diff --git a/apps/common-app/src/apps/reanimated/examples/AmountExample.tsx b/apps/common-app/src/apps/reanimated/examples/AmountExample.tsx
index 498160dc2f64..ea64dce9ad22 100644
--- a/apps/common-app/src/apps/reanimated/examples/AmountExample.tsx
+++ b/apps/common-app/src/apps/reanimated/examples/AmountExample.tsx
@@ -1,14 +1,11 @@
 import React, { useCallback } from 'react';
-import { Button, StyleSheet, TextInput, View } from 'react-native';
+import { Button, StyleSheet, View } from 'react-native';
 import Animated, {
   useAnimatedProps,
-  useDerivedValue,
   useSharedValue,
   withTiming,
 } from 'react-native-reanimated';
 
-const AnimatedTextInput = Animated.createAnimatedComponent(TextInput);
-
 const DELTAS = [-100, -10, -1, 1, 10, 100];
 
 export default function AmountExample() {
@@ -16,12 +13,8 @@ export default function AmountExample() {
 
   const sv = useSharedValue(ref.current);
 
-  const text = useDerivedValue(() => {
-    return `$${sv.value.toFixed(2)}`;
-  });
-
   const animatedProps = useAnimatedProps(() => {
-    return { text: text.value, defaultValue: text.value };
+    return { text: `$${sv.value.toFixed(2)}` };
   });
 
   const setValue = useCallback(
@@ -36,12 +29,7 @@ export default function AmountExample() {
 
   return (
     <View style={styles.container}>
-      <AnimatedTextInput
-        animatedProps={animatedProps}
-        style={styles.text}
-        editable={false}
-        underlineColorAndroid="transparent"
-      />
+      <Animated.Text animatedProps={animatedProps} style={styles.text} />
       <View style={styles.row}>
         {DELTAS.map((delta) => (
           <Button
@@ -65,7 +53,6 @@ const styles = StyleSheet.create({
     fontSize: 80,
     fontWeight: 'bold',
     fontVariant: ['tabular-nums'],
-    textAlign: 'center',
   },
   row: {
     flexDirection: 'row',
diff --git a/apps/common-app/src/apps/reanimated/examples/AnimatedKeyboardExample.tsx b/apps/common-app/src/apps/reanimated/examples/AnimatedKeyboardExample.tsx
index c0243483574f..8506c1c577c9 100644
--- a/apps/common-app/src/apps/reanimated/examples/AnimatedKeyboardExample.tsx
+++ b/apps/common-app/src/apps/reanimated/examples/AnimatedKeyboardExample.tsx
@@ -15,8 +15,6 @@ import Animated, {
   useAnimatedStyle,
 } from 'react-native-reanimated';
 
-const AnimatedTextInput = Animated.createAnimatedComponent(TextInput);
-
 const KeyboardStateNames = {
   [KeyboardState.UNKNOWN]: 'UNKNOWN',
   [KeyboardState.OPENING]: 'OPENING',
@@ -57,13 +55,15 @@ export default function AnimatedKeyboardExample() {
   });
 
   const animatedHeightProps = useAnimatedProps(() => {
-    const text = `Keyboard height: ${keyboard.height.value}`;
-    return { text, defaultValue: text };
+    return {
+      text: `Keyboard height: ${keyboard.height.value}`,
+    };
   });
 
   const animatedStateProps = useAnimatedProps(() => {
-    const text = `Keyboard state: ${KeyboardStateNames[keyboard.state.value]} - ${keyboard.state.value}`;
-    return { text, defaultValue: text };
+    return {
+      text: `Keyboard state: ${KeyboardStateNames[keyboard.state.value]} - ${keyboard.state.value}`,
+    };
   });
 
   return (
@@ -98,14 +98,12 @@ export default function AnimatedKeyboardExample() {
         </TouchableOpacity>
       </Animated.View>
       <View style={styles.infoContainer}>
-        <AnimatedTextInput
+        <Animated.Text
           style={styles.infoText}
-          editable={false}
           animatedProps={animatedHeightProps}
         />
-        <AnimatedTextInput
+        <Animated.Text
           style={styles.infoText}
-          editable={false}
           animatedProps={animatedStateProps}
         />
       </View>
@@ -127,7 +125,6 @@ const styles = StyleSheet.create({
   },
   infoText: {
     fontWeight: '700',
-    width: '100%',
   },
   accessoryBar: {
     position: 'absolute',
diff --git a/apps/common-app/src/apps/reanimated/examples/AnimatedTextExample.tsx b/apps/common-app/src/apps/reanimated/examples/AnimatedTextExample.tsx
new file mode 100644
index 000000000000..f377e143dd18
--- /dev/null
+++ b/apps/common-app/src/apps/reanimated/examples/AnimatedTextExample.tsx
@@ -0,0 +1,216 @@
+import React, { useEffect, useState } from 'react';
+import { Button, ScrollView, StyleSheet, Text, View } from 'react-native';
+import Animated, {
+  interpolate,
+  useAnimatedProps,
+  useAnimatedStyle,
+  useDerivedValue,
+  useSharedValue,
+  withRepeat,
+  withTiming,
+} from 'react-native-reanimated';
+
+// TODO: add support for the following syntax: <Animated.Text>{sharedValue}</Animated.Text>
+// TODO: add support for the following syntax: <Animated.Text>Before {sharedValue} After</Animated.Text>
+// TODO: add TypeScript validation that allows <Animated.Text> to either have children or have `text` animated prop
+// TODO: add gauges example
+// TODO: sync `text` prop updates back to React as `children` prop
+// TODO: add docs about Animated.Text
+// TODO: convert docs examples from AnimatedTextInput to Animated.Text
+
+export default function AnimatedTextExample() {
+  const sv = useSharedValue(0);
+
+  useEffect(() => {
+    sv.value = 0;
+    sv.value = withRepeat(withTiming(1, { duration: 1000 }), -1, true);
+  }, [sv]);
+
+  const textSv = useDerivedValue(() => {
+    return String(Math.round(sv.value * 100));
+  });
+
+  const stringAnimatedProps = useAnimatedProps(() => {
+    return {
+      text: `${Math.round(sv.value * 100)}%`, // string
+    };
+  });
+
+  const numberAnimatedProps = useAnimatedProps(() => {
+    return {
+      text: Math.round(sv.value * 100), // number
+    };
+  });
+
+  const emptyAnimatedProps = useAnimatedProps(() => {
+    return {
+      text: sv.value > 0.5 ? 'Blink' : '', // empty string sometimes
+    };
+  });
+
+  const animatedStyle = useAnimatedStyle(() => {
+    return {
+      fontSize: interpolate(sv.value, [0, 1], [10, 20]),
+    };
+  });
+
+  const [show, setShow] = useState(false);
+
+  return (
+    <ScrollView contentContainerStyle={styles.container}>
+      {/* Animated text is an inline prop */}
+      {/* TODO: fix this example not working after fast refresh */}
+      <View style={styles.row}>
+        <Text>Before</Text>
+        <Animated.Text
+          text={textSv}
+          style={[styles.tabularNums, styles.color0]}
+        />
+        <Text>After</Text>
+      </View>
+
+      {/* Animated text is a string */}
+      <View style={styles.row}>
+        <Text>Before</Text>
+        <Animated.Text
+          animatedProps={stringAnimatedProps}
+          style={[styles.tabularNums, styles.color1]}
+        />
+        <Text>After</Text>
+      </View>
+
+      {/* Animated text is a number */}
+      <View style={styles.row}>
+        <Text>Before</Text>
+        <Animated.Text
+          animatedProps={numberAnimatedProps}
+          style={[styles.tabularNums, styles.color2]}
+        />
+        <Text>After</Text>
+      </View>
+
+      {/* Animated text is an empty string during first render */}
+      <View style={styles.row}>
+        <Text>Before</Text>
+        <Animated.Text
+          animatedProps={emptyAnimatedProps}
+          style={[styles.tabularNums, styles.color3]}
+        />
+        <Text>After</Text>
+      </View>
+
+      {/* With animated style */}
+      <View style={styles.row}>
+        <Text>Before</Text>
+        <Animated.Text
+          animatedProps={numberAnimatedProps}
+          style={[styles.tabularNums, styles.color4, animatedStyle]}
+        />
+        <Text>After</Text>
+      </View>
+
+      {/* Inside another Text component */}
+      <View style={styles.row}>
+        <Text style={styles.italic}>
+          Before
+          <Animated.Text
+            animatedProps={numberAnimatedProps}
+            style={[styles.tabularNums, styles.color5]}
+          />
+          After
+        </Text>
+      </View>
+
+      {/* Inside another Animated.Text */}
+      <View style={styles.row}>
+        <Animated.Text style={styles.italic}>
+          Before
+          <Animated.Text
+            animatedProps={numberAnimatedProps}
+            style={[styles.tabularNums, styles.color6]}
+          />
+          After
+        </Animated.Text>
+      </View>
+
+      {/* Inside another Animated.Text with animatedStyle */}
+      <View style={styles.row}>
+        <Animated.Text style={[styles.italic, animatedStyle]}>
+          Before
+          <Animated.Text
+            animatedProps={numberAnimatedProps}
+            style={[styles.tabularNums, styles.color7]}
+          />
+          After
+        </Animated.Text>
+      </View>
+
+      {/* Non-empty Animated.Text */}
+      <View style={styles.row}>
+        <Animated.Text>Lorem ipsum</Animated.Text>
+      </View>
+
+      {/* Non-empty Animated.Text with animated style */}
+      <View style={styles.row}>
+        <Animated.Text style={animatedStyle}>Lorem ipsum</Animated.Text>
+      </View>
+
+      {/* Non-empty Animated.Text with animated text (throws an error) */}
+      <View style={styles.row}>
+        {show && (
+          // @ts-expect-error We don't want to accept text in animatedProps when children are present
+          <Animated.Text animatedProps={stringAnimatedProps}>
+            Lorem ipsum
+          </Animated.Text>
+        )}
+        <Button
+          title="Render non-empty Animated.Text with animated text (throws an error)"
+          onPress={() => setShow(true)}
+        />
+      </View>
+    </ScrollView>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  row: {
+    flexDirection: 'row',
+    alignItems: 'baseline',
+    marginBottom: 30,
+  },
+  tabularNums: {
+    fontVariant: ['tabular-nums'],
+  },
+  italic: {
+    fontStyle: 'italic',
+  },
+  color0: {
+    backgroundColor: 'burlywood',
+  },
+  color1: {
+    backgroundColor: 'pink',
+  },
+  color2: {
+    backgroundColor: 'peachpuff',
+  },
+  color3: {
+    backgroundColor: 'khaki',
+  },
+  color4: {
+    backgroundColor: 'palegreen',
+  },
+  color5: {
+    backgroundColor: 'lightskyblue',
+  },
+  color6: {
+    backgroundColor: 'lightsteelblue',
+  },
+  color7: {
+    backgroundColor: 'thistle',
+  },
+});
diff --git a/apps/common-app/src/apps/reanimated/examples/AnimatedTextInputExample.tsx b/apps/common-app/src/apps/reanimated/examples/AnimatedTextInputExample.tsx
new file mode 100644
index 000000000000..34d87d8ec5ae
--- /dev/null
+++ b/apps/common-app/src/apps/reanimated/examples/AnimatedTextInputExample.tsx
@@ -0,0 +1,51 @@
+import React, { useEffect } from 'react';
+import { StyleSheet, TextInput, View } from 'react-native';
+import Animated, {
+  useAnimatedProps,
+  useSharedValue,
+  withRepeat,
+  withTiming,
+} from 'react-native-reanimated';
+
+// NOTE: It is recommended to use <Animated.Text> component instead of AnimatedTextInput for text animations.
+
+const AnimatedTextInput = Animated.createAnimatedComponent(TextInput);
+
+export default function AnimatedTextInputExample() {
+  const sv = useSharedValue(0);
+
+  useEffect(() => {
+    sv.value = 0;
+    sv.value = withRepeat(withTiming(100, { duration: 1500 }), -1, true);
+  }, [sv]);
+
+  const animatedProps = useAnimatedProps(() => {
+    return {
+      text: `${Math.round(sv.value)}`,
+      defaultValue: `${Math.round(sv.value)}`,
+    };
+  });
+
+  return (
+    <View style={styles.container}>
+      <AnimatedTextInput
+        animatedProps={animatedProps}
+        style={styles.input}
+        editable={false}
+        underlineColorAndroid="transparent"
+      />
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+  },
+  input: {
+    fontSize: 100,
+    textAlign: 'center',
+    fontVariant: ['tabular-nums'],
+  },
+});
diff --git a/apps/common-app/src/apps/reanimated/examples/CircularSliderExample.tsx b/apps/common-app/src/apps/reanimated/examples/CircularSliderExample.tsx
index 96ed7d7c757f..c783c6a819dc 100644
--- a/apps/common-app/src/apps/reanimated/examples/CircularSliderExample.tsx
+++ b/apps/common-app/src/apps/reanimated/examples/CircularSliderExample.tsx
@@ -13,7 +13,6 @@ import { scheduleOnRN } from 'react-native-worklets';
 
 const AnimatedPath = Animated.createAnimatedComponent(Path);
 const AnimatedCircle = Animated.createAnimatedComponent(Circle);
-const AnimatedInput = Animated.createAnimatedComponent(TextInput);
 
 interface Point {
   x: number;
@@ -109,9 +108,8 @@ function CircularSlider(props: CircularSliderProps) {
     };
   });
 
-  const animatedInputProps = useAnimatedProps(() => {
-    const text = String(currentValue.value);
-    return { text, defaultValue: text };
+  const animatedProps = useAnimatedProps(() => {
+    return { text: String(currentValue.value) };
   });
 
   const gesture = Gesture.Pan()
@@ -152,11 +150,7 @@ function CircularSlider(props: CircularSliderProps) {
           </Svg>
         </Animated.View>
       </GestureDetector>
-      <AnimatedInput
-        editable={false}
-        animatedProps={animatedInputProps}
-        style={styles.input}
-      />
+      <Animated.Text animatedProps={animatedProps} style={styles.text} />
     </>
   );
 }
@@ -188,7 +182,7 @@ const styles = StyleSheet.create({
     alignItems: 'center',
     justifyContent: 'center',
   },
-  input: {
+  text: {
     fontSize: 80,
     fontVariant: ['tabular-nums'],
     position: 'absolute',
diff --git a/apps/common-app/src/apps/reanimated/examples/CounterExample.tsx b/apps/common-app/src/apps/reanimated/examples/CounterExample.tsx
index b533ab49d56f..eceba83c3e2e 100644
--- a/apps/common-app/src/apps/reanimated/examples/CounterExample.tsx
+++ b/apps/common-app/src/apps/reanimated/examples/CounterExample.tsx
@@ -1,5 +1,5 @@
 import React from 'react';
-import { Button, StyleSheet, TextInput, View } from 'react-native';
+import { Button, StyleSheet, View } from 'react-native';
 import Animated, {
   useAnimatedProps,
   useDerivedValue,
@@ -7,8 +7,6 @@ import Animated, {
   withTiming,
 } from 'react-native-reanimated';
 
-const AnimatedTextInput = Animated.createAnimatedComponent(TextInput);
-
 export default function CounterExample() {
   const ref = React.useRef(0);
 
@@ -19,7 +17,7 @@ export default function CounterExample() {
   });
 
   const animatedProps = useAnimatedProps(() => {
-    return { text: text.value, defaultValue: text.value };
+    return { text: text.value };
   });
 
   const handleToggle = () => {
@@ -32,11 +30,7 @@ export default function CounterExample() {
       <View style={styles.buttons}>
         <Button onPress={handleToggle} title="Toggle" />
       </View>
-      <AnimatedTextInput
-        animatedProps={animatedProps}
-        style={styles.text}
-        editable={false}
-      />
+      <Animated.Text animatedProps={animatedProps} style={styles.text} />
     </>
   );
 }
diff --git a/apps/common-app/src/apps/reanimated/examples/CustomHandler/AnimatedText.tsx b/apps/common-app/src/apps/reanimated/examples/CustomHandler/AnimatedText.tsx
index 98880b91bb78..878c41ef7dbf 100644
--- a/apps/common-app/src/apps/reanimated/examples/CustomHandler/AnimatedText.tsx
+++ b/apps/common-app/src/apps/reanimated/examples/CustomHandler/AnimatedText.tsx
@@ -1,11 +1,9 @@
 import React from 'react';
-import type { StyleProp, TextInputProps, TextStyle } from 'react-native';
-import { StyleSheet, TextInput } from 'react-native';
+import type { StyleProp, TextStyle } from 'react-native';
+import { StyleSheet } from 'react-native';
 import type { AnimatedStyle, SharedValue } from 'react-native-reanimated';
 import Animated, { useAnimatedProps } from 'react-native-reanimated';
 
-const AnimatedTextInput = Animated.createAnimatedComponent(TextInput);
-
 export function AnimatedText({
   style,
   text,
@@ -14,17 +12,11 @@ export function AnimatedText({
   text: SharedValue<string>;
 }) {
   const animatedProps = useAnimatedProps(() => {
-    return { text: text.value } as unknown as TextInputProps;
+    return { text: text.value };
   });
 
   return (
-    <AnimatedTextInput
-      underlineColorAndroid="transparent"
-      editable={false}
-      value={text.value}
-      style={[styles.text, style]}
-      animatedProps={animatedProps}
-    />
+    <Animated.Text animatedProps={animatedProps} style={[styles.text, style]} />
   );
 }
 
diff --git a/apps/common-app/src/apps/reanimated/examples/EmptyExample.tsx b/apps/common-app/src/apps/reanimated/examples/EmptyExample.tsx
index 7f3a1ac26ce1..d374e2cfc506 100644
--- a/apps/common-app/src/apps/reanimated/examples/EmptyExample.tsx
+++ b/apps/common-app/src/apps/reanimated/examples/EmptyExample.tsx
@@ -1,10 +1,65 @@
-import React from 'react';
+import React, { useEffect, useState } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
+import Animated, {
+  useAnimatedProps,
+  useDerivedValue,
+  useSharedValue,
+  withRepeat,
+  withTiming,
+} from 'react-native-reanimated';
+
+function Counter() {
+  const [a, setA] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => {
+      setA((a) => a + 1);
+    }, 1000);
+    return () => clearInterval(id);
+  }, []);
+  console.log('AnimatedTextExample render', a);
+
+  return <Text>Count: {a}</Text>;
+}
 
 export default function EmptyExample() {
+  const sv = useSharedValue(0);
+
+  const textSv = useDerivedValue(() => {
+    return String(Math.round(sv.value));
+  });
+
+  useEffect(() => {
+    sv.value = 0;
+    sv.value = withRepeat(withTiming(100, { duration: 1000 }), -1, true);
+  }, [sv]);
+
+  const [a, setA] = useState(0);
+
+  useEffect(() => {
+    const id = setInterval(() => {
+      setA((a) => a + 1);
+    }, 1000);
+    return () => clearInterval(id);
+  }, []);
+
+  // const animatedProps = useAnimatedProps(() => {
+  //   return {
+  //     text: textSv.value,
+  //   };
+  // });
+
   return (
     <View style={styles.container}>
-      <Text>Hello world!</Text>
+      {/* <Counter /> */}
+      <Animated.Text
+        // animatedProps={animatedProps}
+        text={textSv}
+        style={{
+          fontVariant: ['tabular-nums'],
+          fontSize: 40,
+          backgroundColor: 'lightblue',
+        }}
+      />
     </View>
   );
 }
diff --git a/apps/common-app/src/apps/reanimated/examples/FpsExample.tsx b/apps/common-app/src/apps/reanimated/examples/FpsExample.tsx
index 6d2c09f06959..9e045853c7d8 100644
--- a/apps/common-app/src/apps/reanimated/examples/FpsExample.tsx
+++ b/apps/common-app/src/apps/reanimated/examples/FpsExample.tsx
@@ -1,7 +1,8 @@
-import React, { useCallback, useEffect } from 'react';
+import React, { useCallback } from 'react';
 import { StyleSheet, Text, View } from 'react-native';
-import {
+import Animated, {
   FrameInfo,
+  useAnimatedProps,
   useFrameCallback,
   useSharedValue,
 } from 'react-native-reanimated';
@@ -25,43 +26,68 @@ export default function FpsExample() {
     )
   );
 
-  const [frameInfo, setFrameInfo] = React.useState<FrameInfo | null>(null);
+  const timestampAnimatedProps = useAnimatedProps(() => {
+    return {
+      text: String(frameInfoSharedValue.value?.timestamp.toFixed(6)),
+    };
+  });
 
-  useEffect(() => {
-    const id = setInterval(() => {
-      setFrameInfo(frameInfoSharedValue.value);
-    }, 0);
-    return () => clearInterval(id);
-  }, [frameInfoSharedValue]);
+  const timeSinceFirstFrameAnimatedProps = useAnimatedProps(() => {
+    return {
+      text: String(frameInfoSharedValue.value?.timeSinceFirstFrame.toFixed(6)),
+    };
+  });
+
+  const timeSincePreviousFrameAnimatedProps = useAnimatedProps(() => {
+    const frameInfo = frameInfoSharedValue.value;
+    return {
+      text:
+        frameInfo !== null && frameInfo.timeSincePreviousFrame !== null
+          ? String(frameInfo.timeSincePreviousFrame.toFixed(6))
+          : 'null',
+    };
+  });
+
+  const framesPerSecondAnimatedProps = useAnimatedProps(() => {
+    const frameInfo = frameInfoSharedValue.value;
+    return {
+      text:
+        frameInfo !== null && frameInfo.timeSincePreviousFrame !== null
+          ? String((1000 / frameInfo.timeSincePreviousFrame).toFixed(2))
+          : 'unknown',
+    };
+  });
 
   return (
     <View style={styles.container}>
-      <Text>
-        Timestamp:{' '}
-        <Text style={styles.number}>{frameInfo?.timestamp.toFixed(6)}</Text>
-      </Text>
-      <Text>
-        Time since first frame:{' '}
-        <Text style={styles.number}>
-          {frameInfo?.timeSinceFirstFrame.toFixed(6)}
-        </Text>
-      </Text>
-      <Text>
-        Time since previous frame:{' '}
-        <Text style={styles.number}>
-          {frameInfo !== null && frameInfo.timeSincePreviousFrame !== null
-            ? frameInfo.timeSincePreviousFrame.toFixed(6)
-            : 'null'}
-        </Text>
-      </Text>
-      <Text>
-        Frames per second:{' '}
-        <Text style={styles.number}>
-          {frameInfo !== null && frameInfo.timeSincePreviousFrame !== null
-            ? (1000 / frameInfo.timeSincePreviousFrame).toFixed(2)
-            : 'unknown'}
-        </Text>
-      </Text>
+      <View style={styles.row}>
+        <Text>Timestamp:</Text>
+        <Animated.Text
+          animatedProps={timestampAnimatedProps}
+          style={styles.number}
+        />
+      </View>
+      <View style={styles.row}>
+        <Text>Time since first frame:</Text>
+        <Animated.Text
+          animatedProps={timeSinceFirstFrameAnimatedProps}
+          style={styles.number}
+        />
+      </View>
+      <View style={styles.row}>
+        <Text>Time since previous frame:</Text>
+        <Animated.Text
+          animatedProps={timeSincePreviousFrameAnimatedProps}
+          style={styles.number}
+        />
+      </View>
+      <View style={styles.row}>
+        <Text>Frames per second:</Text>
+        <Animated.Text
+          animatedProps={framesPerSecondAnimatedProps}
+          style={styles.number}
+        />
+      </View>
     </View>
   );
 }
@@ -75,5 +101,10 @@ const styles = StyleSheet.create({
   number: {
     fontSize: 24,
     fontVariant: ['tabular-nums'],
+    marginLeft: 4,
+  },
+  row: {
+    flexDirection: 'row',
+    alignItems: 'baseline',
   },
 });
diff --git a/apps/common-app/src/apps/reanimated/examples/SvgExample.tsx b/apps/common-app/src/apps/reanimated/examples/SvgExample.tsx
index 93d28b1f0c43..b22e3f10b995 100644
--- a/apps/common-app/src/apps/reanimated/examples/SvgExample.tsx
+++ b/apps/common-app/src/apps/reanimated/examples/SvgExample.tsx
@@ -1,7 +1,8 @@
-import React from 'react';
+import React, { useEffect, useState } from 'react';
 import { StyleSheet, View } from 'react-native';
 import Animated, {
   useAnimatedProps,
+  useDerivedValue,
   useSharedValue,
   withRepeat,
   withTiming,
@@ -13,14 +14,24 @@ const AnimatedCircle = Animated.createAnimatedComponent(Circle);
 export default function SvgExample() {
   const sv = useSharedValue(0);
 
-  sv.value = withRepeat(withTiming(1, { duration: 500 }), -1, true);
+  useEffect(() => {
+    sv.value = 0;
+    sv.value = withRepeat(withTiming(1, { duration: 500 }), -1, true);
+  }, [sv]);
+
+  const rSv = useDerivedValue(() => `${12 + sv.value * 38}%`);
 
   const animatedProps = useAnimatedProps(() => {
-    return {
-      r: `${1 + sv.value * 49}%`,
-    };
+    return { r: rSv.value };
   });
 
+  const [, setCount] = useState(0);
+  r;
+  useEffect(() => {
+    const id = setInterval(() => setCount((c) => c + 1), 1000);
+    return () => clearInterval(id);
+  }, []);
+
   return (
     <View style={styles.container}>
       <Svg height="200" width="200">
@@ -28,7 +39,8 @@ export default function SvgExample() {
           cx="50%"
           cy="50%"
           fill="lime"
-          animatedProps={animatedProps}
+          // animatedProps={animatedProps}
+          r={rSv}
         />
       </Svg>
     </View>
diff --git a/apps/common-app/src/apps/reanimated/examples/ThirdPartyComponentsExample.tsx b/apps/common-app/src/apps/reanimated/examples/ThirdPartyComponentsExample.tsx
index 6714133cdd17..6e7d26288811 100644
--- a/apps/common-app/src/apps/reanimated/examples/ThirdPartyComponentsExample.tsx
+++ b/apps/common-app/src/apps/reanimated/examples/ThirdPartyComponentsExample.tsx
@@ -1,5 +1,5 @@
 import React, { useEffect } from 'react';
-import { ScrollView, StyleSheet, Text, TextInput, View } from 'react-native';
+import { ScrollView, StyleSheet, Text, View } from 'react-native';
 import type { SharedValue } from 'react-native-reanimated';
 import Animated, {
   Easing,
@@ -11,28 +11,6 @@ import Animated, {
 } from 'react-native-reanimated';
 import { Circle, G, Path, Polygon, Rect, Svg } from 'react-native-svg';
 
-const AnimatedTextInput = Animated.createAnimatedComponent(TextInput);
-
-function TextInputDemo({ sv }: { sv: SharedValue<number> }) {
-  const animatedProps = useAnimatedProps(() => {
-    return {
-      text: `${Math.round(sv.value * 100)}`,
-      defaultValue: `${Math.round(sv.value * 100)}`,
-    };
-  }, []);
-
-  return (
-    <View style={styles.demo}>
-      <Text style={styles.text}>AnimatedTextInput</Text>
-      <AnimatedTextInput
-        animatedProps={animatedProps}
-        style={styles.input}
-        editable={false}
-      />
-    </View>
-  );
-}
-
 const AnimatedCircle = Animated.createAnimatedComponent(Circle);
 
 function SvgCircleDemo({ sv }: { sv: SharedValue<number> }) {
@@ -172,7 +150,6 @@ export default function ThirdPartyComponentsExample() {
 
   return (
     <ScrollView contentContainerStyle={styles.container}>
-      <TextInputDemo sv={sv} />
       <SvgCircleDemo sv={sv} />
       <SvgRectDemo sv={sv} />
       <SvgPathDemo sv={sv} />
@@ -195,9 +172,4 @@ const styles = StyleSheet.create({
   text: {
     textAlign: 'center',
   },
-  input: {
-    fontSize: 100,
-    textAlign: 'center',
-    width: 200,
-  },
 });
diff --git a/apps/common-app/src/apps/reanimated/examples/index.ts b/apps/common-app/src/apps/reanimated/examples/index.ts
index 22efd7dc57fb..20d7119f4c29 100644
--- a/apps/common-app/src/apps/reanimated/examples/index.ts
+++ b/apps/common-app/src/apps/reanimated/examples/index.ts
@@ -9,6 +9,8 @@ import AnimatedSensorMagneticFieldExample from './AnimatedSensorMagneticFieldExa
 import AnimatedSensorRotationExample from './AnimatedSensorRotationExample';
 import AnimatedStyleUpdateExample from './AnimatedStyleUpdateExample';
 import AnimatedTabBarExample from './AnimatedTabBarExample';
+import AnimatedTextExample from './AnimatedTextExample';
+import AnimatedTextInputExample from './AnimatedTextInputExample';
 import AnimatedTextWidthExample from './AnimatedTextWidthExample';
 import ArticleProgressExample from './ArticleProgressExample';
 import BabelVersionCheckExample from './BabelVersionCheckExample';
@@ -199,6 +201,16 @@ export const EXAMPLES: Record<string, Example> = {
     title: 'FPS',
     screen: FpsExample,
   },
+  AnimatedTextExample: {
+    icon: '📝',
+    title: 'Animated text',
+    screen: AnimatedTextExample,
+  },
+  AnimatedTextInputExample: {
+    icon: '⌨️',
+    title: 'Animated text input',
+    screen: AnimatedTextInputExample,
+  },
   SyncBackToReactExample: {
     icon: '🔄',
     title: 'Sync back to React',
diff --git a/docs/docs-reanimated/docs/guides/performance.md b/docs/docs-reanimated/docs/guides/performance.md
index 2cf2bd38ff01..3875bc13e5c7 100644
--- a/docs/docs-reanimated/docs/guides/performance.md
+++ b/docs/docs-reanimated/docs/guides/performance.md
@@ -123,10 +123,6 @@ const pan = useMemo(
 );
 ```
 
-### 💡 Animate `TextInput` instead of re-rendering `Text` component
+### 💡 Use `Animated.Text` instead of re-rendering `Text` component
 
-When implementing an animated number counter, don't use React state to periodically update the counter. Instead, store the number in a shared value and use an animated `TextInput` component to display the current value. For more details, see [this example](https://github.com/software-mansion/react-native-reanimated/blob/main/apps/common-app/src/apps/reanimated/examples/CounterExample.tsx).
-
-```
-
-```
+When implementing text animations (e.g. animated counters), don't use React state to periodically update the counter. Instead, store the number in a shared value and use an `Animated.Text` component with animated `text` prop using [`useAnimatedProps`](/docs/core/useAnimatedProps) or inline props in order to display the current value. For more details, see [Text animations](/docs/guides/text-animations) guide.
diff --git a/docs/docs-reanimated/docs/guides/text-animations.mdx b/docs/docs-reanimated/docs/guides/text-animations.mdx
new file mode 100644
index 000000000000..0ae266b1941a
--- /dev/null
+++ b/docs/docs-reanimated/docs/guides/text-animations.mdx
@@ -0,0 +1,102 @@
+---
+id: text-animations
+title: Text animations
+sidebar_label: Text animations
+---
+
+# Text animations
+
+This guide explains how to animate text using Reanimated. In particular, it focuses on the type of text animations in which the sequence of characters changes between individual animation frames, like in a stopwatch or a digital speedometer.
+
+## Animating text style
+
+For animating text style (e.g. text color, font size or text shadow), you need to use [`useAnimatedStyle`](/docs/core/useAnimatedStyle) hook and pass the animated styles to `Animated.Text` component just like you would do with any other animated component.
+
+## Animating text content
+
+For animating the text content itself, you need to choose one of the approaches described below.
+
+### Using `Animated.Text` <AvailableFrom version="4.2.0" />
+
+The recommended approach is to animate the `text` property of `Animated.Text` component using [`useAnimatedProps`](/docs/core/useAnimatedProps) hook.
+
+The `Animated.Text` component with animated `text` property must have no children. The current value of `text` animated prop will be passed as the children during the first render and will be updated accordingly on the UI thread without triggering a React render afterwards.
+
+For convenience, the value of `text` property can also be a number. Reanimated will automatically perform the string conversion under the hood. However, it is recommended to manually format the value using [`Math.round()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round) function or [`.toFixed()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) method.
+
+In particular, the `text` property may be an empty string. If the value of `text` property is an empty string during the initial render, Reanimated will pass a [zero-width space character](https://en.wikipedia.org/wiki/Zero-width_space) as children prop to force the creation of the text content shadow node. This is an implementation detail and should not affect the behavior of the component.
+
+This approach also works in case of nested text, when the `Animated.Text` component is placed inside another `Text` component or even `Animated.Text` component with animated style.
+
+For more cases, please refer to [this demo](https://github.com/software-mansion/react-native-reanimated/blob/main/apps/common-app/src/apps/reanimated/examples/AnimatedTextExample.tsx) in our example app.
+
+```tsx
+function Counter() {
+  const sv = useSharedValue(0);
+
+  // ...
+
+  const animatedProps = useAnimatedProps(() => {
+    return {
+      // highlight-next-line
+      text: `Current value: ${Math.round(sv.value)}`,
+    };
+  });
+
+  // highlight-next-line
+  return <Animated.Text animatedProps={animatedProps} />;
+}
+```
+
+Alternatively, you can create another shared value with the desired text using [`useDerivedValue`](/docs/core/useDerivedValue) hook and pass the shared value as inline `text` prop:
+
+```tsx
+function Counter() {
+  // ...
+
+  const text = useDerivedValue(() => {
+    // highlight-next-line
+    return `Current value: ${Math.round(sv.value)}`;
+  });
+
+  // highlight-next-line
+  return <Animated.Text text={text} />;
+}
+```
+
+:::tip
+When animating numbers, it is recommended to apply `fontVariant: ['tabular-nums']` style to the animated counter. This way each digit has the same width which makes the layout stable and reduces the perceived shakiness of the text content, resulting in better user experience.
+:::
+
+### Using `AnimatedTextInput`
+
+Another approach is to animate the value of `TextInput` component. This approach is no longer recommended. In some cases, the contents can be incorrectly cropped resulting in showing the ellipsis instead of the last character. Also, it is prone to crashes during a reload ([link to the issue](https://github.com/software-mansion/react-native-reanimated/issues/7647)).
+
+Reanimated does not expose `Animated.TextInput` on its own, so you need to create an animated component yourself using [`createAnimatedComponent`](/docs/core/createAnimatedComponent) function:
+
+```tsx
+const AnimatedTextInput = Animated.createAnimatedComponent(TextInput);
+```
+
+You need to animate both the `defaultValue` prop (for the initial render) and the `text` prop (for the consecutive animation frames) using [`useAnimatedProps`](/docs/core/useAnimatedProps) hook:
+
+```tsx
+const animatedProps = useAnimatedProps(() => {
+  const text = `Current value: ${Math.round(sv.value)}`;
+  // highlight-next-line
+  return { text, defaultValue: text };
+});
+```
+
+Finally, you can use the `AnimatedTextInput` component with the animated props. Don't forget to set `editable` prop to `false` to disable user interactions as well as set `underlineColorAndroid` to `transparent`.
+
+```tsx
+return (
+  <AnimatedTextInput
+    // highlight-next-line
+    animatedProps={animatedProps}
+    editable={false}
+    underlineColorAndroid="transparent"
+  />
+);
+```
diff --git a/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.cpp b/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.cpp
index ce47b067a604..5bf13596a259 100644
--- a/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.cpp
+++ b/packages/react-native-reanimated/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.cpp
@@ -23,7 +23,31 @@ void AnimatedPropsRegistry::update(jsi::Runtime &rt, const jsi::Value &operation
     auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
 
     const jsi::Value &updates = item.getProperty(rt, "updates");
-    addUpdatesToBatch(shadowNode, jsi::dynamicFromValue(rt, updates));
+    auto props = jsi::dynamicFromValue(rt, updates);
+
+    if (!strcmp(shadowNode->getComponentName(), "Paragraph") || !strcmp(shadowNode->getComponentName(), "Text")) {
+      bool hasTextProp = false;
+      for (const auto &[key, value] : props.items()) {
+        if (key == "text") {
+          hasTextProp = true;
+          // Pass the text prop to child component
+          const auto &childShadowNode = shadowNode->getChildren()[0];
+          react_native_assert(!strcmp(childShadowNode->getComponentName(), "RawText"));
+          addUpdatesToBatch(childShadowNode, folly::dynamic::object("text", value.asString()));
+          if constexpr (StaticFeatureFlags::getFlag("FORCE_REACT_RENDER_FOR_SETTLED_ANIMATIONS")) {
+            timestampMap_[childShadowNode->getTag()] = timestamp;
+          }
+          break;
+        }
+      }
+      if (hasTextProp && props.size() == 1) {
+        // Skip adding empty batch for the parent component
+        continue;
+      }
+      props.erase("text");
+    }
+
+    addUpdatesToBatch(shadowNode, props);
 
     if constexpr (StaticFeatureFlags::getFlag("FORCE_REACT_RENDER_FOR_SETTLED_ANIMATIONS")) {
       timestampMap_[shadowNode->getTag()] = timestamp;
diff --git a/packages/react-native-reanimated/__typetests__/common/AnimatedTextTest.tsx b/packages/react-native-reanimated/__typetests__/common/AnimatedTextTest.tsx
new file mode 100644
index 000000000000..f43d5e7b0ada
--- /dev/null
+++ b/packages/react-native-reanimated/__typetests__/common/AnimatedTextTest.tsx
@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import type React from 'react';
+
+import Animated, { useAnimatedProps, useSharedValue } from '../..';
+
+function AnimatedTextTest() {
+  function AnimatedPropsStringTest() {
+    const animatedProps = useAnimatedProps(() => ({ text: 'string' }));
+    return <Animated.Text animatedProps={animatedProps} />;
+  }
+
+  function AnimatedPropsNumberTest() {
+    const animatedProps = useAnimatedProps(() => ({ text: 123 }));
+    return <Animated.Text animatedProps={animatedProps} />;
+  }
+
+  function InlinePropStringTest() {
+    const sv = useSharedValue('string');
+    return <Animated.Text text={sv} />;
+  }
+
+  function InlinePropNumberTest() {
+    const sv = useSharedValue(123);
+    return <Animated.Text text={sv} />;
+  }
+
+  function AnimatedPropsWithChildrenTest() {
+    const animatedProps = useAnimatedProps(() => ({ text: 'string' }));
+    // @ts-expect-error We don't want to accept text in animatedProps when children are present
+    return <Animated.Text animatedProps={animatedProps}>Hello</Animated.Text>;
+  }
+
+  function InlinePropWithChildrenTest() {
+    const sv = useSharedValue('string');
+    // @ts-expect-error We don't want to accept text prop when children are present
+    return <Animated.Text text={sv}>Hello</Animated.Text>;
+  }
+}
diff --git a/packages/react-native-reanimated/src/ReanimatedModule/js-reanimated/index.ts b/packages/react-native-reanimated/src/ReanimatedModule/js-reanimated/index.ts
index 5025db2cccd0..f3ad2706be15 100644
--- a/packages/react-native-reanimated/src/ReanimatedModule/js-reanimated/index.ts
+++ b/packages/react-native-reanimated/src/ReanimatedModule/js-reanimated/index.ts
@@ -66,6 +66,11 @@ export const _updatePropsJS = (
       // React Native Web 0.19+ no longer provides setNativeProps function,
       // so we need to update DOM nodes directly.
       updatePropsDOM(component, rawStyles, isAnimatedProps);
+
+      // For Animated.Text we need to update textContent directly
+      if ('text' in rawStyles) {
+        (component as ReanimatedHTMLElement).textContent = rawStyles['text'];
+      }
     } else if (Object.keys(component.props).length > 0) {
       Object.keys(component.props).forEach((key) => {
         if (!rawStyles[key]) {
diff --git a/packages/react-native-reanimated/src/component/PerformanceMonitor.tsx b/packages/react-native-reanimated/src/component/PerformanceMonitor.tsx
index 52b68591cfed..33245c3b26e3 100644
--- a/packages/react-native-reanimated/src/component/PerformanceMonitor.tsx
+++ b/packages/react-native-reanimated/src/component/PerformanceMonitor.tsx
@@ -1,11 +1,11 @@
 'use strict';
 
 import { useEffect, useRef } from 'react';
-import { StyleSheet, TextInput, View } from 'react-native';
+import { StyleSheet, View } from 'react-native';
 
-import { createAnimatedComponent } from '../createAnimatedComponent';
 import type { FrameInfo } from '../frameCallback';
 import { useAnimatedProps, useFrameCallback, useSharedValue } from '../hook';
+import { AnimatedText } from './Text';
 
 type CircularBuffer = ReturnType<typeof createCircularDoublesBuffer>;
 function createCircularDoublesBuffer(size: number) {
@@ -46,8 +46,6 @@ function createCircularDoublesBuffer(size: number) {
 
 const DEFAULT_BUFFER_SIZE = 20;
 
-const AnimatedTextInput = createAnimatedComponent(TextInput);
-
 function loopAnimationFrame(fn: (lastTime: number, time: number) => void) {
   let lastTime = 0;
 
@@ -106,17 +104,12 @@ function JsPerformance({ smoothingFrames }: { smoothingFrames: number }) {
   }, [jsFps, totalRenderTime]);
 
   const animatedProps = useAnimatedProps(() => {
-    const text = 'JS: ' + (jsFps.value ?? 'N/A') + ' ';
-    return { text, defaultValue: text };
+    return { text: `JS: ${jsFps.value ?? 'N/A'}` };
   });
 
   return (
     <View style={styles.container}>
-      <AnimatedTextInput
-        style={styles.text}
-        animatedProps={animatedProps}
-        editable={false}
-      />
+      <AnimatedText animatedProps={animatedProps} style={styles.text} />
     </View>
   );
 }
@@ -138,17 +131,12 @@ function UiPerformance({ smoothingFrames }: { smoothingFrames: number }) {
   });
 
   const animatedProps = useAnimatedProps(() => {
-    const text = 'UI: ' + (uiFps.value ?? 'N/A') + ' ';
-    return { text, defaultValue: text };
+    return { text: `UI: ${uiFps.value ?? 'N/A'}` };
   });
 
   return (
     <View style={styles.container}>
-      <AnimatedTextInput
-        style={styles.text}
-        animatedProps={animatedProps}
-        editable={false}
-      />
+      <AnimatedText animatedProps={animatedProps} style={styles.text} />
     </View>
   );
 }
diff --git a/packages/react-native-reanimated/src/component/Text.ts b/packages/react-native-reanimated/src/component/Text.ts
index 3e488352f6b7..a2b3f2da344b 100644
--- a/packages/react-native-reanimated/src/component/Text.ts
+++ b/packages/react-native-reanimated/src/component/Text.ts
@@ -1,7 +1,13 @@
 'use strict';
+import type { ReactNode } from 'react';
+import type { TextProps } from 'react-native';
 import { Text } from 'react-native';
 
+import type { SharedValue } from '../commonTypes';
+import type { AnimatedComponentRef } from '../createAnimatedComponent';
 import { createAnimatedComponent } from '../createAnimatedComponent';
+import type { AddArrayPropertyType } from '../css/types';
+import type { AnimatedProps, AnimatedPropsProp } from '../helperTypes';
 
 // Since createAnimatedComponent return type is ComponentClass that has the props of the argument,
 // but not things like NativeMethods, etc. we need to add them manually by extending the type.
@@ -9,6 +15,29 @@ interface AnimatedTextComplement extends Text {
   getNode(): Text;
 }
 
-export const AnimatedText = createAnimatedComponent(Text);
+type BaseAnimatedTextProps = Omit<
+  AnimatedProps<TextProps>,
+  'animatedProps' | 'ref'
+>;
+
+type BaseAnimatedProps = Partial<AnimatedPropsProp<TextProps>>;
+
+type AnimatedTextProps =
+  | (Omit<BaseAnimatedTextProps, 'children'> & {
+      animatedProps?: AddArrayPropertyType<
+        BaseAnimatedProps & { text?: string | number }
+      >;
+      text?: SharedValue<string> | SharedValue<number>;
+      children?: never;
+    })
+  | (BaseAnimatedTextProps & {
+      animatedProps?: AddArrayPropertyType<BaseAnimatedProps>;
+    });
+
+export const AnimatedText = createAnimatedComponent(Text) as (
+  props: AnimatedTextProps & {
+    ref?: AnimatedComponentRef<typeof Text>;
+  }
+) => ReactNode;
 
 export type AnimatedText = typeof AnimatedText & AnimatedTextComplement;
diff --git a/packages/react-native-reanimated/src/createAnimatedComponent/AnimatedComponent.tsx b/packages/react-native-reanimated/src/createAnimatedComponent/AnimatedComponent.tsx
index f89bef3ca728..c5837e4c64df 100644
--- a/packages/react-native-reanimated/src/createAnimatedComponent/AnimatedComponent.tsx
+++ b/packages/react-native-reanimated/src/createAnimatedComponent/AnimatedComponent.tsx
@@ -5,7 +5,7 @@ import type React from 'react';
 import { StyleSheet } from 'react-native';
 
 import { checkStyleOverwriting, maybeBuild } from '../animationBuilder';
-import { IS_JEST, IS_WEB, logger } from '../common';
+import { IS_JEST, IS_WEB, logger, ReanimatedError } from '../common';
 import type { StyleProps } from '../commonTypes';
 import { LayoutAnimationType } from '../commonTypes';
 import { SkipEnteringContext } from '../component/LayoutAnimationConfig';
@@ -517,6 +517,46 @@ export default class AnimatedComponent
         }
       : {};
 
+    if (
+      this.ChildComponent.displayName === 'Text' &&
+      filteredProps.text !== undefined
+    ) {
+      if (filteredProps.children !== undefined) {
+        throw new ReanimatedError(
+          '<Animated.Text> component with animated prop `text` must be empty.'
+        );
+      }
+      // TODO: handle case when `text` property is not present during initial render but appears later on
+
+      // Pass the current value of animated prop `text` as `children` so that the text displays correctly during first render
+      filteredProps.children =
+        filteredProps.text === ''
+          ? '\u200b' // use zero-width space when text is empty
+          : typeof filteredProps.text === 'number'
+            ? String(filteredProps.text)
+            : filteredProps.text;
+    }
+
+    // if (
+    //   this.ChildComponent.displayName === 'Text' &&
+    //   isSharedValue(this.props.text)
+    // ) {
+    //   filteredProps.children =
+    //     filteredProps.text === ''
+    //       ? '\u200b' // use zero-width space when text is empty
+    //       : typeof filteredProps.text === 'number'
+    //         ? String(filteredProps.text)
+    //         : filteredProps.text;
+    // }
+
+    // if (this.ChildComponent.displayName === 'Text') {
+    //   console.log(filteredProps.text);
+    // }
+
+    if (this.ChildComponent.displayName === 'Circle') {
+      console.log('filteredProps', filteredProps);
+    }
+
     if (FORCE_REACT_RENDER_FOR_SETTLED_ANIMATIONS) {
       const flatStyles = StyleSheet.flatten(filteredProps.style as object);
       const mergedStyles = {
diff --git a/packages/react-native-reanimated/src/createAnimatedComponent/createAnimatedComponent.tsx b/packages/react-native-reanimated/src/createAnimatedComponent/createAnimatedComponent.tsx
index cbe8a1acf21b..a6c9b8edb662 100644
--- a/packages/react-native-reanimated/src/createAnimatedComponent/createAnimatedComponent.tsx
+++ b/packages/react-native-reanimated/src/createAnimatedComponent/createAnimatedComponent.tsx
@@ -15,7 +15,7 @@ import type {
   InitialComponentProps,
 } from './commonTypes';
 
-type AnimatedComponentRef<TInstance> =
+export type AnimatedComponentRef<TInstance> =
   | Ref<ExtractElementRef<TInstance>>
   | (TInstance extends InstanceOrElement ? AnimatedRef<TInstance> : never)
   // Accept untyped AnimatedRef as well to allow passing a reference created
diff --git a/packages/react-native-reanimated/src/createAnimatedComponent/index.ts b/packages/react-native-reanimated/src/createAnimatedComponent/index.ts
index b6c6176ebc3e..fc1ba0fef019 100644
--- a/packages/react-native-reanimated/src/createAnimatedComponent/index.ts
+++ b/packages/react-native-reanimated/src/createAnimatedComponent/index.ts
@@ -1,4 +1,7 @@
 'use strict';
 export type { AnimatedProps } from './commonTypes';
-export type { AnimatedComponentType } from './createAnimatedComponent';
+export type {
+  AnimatedComponentRef,
+  AnimatedComponentType,
+} from './createAnimatedComponent';
 export { createAnimatedComponent } from './createAnimatedComponent';
diff --git a/packages/react-native-reanimated/src/helperTypes.ts b/packages/react-native-reanimated/src/helperTypes.ts
index b29c7abafc83..5091ec3dbcc1 100644
--- a/packages/react-native-reanimated/src/helperTypes.ts
+++ b/packages/react-native-reanimated/src/helperTypes.ts
@@ -94,7 +94,7 @@ type SharedTransitionProps = {
   sharedTransitionStyle?: SharedTransition;
 };
 
-type AnimatedPropsProp<Props extends object> = RestProps<Props> &
+export type AnimatedPropsProp<Props extends object> = RestProps<Props> &
   AnimatedStyleProps<Props> &
   LayoutProps;
 
diff --git a/packages/react-native-worklets/plugin/index.js b/packages/react-native-worklets/plugin/index.js
index 098edfafe915..07da8c3c7f67 100644
--- a/packages/react-native-worklets/plugin/index.js
+++ b/packages/react-native-worklets/plugin/index.js
@@ -1,274 +1,343 @@
-"use strict";
+'use strict';
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
+var __commonJS = (cb, mod) =>
+  function __require() {
+    return (
+      mod ||
+        (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod),
+      mod.exports
+    );
+  };
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
+  if ((from && typeof from === 'object') || typeof from === 'function') {
     for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+var __toESM = (mod, isNodeMode, target) => (
+  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+  __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule
+      ? __defProp(target, 'default', { value: mod, enumerable: true })
+      : target,
+    mod
+  )
+);
 
 // lib/gestureHandlerAutoworkletization.js
 var require_gestureHandlerAutoworkletization = __commonJS({
-  "lib/gestureHandlerAutoworkletization.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.gestureHandlerObjectHooks = exports2.gestureHandlerBuilderMethods = void 0;
+  'lib/gestureHandlerAutoworkletization.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
+    exports2.gestureHandlerObjectHooks = exports2.gestureHandlerBuilderMethods =
+      void 0;
     exports2.isGestureHandlerEventCallback = isGestureHandlerEventCallback;
-    exports2.isGestureObjectEventCallbackMethod = isGestureObjectEventCallbackMethod;
-    var types_12 = require("@babel/types");
+    exports2.isGestureObjectEventCallbackMethod =
+      isGestureObjectEventCallbackMethod;
+    var types_12 = require('@babel/types');
     var gestureHandlerGestureObjects = /* @__PURE__ */ new Set([
-      "Tap",
-      "Pan",
-      "Pinch",
-      "Rotation",
-      "Fling",
-      "LongPress",
-      "ForceTouch",
-      "Native",
-      "Manual",
-      "Race",
-      "Simultaneous",
-      "Exclusive",
-      "Hover"
+      'Tap',
+      'Pan',
+      'Pinch',
+      'Rotation',
+      'Fling',
+      'LongPress',
+      'ForceTouch',
+      'Native',
+      'Manual',
+      'Race',
+      'Simultaneous',
+      'Exclusive',
+      'Hover',
     ]);
     exports2.gestureHandlerBuilderMethods = /* @__PURE__ */ new Set([
-      "onBegin",
-      "onStart",
-      "onEnd",
-      "onFinalize",
-      "onUpdate",
-      "onChange",
-      "onTouchesDown",
-      "onTouchesMove",
-      "onTouchesUp",
-      "onTouchesCancelled"
+      'onBegin',
+      'onStart',
+      'onEnd',
+      'onFinalize',
+      'onUpdate',
+      'onChange',
+      'onTouchesDown',
+      'onTouchesMove',
+      'onTouchesUp',
+      'onTouchesCancelled',
     ]);
     exports2.gestureHandlerObjectHooks = /* @__PURE__ */ new Set([
-      "useTapGesture",
-      "usePanGesture",
-      "usePinchGesture",
-      "useRotationGesture",
-      "useFlingGesture",
-      "useLongPressGesture",
-      "useNativeGesture",
-      "useManualGesture",
-      "useHoverGesture"
+      'useTapGesture',
+      'usePanGesture',
+      'usePinchGesture',
+      'useRotationGesture',
+      'useFlingGesture',
+      'useLongPressGesture',
+      'useNativeGesture',
+      'useManualGesture',
+      'useHoverGesture',
     ]);
     function isGestureHandlerEventCallback(path) {
-      return (0, types_12.isCallExpression)(path.parent) && (0, types_12.isExpression)(path.parent.callee) && isGestureObjectEventCallbackMethod(path.parent.callee);
+      return (
+        (0, types_12.isCallExpression)(path.parent) &&
+        (0, types_12.isExpression)(path.parent.callee) &&
+        isGestureObjectEventCallbackMethod(path.parent.callee)
+      );
     }
     function isGestureObjectEventCallbackMethod(exp) {
-      return (0, types_12.isMemberExpression)(exp) && (0, types_12.isIdentifier)(exp.property) && exports2.gestureHandlerBuilderMethods.has(exp.property.name) && containsGestureObject(exp.object);
+      return (
+        (0, types_12.isMemberExpression)(exp) &&
+        (0, types_12.isIdentifier)(exp.property) &&
+        exports2.gestureHandlerBuilderMethods.has(exp.property.name) &&
+        containsGestureObject(exp.object)
+      );
     }
     function containsGestureObject(exp) {
       if (isGestureObject(exp)) {
         return true;
       }
-      if ((0, types_12.isCallExpression)(exp) && (0, types_12.isMemberExpression)(exp.callee) && containsGestureObject(exp.callee.object)) {
+      if (
+        (0, types_12.isCallExpression)(exp) &&
+        (0, types_12.isMemberExpression)(exp.callee) &&
+        containsGestureObject(exp.callee.object)
+      ) {
         return true;
       }
       return false;
     }
     function isGestureObject(exp) {
-      return (0, types_12.isCallExpression)(exp) && (0, types_12.isMemberExpression)(exp.callee) && (0, types_12.isIdentifier)(exp.callee.object) && exp.callee.object.name === "Gesture" && (0, types_12.isIdentifier)(exp.callee.property) && gestureHandlerGestureObjects.has(exp.callee.property.name);
-    }
-  }
+      return (
+        (0, types_12.isCallExpression)(exp) &&
+        (0, types_12.isMemberExpression)(exp.callee) &&
+        (0, types_12.isIdentifier)(exp.callee.object) &&
+        exp.callee.object.name === 'Gesture' &&
+        (0, types_12.isIdentifier)(exp.callee.property) &&
+        gestureHandlerGestureObjects.has(exp.callee.property.name)
+      );
+    }
+  },
 });
 
 // lib/layoutAnimationAutoworkletization.js
 var require_layoutAnimationAutoworkletization = __commonJS({
-  "lib/layoutAnimationAutoworkletization.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/layoutAnimationAutoworkletization.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.isLayoutAnimationCallback = isLayoutAnimationCallback;
-    var types_12 = require("@babel/types");
+    var types_12 = require('@babel/types');
     var EntryExitAnimations = /* @__PURE__ */ new Set([
-      "BounceIn",
-      "BounceInDown",
-      "BounceInLeft",
-      "BounceInRight",
-      "BounceInUp",
-      "BounceOut",
-      "BounceOutDown",
-      "BounceOutLeft",
-      "BounceOutRight",
-      "BounceOutUp",
-      "FadeIn",
-      "FadeInDown",
-      "FadeInLeft",
-      "FadeInRight",
-      "FadeInUp",
-      "FadeOut",
-      "FadeOutDown",
-      "FadeOutLeft",
-      "FadeOutRight",
-      "FadeOutUp",
-      "FlipInEasyX",
-      "FlipInEasyY",
-      "FlipInXDown",
-      "FlipInXUp",
-      "FlipInYLeft",
-      "FlipInYRight",
-      "FlipOutEasyX",
-      "FlipOutEasyY",
-      "FlipOutXDown",
-      "FlipOutXUp",
-      "FlipOutYLeft",
-      "FlipOutYRight",
-      "LightSpeedInLeft",
-      "LightSpeedInRight",
-      "LightSpeedOutLeft",
-      "LightSpeedOutRight",
-      "PinwheelIn",
-      "PinwheelOut",
-      "RollInLeft",
-      "RollInRight",
-      "RollOutLeft",
-      "RollOutRight",
-      "RotateInDownLeft",
-      "RotateInDownRight",
-      "RotateInUpLeft",
-      "RotateInUpRight",
-      "RotateOutDownLeft",
-      "RotateOutDownRight",
-      "RotateOutUpLeft",
-      "RotateOutUpRight",
-      "SlideInDown",
-      "SlideInLeft",
-      "SlideInRight",
-      "SlideInUp",
-      "SlideOutDown",
-      "SlideOutLeft",
-      "SlideOutRight",
-      "SlideOutUp",
-      "StretchInX",
-      "StretchInY",
-      "StretchOutX",
-      "StretchOutY",
-      "ZoomIn",
-      "ZoomInDown",
-      "ZoomInEasyDown",
-      "ZoomInEasyUp",
-      "ZoomInLeft",
-      "ZoomInRight",
-      "ZoomInRotate",
-      "ZoomInUp",
-      "ZoomOut",
-      "ZoomOutDown",
-      "ZoomOutEasyDown",
-      "ZoomOutEasyUp",
-      "ZoomOutLeft",
-      "ZoomOutRight",
-      "ZoomOutRotate",
-      "ZoomOutUp"
+      'BounceIn',
+      'BounceInDown',
+      'BounceInLeft',
+      'BounceInRight',
+      'BounceInUp',
+      'BounceOut',
+      'BounceOutDown',
+      'BounceOutLeft',
+      'BounceOutRight',
+      'BounceOutUp',
+      'FadeIn',
+      'FadeInDown',
+      'FadeInLeft',
+      'FadeInRight',
+      'FadeInUp',
+      'FadeOut',
+      'FadeOutDown',
+      'FadeOutLeft',
+      'FadeOutRight',
+      'FadeOutUp',
+      'FlipInEasyX',
+      'FlipInEasyY',
+      'FlipInXDown',
+      'FlipInXUp',
+      'FlipInYLeft',
+      'FlipInYRight',
+      'FlipOutEasyX',
+      'FlipOutEasyY',
+      'FlipOutXDown',
+      'FlipOutXUp',
+      'FlipOutYLeft',
+      'FlipOutYRight',
+      'LightSpeedInLeft',
+      'LightSpeedInRight',
+      'LightSpeedOutLeft',
+      'LightSpeedOutRight',
+      'PinwheelIn',
+      'PinwheelOut',
+      'RollInLeft',
+      'RollInRight',
+      'RollOutLeft',
+      'RollOutRight',
+      'RotateInDownLeft',
+      'RotateInDownRight',
+      'RotateInUpLeft',
+      'RotateInUpRight',
+      'RotateOutDownLeft',
+      'RotateOutDownRight',
+      'RotateOutUpLeft',
+      'RotateOutUpRight',
+      'SlideInDown',
+      'SlideInLeft',
+      'SlideInRight',
+      'SlideInUp',
+      'SlideOutDown',
+      'SlideOutLeft',
+      'SlideOutRight',
+      'SlideOutUp',
+      'StretchInX',
+      'StretchInY',
+      'StretchOutX',
+      'StretchOutY',
+      'ZoomIn',
+      'ZoomInDown',
+      'ZoomInEasyDown',
+      'ZoomInEasyUp',
+      'ZoomInLeft',
+      'ZoomInRight',
+      'ZoomInRotate',
+      'ZoomInUp',
+      'ZoomOut',
+      'ZoomOutDown',
+      'ZoomOutEasyDown',
+      'ZoomOutEasyUp',
+      'ZoomOutLeft',
+      'ZoomOutRight',
+      'ZoomOutRotate',
+      'ZoomOutUp',
     ]);
     var LayoutTransitions = /* @__PURE__ */ new Set([
-      "Layout",
-      "LinearTransition",
-      "SequencedTransition",
-      "FadingTransition",
-      "JumpingTransition",
-      "CurvedTransition",
-      "EntryExitTransition"
+      'Layout',
+      'LinearTransition',
+      'SequencedTransition',
+      'FadingTransition',
+      'JumpingTransition',
+      'CurvedTransition',
+      'EntryExitTransition',
     ]);
     var LayoutAnimations = /* @__PURE__ */ new Set([
       ...EntryExitAnimations,
-      ...LayoutTransitions
+      ...LayoutTransitions,
     ]);
     var BaseAnimationsChainableMethods = /* @__PURE__ */ new Set([
-      "build",
-      "duration",
-      "delay",
-      "getDuration",
-      "randomDelay",
-      "getDelay",
-      "getDelayFunction"
+      'build',
+      'duration',
+      'delay',
+      'getDuration',
+      'randomDelay',
+      'getDelay',
+      'getDelayFunction',
     ]);
     var ComplexAnimationsChainableMethods = /* @__PURE__ */ new Set([
-      "easing",
-      "rotate",
-      "springify",
-      "damping",
-      "mass",
-      "stiffness",
-      "overshootClamping",
-      "energyThreshold",
-      "restDisplacementThreshold",
-      "restSpeedThreshold",
-      "withInitialValues",
-      "getAnimationAndConfig"
+      'easing',
+      'rotate',
+      'springify',
+      'damping',
+      'mass',
+      'stiffness',
+      'overshootClamping',
+      'energyThreshold',
+      'restDisplacementThreshold',
+      'restSpeedThreshold',
+      'withInitialValues',
+      'getAnimationAndConfig',
     ]);
     var DefaultTransitionChainableMethods = /* @__PURE__ */ new Set([
-      "easingX",
-      "easingY",
-      "easingWidth",
-      "easingHeight",
-      "entering",
-      "exiting",
-      "reverse"
+      'easingX',
+      'easingY',
+      'easingWidth',
+      'easingHeight',
+      'entering',
+      'exiting',
+      'reverse',
     ]);
     var LayoutAnimationsChainableMethods = /* @__PURE__ */ new Set([
       ...BaseAnimationsChainableMethods,
       ...ComplexAnimationsChainableMethods,
-      ...DefaultTransitionChainableMethods
+      ...DefaultTransitionChainableMethods,
     ]);
-    var LayoutAnimationsCallbacks = /* @__PURE__ */ new Set(["withCallback"]);
+    var LayoutAnimationsCallbacks = /* @__PURE__ */ new Set(['withCallback']);
     function isLayoutAnimationCallback(path) {
-      return (0, types_12.isCallExpression)(path.parent) && (0, types_12.isExpression)(path.parent.callee) && isLayoutAnimationCallbackMethod(path.parent.callee);
+      return (
+        (0, types_12.isCallExpression)(path.parent) &&
+        (0, types_12.isExpression)(path.parent.callee) &&
+        isLayoutAnimationCallbackMethod(path.parent.callee)
+      );
     }
     function isLayoutAnimationCallbackMethod(exp) {
-      return (0, types_12.isMemberExpression)(exp) && (0, types_12.isIdentifier)(exp.property) && LayoutAnimationsCallbacks.has(exp.property.name) && isLayoutAnimationsChainableOrNewOperator(exp.object);
+      return (
+        (0, types_12.isMemberExpression)(exp) &&
+        (0, types_12.isIdentifier)(exp.property) &&
+        LayoutAnimationsCallbacks.has(exp.property.name) &&
+        isLayoutAnimationsChainableOrNewOperator(exp.object)
+      );
     }
     function isLayoutAnimationsChainableOrNewOperator(exp) {
       if ((0, types_12.isIdentifier)(exp) && LayoutAnimations.has(exp.name)) {
         return true;
-      } else if ((0, types_12.isNewExpression)(exp) && (0, types_12.isIdentifier)(exp.callee) && LayoutAnimations.has(exp.callee.name)) {
+      } else if (
+        (0, types_12.isNewExpression)(exp) &&
+        (0, types_12.isIdentifier)(exp.callee) &&
+        LayoutAnimations.has(exp.callee.name)
+      ) {
         return true;
       }
-      if ((0, types_12.isCallExpression)(exp) && (0, types_12.isMemberExpression)(exp.callee) && (0, types_12.isIdentifier)(exp.callee.property) && LayoutAnimationsChainableMethods.has(exp.callee.property.name) && isLayoutAnimationsChainableOrNewOperator(exp.callee.object)) {
+      if (
+        (0, types_12.isCallExpression)(exp) &&
+        (0, types_12.isMemberExpression)(exp.callee) &&
+        (0, types_12.isIdentifier)(exp.callee.property) &&
+        LayoutAnimationsChainableMethods.has(exp.callee.property.name) &&
+        isLayoutAnimationsChainableOrNewOperator(exp.callee.object)
+      ) {
         return true;
       }
       return false;
     }
-  }
+  },
 });
 
 // lib/types.js
 var require_types = __commonJS({
-  "lib/types.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.generatedWorkletsDir = exports2.workletClassFactorySuffix = exports2.WorkletizableObject = exports2.WorkletizableFunction = void 0;
+  'lib/types.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
+    exports2.generatedWorkletsDir =
+      exports2.workletClassFactorySuffix =
+      exports2.WorkletizableObject =
+      exports2.WorkletizableFunction =
+        void 0;
     exports2.isWorkletizableFunctionPath = isWorkletizableFunctionPath;
     exports2.isWorkletizableFunctionNode = isWorkletizableFunctionNode;
     exports2.isWorkletizableObjectPath = isWorkletizableObjectPath;
     exports2.isWorkletizableObjectNode = isWorkletizableObjectNode;
-    var types_12 = require("@babel/types");
-    exports2.WorkletizableFunction = "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ObjectMethod";
-    exports2.WorkletizableObject = "ObjectExpression";
+    var types_12 = require('@babel/types');
+    exports2.WorkletizableFunction =
+      'FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ObjectMethod';
+    exports2.WorkletizableObject = 'ObjectExpression';
     function isWorkletizableFunctionPath(path) {
-      return path.isFunctionDeclaration() || path.isFunctionExpression() || path.isArrowFunctionExpression() || path.isObjectMethod();
+      return (
+        path.isFunctionDeclaration() ||
+        path.isFunctionExpression() ||
+        path.isArrowFunctionExpression() ||
+        path.isObjectMethod()
+      );
     }
     function isWorkletizableFunctionNode(node) {
-      return (0, types_12.isFunctionDeclaration)(node) || (0, types_12.isFunctionExpression)(node) || (0, types_12.isArrowFunctionExpression)(node) || (0, types_12.isObjectMethod)(node);
+      return (
+        (0, types_12.isFunctionDeclaration)(node) ||
+        (0, types_12.isFunctionExpression)(node) ||
+        (0, types_12.isArrowFunctionExpression)(node) ||
+        (0, types_12.isObjectMethod)(node)
+      );
     }
     function isWorkletizableObjectPath(path) {
       return path.isObjectExpression();
@@ -276,20 +345,25 @@ var require_types = __commonJS({
     function isWorkletizableObjectNode(node) {
       return (0, types_12.isObjectExpression)(node);
     }
-    exports2.workletClassFactorySuffix = "__classFactory";
-    exports2.generatedWorkletsDir = "__generatedWorklets";
-  }
+    exports2.workletClassFactorySuffix = '__classFactory';
+    exports2.generatedWorkletsDir = '__generatedWorklets';
+  },
 });
 
 // lib/referencedWorklets.js
 var require_referencedWorklets = __commonJS({
-  "lib/referencedWorklets.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/referencedWorklets.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.findReferencedWorklet = findReferencedWorklet;
-    var types_12 = require("@babel/types");
+    var types_12 = require('@babel/types');
     var types_2 = require_types();
-    function findReferencedWorklet(workletIdentifier, acceptWorkletizableFunction, acceptObject, state) {
+    function findReferencedWorklet(
+      workletIdentifier,
+      acceptWorkletizableFunction,
+      acceptObject,
+      state
+    ) {
       const workletName = workletIdentifier.node.name;
       const scope = workletIdentifier.scope;
       const workletBinding = scope.getBinding(workletName);
@@ -299,222 +373,319 @@ var require_referencedWorklets = __commonJS({
       if (state.opts.bundleMode && bindingIsWorklet(workletBinding)) {
         return void 0;
       }
-      if (acceptWorkletizableFunction && workletBinding.path.isFunctionDeclaration()) {
+      if (
+        acceptWorkletizableFunction &&
+        workletBinding.path.isFunctionDeclaration()
+      ) {
         return workletBinding.path;
       }
       const isConstant = workletBinding.constant;
       if (isConstant) {
-        return findReferencedWorkletFromVariableDeclarator(workletBinding, acceptWorkletizableFunction, acceptObject, state);
-      }
-      return findReferencedWorkletFromAssignmentExpression(workletBinding, acceptWorkletizableFunction, acceptObject, state);
-    }
-    function findReferencedWorkletFromVariableDeclarator(workletBinding, acceptWorkletizableFunction, acceptObject, state) {
+        return findReferencedWorkletFromVariableDeclarator(
+          workletBinding,
+          acceptWorkletizableFunction,
+          acceptObject,
+          state
+        );
+      }
+      return findReferencedWorkletFromAssignmentExpression(
+        workletBinding,
+        acceptWorkletizableFunction,
+        acceptObject,
+        state
+      );
+    }
+    function findReferencedWorkletFromVariableDeclarator(
+      workletBinding,
+      acceptWorkletizableFunction,
+      acceptObject,
+      state
+    ) {
       const workletDeclaration = workletBinding.path;
       if (!workletDeclaration.isVariableDeclarator()) {
         return void 0;
       }
-      const worklet = workletDeclaration.get("init");
-      if (acceptWorkletizableFunction && (0, types_2.isWorkletizableFunctionPath)(worklet)) {
+      const worklet = workletDeclaration.get('init');
+      if (
+        acceptWorkletizableFunction &&
+        (0, types_2.isWorkletizableFunctionPath)(worklet)
+      ) {
         return worklet;
       }
       if (acceptObject && (0, types_2.isWorkletizableObjectPath)(worklet)) {
         return worklet;
       }
       if (worklet.isIdentifier() && worklet.isReferencedIdentifier()) {
-        return findReferencedWorklet(worklet, acceptWorkletizableFunction, acceptObject, state);
+        return findReferencedWorklet(
+          worklet,
+          acceptWorkletizableFunction,
+          acceptObject,
+          state
+        );
       }
       return void 0;
     }
-    function findReferencedWorkletFromAssignmentExpression(workletBinding, acceptWorkletizableFunction, acceptObject, state) {
-      const workletDeclaration = workletBinding.constantViolations.reverse().find((constantViolation) => constantViolation.isAssignmentExpression() && (acceptWorkletizableFunction && (0, types_2.isWorkletizableFunctionPath)(constantViolation.get("right")) || acceptObject && (0, types_2.isWorkletizableObjectPath)(constantViolation.get("right"))));
+    function findReferencedWorkletFromAssignmentExpression(
+      workletBinding,
+      acceptWorkletizableFunction,
+      acceptObject,
+      state
+    ) {
+      const workletDeclaration = workletBinding.constantViolations
+        .reverse()
+        .find(
+          (constantViolation) =>
+            constantViolation.isAssignmentExpression() &&
+            ((acceptWorkletizableFunction &&
+              (0, types_2.isWorkletizableFunctionPath)(
+                constantViolation.get('right')
+              )) ||
+              (acceptObject &&
+                (0, types_2.isWorkletizableObjectPath)(
+                  constantViolation.get('right')
+                )))
+        );
       if (!workletDeclaration || !workletDeclaration.isAssignmentExpression()) {
         return void 0;
       }
-      const workletDefinition = workletDeclaration.get("right");
-      if (acceptWorkletizableFunction && (0, types_2.isWorkletizableFunctionPath)(workletDefinition)) {
+      const workletDefinition = workletDeclaration.get('right');
+      if (
+        acceptWorkletizableFunction &&
+        (0, types_2.isWorkletizableFunctionPath)(workletDefinition)
+      ) {
         return workletDefinition;
       }
-      if (acceptObject && (0, types_2.isWorkletizableObjectPath)(workletDefinition)) {
+      if (
+        acceptObject &&
+        (0, types_2.isWorkletizableObjectPath)(workletDefinition)
+      ) {
         return workletDefinition;
       }
-      if (workletDefinition.isIdentifier() && workletDefinition.isReferencedIdentifier()) {
-        return findReferencedWorklet(workletDefinition, acceptWorkletizableFunction, acceptObject, state);
+      if (
+        workletDefinition.isIdentifier() &&
+        workletDefinition.isReferencedIdentifier()
+      ) {
+        return findReferencedWorklet(
+          workletDefinition,
+          acceptWorkletizableFunction,
+          acceptObject,
+          state
+        );
       }
       return void 0;
     }
     function bindingIsWorklet(binding) {
-      return binding.referencePaths.some((refPath) => !Array.isArray(refPath.container) && (0, types_12.isMemberExpression)(refPath.container) && refPath.container.object === refPath.node && (0, types_12.isIdentifier)(refPath.container.property) && refPath.container.property.name === "__workletHash");
-    }
-  }
+      return binding.referencePaths.some(
+        (refPath) =>
+          !Array.isArray(refPath.container) &&
+          (0, types_12.isMemberExpression)(refPath.container) &&
+          refPath.container.object === refPath.node &&
+          (0, types_12.isIdentifier)(refPath.container.property) &&
+          refPath.container.property.name === '__workletHash'
+      );
+    }
+  },
 });
 
 // lib/findWorklet.js
 var require_findWorklet = __commonJS({
-  "lib/findWorklet.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/findWorklet.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.findWorklet = findWorklet;
     var referencedWorklets_1 = require_referencedWorklets();
     var types_12 = require_types();
-    function findWorklet(nodePath, state, acceptWorkletizableFunction, acceptObject) {
-      if (acceptWorkletizableFunction && (0, types_12.isWorkletizableFunctionPath)(nodePath)) {
+    function findWorklet(
+      nodePath,
+      state,
+      acceptWorkletizableFunction,
+      acceptObject
+    ) {
+      if (
+        acceptWorkletizableFunction &&
+        (0, types_12.isWorkletizableFunctionPath)(nodePath)
+      ) {
         return nodePath;
       }
       if (acceptObject && (0, types_12.isWorkletizableObjectPath)(nodePath)) {
         return nodePath;
       }
       if (nodePath.isIdentifier() && nodePath.isReferencedIdentifier()) {
-        const worklet = (0, referencedWorklets_1.findReferencedWorklet)(nodePath, acceptWorkletizableFunction, acceptObject, state);
+        const worklet = (0, referencedWorklets_1.findReferencedWorklet)(
+          nodePath,
+          acceptWorkletizableFunction,
+          acceptObject,
+          state
+        );
         return worklet;
       }
       return void 0;
     }
-  }
+  },
 });
 
 // lib/utils.js
 var require_utils = __commonJS({
-  "lib/utils.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/utils.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.isRelease = isRelease;
     exports2.replaceWithFactoryCall = replaceWithFactoryCall;
-    var types_12 = require("@babel/types");
+    var types_12 = require('@babel/types');
     function isRelease() {
       var _a, _b;
       const pattern = /(prod|release|stag[ei])/i;
-      return !!(((_a = process.env.BABEL_ENV) === null || _a === void 0 ? void 0 : _a.match(pattern)) || ((_b = process.env.NODE_ENV) === null || _b === void 0 ? void 0 : _b.match(pattern)));
+      return !!(
+        ((_a = process.env.BABEL_ENV) === null || _a === void 0
+          ? void 0
+          : _a.match(pattern)) ||
+        ((_b = process.env.NODE_ENV) === null || _b === void 0
+          ? void 0
+          : _b.match(pattern))
+      );
     }
     function replaceWithFactoryCall(toReplace, name, factoryCall) {
       if (!name || !needsDeclaration(toReplace)) {
         toReplace.replaceWith(factoryCall);
       } else {
-        const replacement = (0, types_12.variableDeclaration)("const", [
-          (0, types_12.variableDeclarator)((0, types_12.identifier)(name), factoryCall)
+        const replacement = (0, types_12.variableDeclaration)('const', [
+          (0, types_12.variableDeclarator)(
+            (0, types_12.identifier)(name),
+            factoryCall
+          ),
         ]);
         toReplace.replaceWith(replacement);
       }
     }
     function needsDeclaration(nodePath) {
-      return (0, types_12.isScopable)(nodePath.parent) || (0, types_12.isExportNamedDeclaration)(nodePath.parent);
+      return (
+        (0, types_12.isScopable)(nodePath.parent) ||
+        (0, types_12.isExportNamedDeclaration)(nodePath.parent)
+      );
     }
-  }
+  },
 });
 
 // lib/globals.js
 var require_globals = __commonJS({
-  "lib/globals.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.globals = exports2.defaultGlobals = exports2.internalBindingsToCaptureFromGlobalScope = exports2.outsideBindingsToCaptureFromGlobalScope = void 0;
+  'lib/globals.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
+    exports2.globals =
+      exports2.defaultGlobals =
+      exports2.internalBindingsToCaptureFromGlobalScope =
+      exports2.outsideBindingsToCaptureFromGlobalScope =
+        void 0;
     exports2.initializeState = initializeState;
     exports2.initializeGlobals = initializeGlobals;
     exports2.addCustomGlobals = addCustomGlobals;
     var notCapturedIdentifiers = [
-      "globalThis",
-      "Infinity",
-      "NaN",
-      "undefined",
-      "eval",
-      "isFinite",
-      "isNaN",
-      "parseFloat",
-      "parseInt",
-      "decodeURI",
-      "decodeURIComponent",
-      "encodeURI",
-      "encodeURIComponent",
-      "escape",
-      "unescape",
-      "Object",
-      "Function",
-      "Boolean",
-      "Symbol",
-      "Error",
-      "AggregateError",
-      "EvalError",
-      "RangeError",
-      "ReferenceError",
-      "SyntaxError",
-      "TypeError",
-      "URIError",
-      "InternalError",
-      "Number",
-      "BigInt",
-      "Math",
-      "Date",
-      "String",
-      "RegExp",
-      "Array",
-      "Int8Array",
-      "Uint8Array",
-      "Uint8ClampedArray",
-      "Int16Array",
-      "Uint16Array",
-      "Int32Array",
-      "Uint32Array",
-      "BigInt64Array",
-      "BigUint64Array",
-      "Float32Array",
-      "Float64Array",
-      "Map",
-      "Set",
-      "WeakMap",
-      "WeakSet",
-      "ArrayBuffer",
-      "SharedArrayBuffer",
-      "DataView",
-      "Atomics",
-      "JSON",
-      "WeakRef",
-      "FinalizationRegistry",
-      "Iterator",
-      "AsyncIterator",
-      "Promise",
-      "GeneratorFunction",
-      "AsyncGeneratorFunction",
-      "Generator",
-      "AsyncGenerator",
-      "AsyncFunction",
-      "Reflect",
-      "Proxy",
-      "Intl",
-      "null",
-      "this",
-      "global",
-      "window",
-      "globalThis",
-      "self",
-      "console",
-      "performance",
-      "arguments",
-      "require",
-      "queueMicrotask",
-      "requestAnimationFrame",
-      "cancelAnimationFrame",
-      "setTimeout",
-      "clearTimeout",
-      "setImmediate",
-      "clearImmediate",
-      "setInterval",
-      "clearInterval",
-      "HermesInternal",
-      "_WORKLET"
+      'globalThis',
+      'Infinity',
+      'NaN',
+      'undefined',
+      'eval',
+      'isFinite',
+      'isNaN',
+      'parseFloat',
+      'parseInt',
+      'decodeURI',
+      'decodeURIComponent',
+      'encodeURI',
+      'encodeURIComponent',
+      'escape',
+      'unescape',
+      'Object',
+      'Function',
+      'Boolean',
+      'Symbol',
+      'Error',
+      'AggregateError',
+      'EvalError',
+      'RangeError',
+      'ReferenceError',
+      'SyntaxError',
+      'TypeError',
+      'URIError',
+      'InternalError',
+      'Number',
+      'BigInt',
+      'Math',
+      'Date',
+      'String',
+      'RegExp',
+      'Array',
+      'Int8Array',
+      'Uint8Array',
+      'Uint8ClampedArray',
+      'Int16Array',
+      'Uint16Array',
+      'Int32Array',
+      'Uint32Array',
+      'BigInt64Array',
+      'BigUint64Array',
+      'Float32Array',
+      'Float64Array',
+      'Map',
+      'Set',
+      'WeakMap',
+      'WeakSet',
+      'ArrayBuffer',
+      'SharedArrayBuffer',
+      'DataView',
+      'Atomics',
+      'JSON',
+      'WeakRef',
+      'FinalizationRegistry',
+      'Iterator',
+      'AsyncIterator',
+      'Promise',
+      'GeneratorFunction',
+      'AsyncGeneratorFunction',
+      'Generator',
+      'AsyncGenerator',
+      'AsyncFunction',
+      'Reflect',
+      'Proxy',
+      'Intl',
+      'null',
+      'this',
+      'global',
+      'window',
+      'globalThis',
+      'self',
+      'console',
+      'performance',
+      'arguments',
+      'require',
+      'queueMicrotask',
+      'requestAnimationFrame',
+      'cancelAnimationFrame',
+      'setTimeout',
+      'clearTimeout',
+      'setImmediate',
+      'clearImmediate',
+      'setInterval',
+      'clearInterval',
+      'HermesInternal',
+      '_WORKLET',
     ];
     exports2.outsideBindingsToCaptureFromGlobalScope = /* @__PURE__ */ new Set([
-      "ReanimatedError"
+      'ReanimatedError',
     ]);
-    exports2.internalBindingsToCaptureFromGlobalScope = /* @__PURE__ */ new Set([
-      "WorkletsError"
-    ]);
-    var notCapturedIdentifiers_DEPRECATED = ["_IS_FABRIC"];
+    exports2.internalBindingsToCaptureFromGlobalScope = /* @__PURE__ */ new Set(
+      ['WorkletsError']
+    );
+    var notCapturedIdentifiers_DEPRECATED = ['_IS_FABRIC'];
     function initializeState(state) {
       state.workletNumber = 1;
       state.classesToWorkletize = [];
       initializeGlobals();
       addCustomGlobals(state);
     }
-    exports2.defaultGlobals = new Set(notCapturedIdentifiers.concat(notCapturedIdentifiers_DEPRECATED));
+    exports2.defaultGlobals = new Set(
+      notCapturedIdentifiers.concat(notCapturedIdentifiers_DEPRECATED)
+    );
     function initializeGlobals() {
       exports2.globals = new Set(exports2.defaultGlobals);
     }
@@ -525,16 +696,16 @@ var require_globals = __commonJS({
         });
       }
     }
-  }
+  },
 });
 
 // lib/closure.js
 var require_closure = __commonJS({
-  "lib/closure.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/closure.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.getClosure = getClosure;
-    var types_12 = require("@babel/types");
+    var types_12 = require('@babel/types');
     var globals_12 = require_globals();
     function getClosure(funPath, state) {
       const capturedNames = /* @__PURE__ */ new Set();
@@ -542,224 +713,372 @@ var require_closure = __commonJS({
       const libraryBindingsToImport = /* @__PURE__ */ new Set();
       const relativeBindingsToImport = /* @__PURE__ */ new Set();
       let recrawled = false;
-      funPath.traverse({
-        "TSType|TSTypeAliasDeclaration|TSInterfaceDeclaration"(typePath) {
-          typePath.skip();
-        },
-        ReferencedIdentifier(idPath) {
-          if (idPath.isJSXIdentifier()) {
-            return;
-          }
-          const name = idPath.node.name;
-          if (capturedNames.has(name)) {
-            return;
-          }
-          let binding = idPath.scope.getBinding(name);
-          if (!binding && !recrawled) {
-            recrawled = true;
-            idPath.scope.crawl();
-            binding = idPath.scope.getBinding(name);
-          }
-          if (!binding) {
-            if (globals_12.globals.has(name)) {
+      funPath.traverse(
+        {
+          'TSType|TSTypeAliasDeclaration|TSInterfaceDeclaration'(typePath) {
+            typePath.skip();
+          },
+          ReferencedIdentifier(idPath) {
+            if (idPath.isJSXIdentifier()) {
               return;
             }
-            capturedNames.add(name);
-            closureVariables.push((0, types_12.cloneNode)(idPath.node, true));
-            return;
-          }
-          if (globals_12.outsideBindingsToCaptureFromGlobalScope.has(name) || !state.opts.bundleMode && globals_12.internalBindingsToCaptureFromGlobalScope.has(name)) {
-            return;
-          }
-          if ("id" in funPath.node) {
-            const id = idPath.scope.getBindingIdentifier(name);
-            if (id && id === funPath.node.id) {
+            const name = idPath.node.name;
+            if (capturedNames.has(name)) {
               return;
             }
-          }
-          let scope = idPath.scope;
-          while (scope !== funPath.scope.parent) {
-            if (scope.hasOwnBinding(name)) {
-              return;
+            let binding = idPath.scope.getBinding(name);
+            if (!binding && !recrawled) {
+              recrawled = true;
+              idPath.scope.crawl();
+              binding = idPath.scope.getBinding(name);
             }
-            scope = scope.parent;
-          }
-          if (state.opts.bundleMode && isImport(binding)) {
-            if (isImportRelative(binding) && isAllowedForRelativeImports(state.filename, state.opts.workletizableModules)) {
+            if (!binding) {
+              if (globals_12.globals.has(name)) {
+                return;
+              }
               capturedNames.add(name);
-              relativeBindingsToImport.add(binding);
+              closureVariables.push((0, types_12.cloneNode)(idPath.node, true));
               return;
             }
-            const source = binding.path.parentPath.node.source.value;
-            if (isWorkletizableModule(source, state.opts.workletizableModules)) {
-              capturedNames.add(name);
-              libraryBindingsToImport.add(binding);
+            if (
+              globals_12.outsideBindingsToCaptureFromGlobalScope.has(name) ||
+              (!state.opts.bundleMode &&
+                globals_12.internalBindingsToCaptureFromGlobalScope.has(name))
+            ) {
               return;
             }
-          }
-          capturedNames.add(name);
-          closureVariables.push((0, types_12.cloneNode)(idPath.node, true));
-        }
-      }, state);
+            if ('id' in funPath.node) {
+              const id = idPath.scope.getBindingIdentifier(name);
+              if (id && id === funPath.node.id) {
+                return;
+              }
+            }
+            let scope = idPath.scope;
+            while (scope !== funPath.scope.parent) {
+              if (scope.hasOwnBinding(name)) {
+                return;
+              }
+              scope = scope.parent;
+            }
+            if (state.opts.bundleMode && isImport(binding)) {
+              if (
+                isImportRelative(binding) &&
+                isAllowedForRelativeImports(
+                  state.filename,
+                  state.opts.workletizableModules
+                )
+              ) {
+                capturedNames.add(name);
+                relativeBindingsToImport.add(binding);
+                return;
+              }
+              const source = binding.path.parentPath.node.source.value;
+              if (
+                isWorkletizableModule(source, state.opts.workletizableModules)
+              ) {
+                capturedNames.add(name);
+                libraryBindingsToImport.add(binding);
+                return;
+              }
+            }
+            capturedNames.add(name);
+            closureVariables.push((0, types_12.cloneNode)(idPath.node, true));
+          },
+        },
+        state
+      );
       return {
         closureVariables,
         libraryBindingsToImport,
-        relativeBindingsToImport
+        relativeBindingsToImport,
       };
     }
     function isImport(binding) {
-      return binding.kind === "module" && binding.constant && (binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier()) && binding.path.parentPath.isImportDeclaration();
+      return (
+        binding.kind === 'module' &&
+        binding.constant &&
+        (binding.path.isImportSpecifier() ||
+          binding.path.isImportDefaultSpecifier()) &&
+        binding.path.parentPath.isImportDeclaration()
+      );
     }
     function isImportRelative(imported) {
-      return imported.path.parentPath.node.source.value.startsWith(".");
+      return imported.path.parentPath.node.source.value.startsWith('.');
     }
     function isAllowedForRelativeImports(filename, workletizableModules) {
-      return !!filename && (filename.includes("react-native-worklets") || !!(workletizableModules === null || workletizableModules === void 0 ? void 0 : workletizableModules.some((module3) => filename.includes(module3))));
+      return (
+        !!filename &&
+        (filename.includes('react-native-worklets') ||
+          !!(workletizableModules === null || workletizableModules === void 0
+            ? void 0
+            : workletizableModules.some((module3) =>
+                filename.includes(module3)
+              )))
+      );
     }
     function isWorkletizableModule(source, workletizableModules) {
-      return source.startsWith("react-native-worklets") || !!(workletizableModules === null || workletizableModules === void 0 ? void 0 : workletizableModules.some((module3) => source.startsWith(module3)));
-    }
-  }
+      return (
+        source.startsWith('react-native-worklets') ||
+        !!(workletizableModules === null || workletizableModules === void 0
+          ? void 0
+          : workletizableModules.some((module3) => source.startsWith(module3)))
+      );
+    }
+  },
 });
 
 // lib/generate.js
 var require_generate = __commonJS({
-  "lib/generate.js"(exports2) {
-    "use strict";
-    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/generate.js'(exports2) {
+    'use strict';
+    var __importDefault =
+      (exports2 && exports2.__importDefault) ||
+      function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+      };
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.generateWorkletFile = generateWorkletFile;
-    var core_1 = require("@babel/core");
-    var types_12 = require("@babel/types");
-    var assert_1 = __importDefault(require("assert"));
-    var fs_1 = require("fs");
-    var path_1 = require("path");
+    var core_1 = require('@babel/core');
+    var types_12 = require('@babel/types');
+    var assert_1 = __importDefault(require('assert'));
+    var fs_1 = require('fs');
+    var path_1 = require('path');
     var types_2 = require_types();
-    function generateWorkletFile(libraryBindingsToImport, relativeBindingsToImport, factory, workletHash, state) {
+    function generateWorkletFile(
+      libraryBindingsToImport,
+      relativeBindingsToImport,
+      factory,
+      workletHash,
+      state
+    ) {
       var _a;
-      const libraryImports = Array.from(libraryBindingsToImport).filter((binding) => (binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier()) && binding.path.parentPath.isImportDeclaration()).map((binding) => (0, types_12.importDeclaration)([(0, types_12.cloneNode)(binding.path.node, true)], (0, types_12.stringLiteral)(binding.path.parentPath.node.source.value)));
-      const filesDirPath = (0, path_1.resolve)((0, path_1.dirname)(require.resolve("react-native-worklets/package.json")), types_2.generatedWorkletsDir);
-      const relativeImports = Array.from(relativeBindingsToImport).filter((binding) => binding.path.isImportSpecifier() && binding.path.parentPath.isImportDeclaration()).map((binding) => {
-        const resolved = (0, path_1.resolve)((0, path_1.dirname)(state.file.opts.filename), binding.path.parentPath.node.source.value);
-        const importPath = (0, path_1.relative)(filesDirPath, resolved);
-        return (0, types_12.importDeclaration)([(0, types_12.cloneNode)(binding.path.node, true)], (0, types_12.stringLiteral)(importPath));
-      });
+      const libraryImports = Array.from(libraryBindingsToImport)
+        .filter(
+          (binding) =>
+            (binding.path.isImportSpecifier() ||
+              binding.path.isImportDefaultSpecifier()) &&
+            binding.path.parentPath.isImportDeclaration()
+        )
+        .map((binding) =>
+          (0, types_12.importDeclaration)(
+            [(0, types_12.cloneNode)(binding.path.node, true)],
+            (0, types_12.stringLiteral)(
+              binding.path.parentPath.node.source.value
+            )
+          )
+        );
+      const filesDirPath = (0, path_1.resolve)(
+        (0, path_1.dirname)(
+          require.resolve('react-native-worklets/package.json')
+        ),
+        types_2.generatedWorkletsDir
+      );
+      const relativeImports = Array.from(relativeBindingsToImport)
+        .filter(
+          (binding) =>
+            binding.path.isImportSpecifier() &&
+            binding.path.parentPath.isImportDeclaration()
+        )
+        .map((binding) => {
+          const resolved = (0, path_1.resolve)(
+            (0, path_1.dirname)(state.file.opts.filename),
+            binding.path.parentPath.node.source.value
+          );
+          const importPath = (0, path_1.relative)(filesDirPath, resolved);
+          return (0, types_12.importDeclaration)(
+            [(0, types_12.cloneNode)(binding.path.node, true)],
+            (0, types_12.stringLiteral)(importPath)
+          );
+        });
       const imports = [...libraryImports, ...relativeImports];
-      const newProg = (0, types_12.program)([...imports, (0, types_12.exportDefaultDeclaration)(factory)]);
-      const transformedProg = (_a = (0, core_1.transformFromAstSync)(newProg, void 0, {
-        filename: state.file.opts.filename,
-        presets: ["@babel/preset-typescript"],
-        plugins: [],
-        ast: false,
-        babelrc: false,
-        configFile: false,
-        comments: false
-      })) === null || _a === void 0 ? void 0 : _a.code;
-      (0, assert_1.default)(transformedProg, "[Worklets] `transformedProg` is undefined.");
+      const newProg = (0, types_12.program)([
+        ...imports,
+        (0, types_12.exportDefaultDeclaration)(factory),
+      ]);
+      const transformedProg =
+        (_a = (0, core_1.transformFromAstSync)(newProg, void 0, {
+          filename: state.file.opts.filename,
+          presets: ['@babel/preset-typescript'],
+          plugins: [],
+          ast: false,
+          babelrc: false,
+          configFile: false,
+          comments: false,
+        })) === null || _a === void 0
+          ? void 0
+          : _a.code;
+      (0, assert_1.default)(
+        transformedProg,
+        '[Worklets] `transformedProg` is undefined.'
+      );
       if (!(0, fs_1.existsSync)(filesDirPath)) {
         (0, fs_1.mkdirSync)(filesDirPath, {});
       }
-      const dedicatedFilePath = (0, path_1.resolve)(filesDirPath, `${workletHash}.js`);
+      const dedicatedFilePath = (0, path_1.resolve)(
+        filesDirPath,
+        `${workletHash}.js`
+      );
       (0, fs_1.writeFileSync)(dedicatedFilePath, transformedProg);
     }
-  }
+  },
 });
 
 // lib/transform.js
 var require_transform = __commonJS({
-  "lib/transform.js"(exports2) {
-    "use strict";
-    var __rest = exports2 && exports2.__rest || function(s, e) {
-      var t = {};
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-      if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-            t[p[i]] = s[p[i]];
-        }
-      return t;
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/transform.js'(exports2) {
+    'use strict';
+    var __rest =
+      (exports2 && exports2.__rest) ||
+      function (s, e) {
+        var t = {};
+        for (var p in s)
+          if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === 'function')
+          for (
+            var i = 0, p = Object.getOwnPropertySymbols(s);
+            i < p.length;
+            i++
+          ) {
+            if (
+              e.indexOf(p[i]) < 0 &&
+              Object.prototype.propertyIsEnumerable.call(s, p[i])
+            )
+              t[p[i]] = s[p[i]];
+          }
+        return t;
+      };
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.workletTransformSync = workletTransformSync;
-    var core_1 = require("@babel/core");
+    var core_1 = require('@babel/core');
     function workletTransformSync(code, opts) {
-      const { extraPlugins = [], extraPresets = [] } = opts, rest = __rest(opts, ["extraPlugins", "extraPresets"]);
-      return (0, core_1.transformSync)(code, Object.assign(Object.assign({}, rest), { plugins: [...defaultPlugins, ...extraPlugins], presets: [...defaultPresets, ...extraPresets] }));
-    }
-    var defaultPresets = [
-      require.resolve("@babel/preset-typescript")
-    ];
+      const { extraPlugins = [], extraPresets = [] } = opts,
+        rest = __rest(opts, ['extraPlugins', 'extraPresets']);
+      return (0, core_1.transformSync)(
+        code,
+        Object.assign(Object.assign({}, rest), {
+          plugins: [...defaultPlugins, ...extraPlugins],
+          presets: [...defaultPresets, ...extraPresets],
+        })
+      );
+    }
+    var defaultPresets = [require.resolve('@babel/preset-typescript')];
     var defaultPlugins = [];
-  }
+  },
 });
 
 // lib/workletStringCode.js
 var require_workletStringCode = __commonJS({
-  "lib/workletStringCode.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    }) : (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function(o, v) {
-      o["default"] = v;
-    });
-    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
-      var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function(o2) {
-          var ar = [];
-          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
-          return ar;
+  'lib/workletStringCode.js'(exports2) {
+    'use strict';
+    var __createBinding =
+      (exports2 && exports2.__createBinding) ||
+      (Object.create
+        ? function (o, m, k, k2) {
+            if (k2 === void 0) k2 = k;
+            var desc = Object.getOwnPropertyDescriptor(m, k);
+            if (
+              !desc ||
+              ('get' in desc
+                ? !m.__esModule
+                : desc.writable || desc.configurable)
+            ) {
+              desc = {
+                enumerable: true,
+                get: function () {
+                  return m[k];
+                },
+              };
+            }
+            Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+            if (k2 === void 0) k2 = k;
+            o[k2] = m[k];
+          });
+    var __setModuleDefault =
+      (exports2 && exports2.__setModuleDefault) ||
+      (Object.create
+        ? function (o, v) {
+            Object.defineProperty(o, 'default', { enumerable: true, value: v });
+          }
+        : function (o, v) {
+            o['default'] = v;
+          });
+    var __importStar =
+      (exports2 && exports2.__importStar) ||
+      /* @__PURE__ */ (function () {
+        var ownKeys = function (o) {
+          ownKeys =
+            Object.getOwnPropertyNames ||
+            function (o2) {
+              var ar = [];
+              for (var k in o2)
+                if (Object.prototype.hasOwnProperty.call(o2, k))
+                  ar[ar.length] = k;
+              return ar;
+            };
+          return ownKeys(o);
         };
-        return ownKeys(o);
-      };
-      return function(mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) {
-          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        }
-        __setModuleDefault(result, mod);
-        return result;
+        return function (mod) {
+          if (mod && mod.__esModule) return mod;
+          var result = {};
+          if (mod != null) {
+            for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+              if (k[i] !== 'default') __createBinding(result, mod, k[i]);
+          }
+          __setModuleDefault(result, mod);
+          return result;
+        };
+      })();
+    var __importDefault =
+      (exports2 && exports2.__importDefault) ||
+      function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
       };
-    })();
-    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.buildWorkletString = buildWorkletString;
-    var core_1 = require("@babel/core");
-    var generator_1 = __importDefault(require("@babel/generator"));
-    var types_12 = require("@babel/types");
-    var assert_1 = require("assert");
-    var convertSourceMap = __importStar(require("convert-source-map"));
-    var fs = __importStar(require("fs"));
+    var core_1 = require('@babel/core');
+    var generator_1 = __importDefault(require('@babel/generator'));
+    var types_12 = require('@babel/types');
+    var assert_1 = require('assert');
+    var convertSourceMap = __importStar(require('convert-source-map'));
+    var fs = __importStar(require('fs'));
     var transform_1 = require_transform();
     var types_2 = require_types();
     var utils_1 = require_utils();
-    var MOCK_SOURCE_MAP = "mock source map";
-    function buildWorkletString(fun, state, closureVariables, workletName, inputMap) {
+    var MOCK_SOURCE_MAP = 'mock source map';
+    function buildWorkletString(
+      fun,
+      state,
+      closureVariables,
+      workletName,
+      inputMap
+    ) {
       var _a;
       restoreRecursiveCalls(fun, workletName);
-      const draftExpression = fun.program.body.find((obj) => (0, types_12.isFunctionDeclaration)(obj)) || fun.program.body.find((obj) => (0, types_12.isExpressionStatement)(obj));
-      (0, assert_1.strict)(draftExpression, "[Reanimated] `draftExpression` is undefined.");
-      const expression = (0, types_12.isFunctionDeclaration)(draftExpression) ? draftExpression : draftExpression.expression;
-      (0, assert_1.strict)("params" in expression, "'params' property is undefined in 'expression'");
-      (0, assert_1.strict)((0, types_12.isBlockStatement)(expression.body), "[Reanimated] `expression.body` is not a `BlockStatement`");
+      const draftExpression =
+        fun.program.body.find((obj) =>
+          (0, types_12.isFunctionDeclaration)(obj)
+        ) ||
+        fun.program.body.find((obj) =>
+          (0, types_12.isExpressionStatement)(obj)
+        );
+      (0, assert_1.strict)(
+        draftExpression,
+        '[Reanimated] `draftExpression` is undefined.'
+      );
+      const expression = (0, types_12.isFunctionDeclaration)(draftExpression)
+        ? draftExpression
+        : draftExpression.expression;
+      (0, assert_1.strict)(
+        'params' in expression,
+        "'params' property is undefined in 'expression'"
+      );
+      (0, assert_1.strict)(
+        (0, types_12.isBlockStatement)(expression.body),
+        '[Reanimated] `expression.body` is not a `BlockStatement`'
+      );
       const parsedClasses = /* @__PURE__ */ new Set();
       if (!state.opts.disableWorkletClasses) {
         (0, core_1.traverse)(fun, {
@@ -768,36 +1087,66 @@ var require_workletStringCode = __commonJS({
               return;
             }
             const constructorName = path.node.callee.name;
-            if (!closureVariables.some((variable) => variable.name === constructorName) || parsedClasses.has(constructorName)) {
+            if (
+              !closureVariables.some(
+                (variable) => variable.name === constructorName
+              ) ||
+              parsedClasses.has(constructorName)
+            ) {
               return;
             }
-            const index = closureVariables.findIndex((variable) => variable.name === constructorName);
+            const index = closureVariables.findIndex(
+              (variable) => variable.name === constructorName
+            );
             closureVariables.splice(index, 1);
-            const workletClassFactoryName = constructorName + types_2.workletClassFactorySuffix;
-            closureVariables.push((0, types_12.identifier)(workletClassFactoryName));
+            const workletClassFactoryName =
+              constructorName + types_2.workletClassFactorySuffix;
+            closureVariables.push(
+              (0, types_12.identifier)(workletClassFactoryName)
+            );
             (0, types_12.assertBlockStatement)(expression.body);
-            expression.body.body.unshift((0, types_12.variableDeclaration)("const", [
-              (0, types_12.variableDeclarator)((0, types_12.identifier)(constructorName), (0, types_12.callExpression)((0, types_12.identifier)(workletClassFactoryName), []))
-            ]));
+            expression.body.body.unshift(
+              (0, types_12.variableDeclaration)('const', [
+                (0, types_12.variableDeclarator)(
+                  (0, types_12.identifier)(constructorName),
+                  (0, types_12.callExpression)(
+                    (0, types_12.identifier)(workletClassFactoryName),
+                    []
+                  )
+                ),
+              ])
+            );
             parsedClasses.add(constructorName);
-          }
+          },
         });
       }
-      const workletFunction = (0, types_12.functionExpression)((0, types_12.identifier)(workletName), expression.params, expression.body, expression.generator, expression.async);
+      const workletFunction = (0, types_12.functionExpression)(
+        (0, types_12.identifier)(workletName),
+        expression.params,
+        expression.body,
+        expression.generator,
+        expression.async
+      );
       const code = (0, generator_1.default)(workletFunction).code;
-      (0, assert_1.strict)(inputMap, "[Reanimated] `inputMap` is undefined.");
-      const includeSourceMap = !((0, utils_1.isRelease)() || state.opts.disableSourceMaps);
+      (0, assert_1.strict)(inputMap, '[Reanimated] `inputMap` is undefined.');
+      const includeSourceMap = !(
+        (0, utils_1.isRelease)() || state.opts.disableSourceMaps
+      );
       if (includeSourceMap) {
         inputMap.sourcesContent = [];
         for (const sourceFile of inputMap.sources) {
-          inputMap.sourcesContent.push(fs.readFileSync(sourceFile).toString("utf-8"));
+          inputMap.sourcesContent.push(
+            fs.readFileSync(sourceFile).toString('utf-8')
+          );
         }
       }
       const transformed = (0, transform_1.workletTransformSync)(code, {
         filename: state.file.opts.filename,
         extraPlugins: [
           getClosurePlugin(closureVariables),
-          ...(_a = state.opts.extraPlugins) !== null && _a !== void 0 ? _a : []
+          ...((_a = state.opts.extraPlugins) !== null && _a !== void 0
+            ? _a
+            : []),
         ],
         extraPresets: state.opts.extraPresets,
         compact: true,
@@ -806,9 +1155,9 @@ var require_workletStringCode = __commonJS({
         ast: false,
         babelrc: false,
         configFile: false,
-        comments: false
+        comments: false,
       });
-      (0, assert_1.strict)(transformed, "[Reanimated] `transformed` is null.");
+      (0, assert_1.strict)(transformed, '[Reanimated] `transformed` is null.');
       let sourceMap;
       if (includeSourceMap) {
         if (shouldMockSourceMap()) {
@@ -830,14 +1179,17 @@ var require_workletStringCode = __commonJS({
           const oldName = path.node.id.name;
           const scope = path.scope;
           scope.rename(oldName, newName);
-        }
+        },
       });
     }
     function shouldMockSourceMap() {
-      return process.env.REANIMATED_JEST_SHOULD_MOCK_SOURCE_MAP === "1";
+      return process.env.REANIMATED_JEST_SHOULD_MOCK_SOURCE_MAP === '1';
     }
     function prependClosure(path, closureVariables, closureDeclaration) {
-      if (closureVariables.length === 0 || !(0, types_12.isProgram)(path.parent)) {
+      if (
+        closureVariables.length === 0 ||
+        !(0, types_12.isProgram)(path.parent)
+      ) {
         return;
       }
       if (!(0, types_12.isExpression)(path.node.body)) {
@@ -846,160 +1198,414 @@ var require_workletStringCode = __commonJS({
     }
     function prependRecursiveDeclaration(path) {
       var _a;
-      if ((0, types_12.isProgram)(path.parent) && !(0, types_12.isArrowFunctionExpression)(path.node) && !(0, types_12.isObjectMethod)(path.node) && path.node.id && path.scope.parent) {
-        const hasRecursiveCalls = ((_a = path.scope.parent.bindings[path.node.id.name]) === null || _a === void 0 ? void 0 : _a.references) > 0;
+      if (
+        (0, types_12.isProgram)(path.parent) &&
+        !(0, types_12.isArrowFunctionExpression)(path.node) &&
+        !(0, types_12.isObjectMethod)(path.node) &&
+        path.node.id &&
+        path.scope.parent
+      ) {
+        const hasRecursiveCalls =
+          ((_a = path.scope.parent.bindings[path.node.id.name]) === null ||
+          _a === void 0
+            ? void 0
+            : _a.references) > 0;
         if (hasRecursiveCalls) {
-          path.node.body.body.unshift((0, types_12.variableDeclaration)("const", [
-            (0, types_12.variableDeclarator)((0, types_12.identifier)(path.node.id.name), (0, types_12.memberExpression)((0, types_12.thisExpression)(), (0, types_12.identifier)("_recur")))
-          ]));
+          path.node.body.body.unshift(
+            (0, types_12.variableDeclaration)('const', [
+              (0, types_12.variableDeclarator)(
+                (0, types_12.identifier)(path.node.id.name),
+                (0, types_12.memberExpression)(
+                  (0, types_12.thisExpression)(),
+                  (0, types_12.identifier)('_recur')
+                )
+              ),
+            ])
+          );
         }
       }
     }
     function getClosurePlugin(closureVariables) {
-      const closureDeclaration = (0, types_12.variableDeclaration)("const", [
-        (0, types_12.variableDeclarator)((0, types_12.objectPattern)(closureVariables.map((variable) => (0, types_12.objectProperty)((0, types_12.identifier)(variable.name), (0, types_12.identifier)(variable.name), false, true))), (0, types_12.memberExpression)((0, types_12.thisExpression)(), (0, types_12.identifier)("__closure")))
+      const closureDeclaration = (0, types_12.variableDeclaration)('const', [
+        (0, types_12.variableDeclarator)(
+          (0, types_12.objectPattern)(
+            closureVariables.map((variable) =>
+              (0, types_12.objectProperty)(
+                (0, types_12.identifier)(variable.name),
+                (0, types_12.identifier)(variable.name),
+                false,
+                true
+              )
+            )
+          ),
+          (0, types_12.memberExpression)(
+            (0, types_12.thisExpression)(),
+            (0, types_12.identifier)('__closure')
+          )
+        ),
       ]);
       return {
         visitor: {
-          "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ObjectMethod": (path) => {
-            prependClosure(path, closureVariables, closureDeclaration);
-            prependRecursiveDeclaration(path);
-          }
-        }
+          'FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ObjectMethod':
+            (path) => {
+              prependClosure(path, closureVariables, closureDeclaration);
+              prependRecursiveDeclaration(path);
+            },
+        },
       };
     }
-  }
+  },
 });
 
 // lib/workletFactory.js
 var require_workletFactory = __commonJS({
-  "lib/workletFactory.js"(exports2) {
-    "use strict";
-    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/workletFactory.js'(exports2) {
+    'use strict';
+    var __importDefault =
+      (exports2 && exports2.__importDefault) ||
+      function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+      };
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.makeWorkletFactory = makeWorkletFactory;
-    var generator_1 = __importDefault(require("@babel/generator"));
-    var types_12 = require("@babel/types");
-    var assert_1 = require("assert");
-    var path_1 = require("path");
+    var generator_1 = __importDefault(require('@babel/generator'));
+    var types_12 = require('@babel/types');
+    var assert_1 = require('assert');
+    var path_1 = require('path');
     var closure_1 = require_closure();
     var generate_1 = require_generate();
     var transform_1 = require_transform();
     var types_2 = require_types();
     var utils_1 = require_utils();
     var workletStringCode_1 = require_workletStringCode();
-    var REAL_VERSION = require("../package.json").version;
-    var MOCK_VERSION = "x.y.z";
+    var REAL_VERSION = require('../package.json').version;
+    var MOCK_VERSION = 'x.y.z';
     function makeWorkletFactory(fun, state) {
       var _a;
       removeWorkletDirective(fun);
-      (0, assert_1.strict)(state.file.opts.filename, "[Reanimated] `state.file.opts.filename` is undefined.");
+      (0, assert_1.strict)(
+        state.file.opts.filename,
+        '[Reanimated] `state.file.opts.filename` is undefined.'
+      );
       const codeObject = (0, generator_1.default)(fun.node, {
         sourceMaps: true,
-        sourceFileName: state.file.opts.filename
+        sourceFileName: state.file.opts.filename,
       });
-      codeObject.code = "(" + (fun.isObjectMethod() ? "function " : "") + codeObject.code + "\n)";
-      const transformed = (0, transform_1.workletTransformSync)(codeObject.code, {
-        extraPlugins: [...extraPlugins, ...(_a = state.opts.extraPlugins) !== null && _a !== void 0 ? _a : []],
-        extraPresets: state.opts.extraPresets,
-        filename: state.file.opts.filename,
-        ast: true,
-        babelrc: false,
-        configFile: false,
-        inputSourceMap: codeObject.map
-      });
-      (0, assert_1.strict)(transformed, "[Reanimated] `transformed` is undefined.");
-      (0, assert_1.strict)(transformed.ast, "[Reanimated] `transformed.ast` is undefined.");
-      const { closureVariables, libraryBindingsToImport, relativeBindingsToImport } = (0, closure_1.getClosure)(fun, state);
+      codeObject.code =
+        '(' +
+        (fun.isObjectMethod() ? 'function ' : '') +
+        codeObject.code +
+        '\n)';
+      const transformed = (0, transform_1.workletTransformSync)(
+        codeObject.code,
+        {
+          extraPlugins: [
+            ...extraPlugins,
+            ...((_a = state.opts.extraPlugins) !== null && _a !== void 0
+              ? _a
+              : []),
+          ],
+          extraPresets: state.opts.extraPresets,
+          filename: state.file.opts.filename,
+          ast: true,
+          babelrc: false,
+          configFile: false,
+          inputSourceMap: codeObject.map,
+        }
+      );
+      (0, assert_1.strict)(
+        transformed,
+        '[Reanimated] `transformed` is undefined.'
+      );
+      (0, assert_1.strict)(
+        transformed.ast,
+        '[Reanimated] `transformed.ast` is undefined.'
+      );
+      const {
+        closureVariables,
+        libraryBindingsToImport,
+        relativeBindingsToImport,
+      } = (0, closure_1.getClosure)(fun, state);
       const clone = (0, types_12.cloneNode)(fun.node);
-      const funExpression = (0, types_12.isBlockStatement)(clone.body) ? (0, types_12.functionExpression)(null, clone.params, clone.body, clone.generator, clone.async) : clone;
+      const funExpression = (0, types_12.isBlockStatement)(clone.body)
+        ? (0, types_12.functionExpression)(
+            null,
+            clone.params,
+            clone.body,
+            clone.generator,
+            clone.async
+          )
+        : clone;
       const { workletName, reactName } = makeWorkletName(fun, state);
       let mutatedClosureVariables;
       if (state.opts.bundleMode) {
-        mutatedClosureVariables = closureVariables.map((variable) => (0, types_12.cloneNode)(variable, true));
+        mutatedClosureVariables = closureVariables.map((variable) =>
+          (0, types_12.cloneNode)(variable, true)
+        );
       } else {
         mutatedClosureVariables = closureVariables;
       }
-      let [funString, sourceMapString] = (0, workletStringCode_1.buildWorkletString)(transformed.ast, state, mutatedClosureVariables, workletName, transformed.map);
-      (0, assert_1.strict)(funString, "[Reanimated] `funString` is undefined.");
+      let [funString, sourceMapString] = (0,
+      workletStringCode_1.buildWorkletString)(
+        transformed.ast,
+        state,
+        mutatedClosureVariables,
+        workletName,
+        transformed.map
+      );
+      (0, assert_1.strict)(funString, '[Reanimated] `funString` is undefined.');
       const workletHash = hash(funString);
       let lineOffset = 1;
       if (closureVariables.length > 0) {
         lineOffset -= closureVariables.length + 2;
       }
-      const pathForStringDefinitions = fun.parentPath.isProgram() ? fun : fun.findParent((path) => {
-        var _a2, _b;
-        return (_b = (_a2 = path.parentPath) === null || _a2 === void 0 ? void 0 : _a2.isProgram()) !== null && _b !== void 0 ? _b : false;
-      });
-      (0, assert_1.strict)(pathForStringDefinitions, "[Reanimated] `pathForStringDefinitions` is null.");
-      (0, assert_1.strict)(pathForStringDefinitions.parentPath, "[Reanimated] `pathForStringDefinitions.parentPath` is null.");
-      const initDataId = pathForStringDefinitions.parentPath.scope.generateUidIdentifier(`worklet_${workletHash}_init_data`);
+      const pathForStringDefinitions = fun.parentPath.isProgram()
+        ? fun
+        : fun.findParent((path) => {
+            var _a2, _b;
+            return (_b =
+              (_a2 = path.parentPath) === null || _a2 === void 0
+                ? void 0
+                : _a2.isProgram()) !== null && _b !== void 0
+              ? _b
+              : false;
+          });
+      (0, assert_1.strict)(
+        pathForStringDefinitions,
+        '[Reanimated] `pathForStringDefinitions` is null.'
+      );
+      (0, assert_1.strict)(
+        pathForStringDefinitions.parentPath,
+        '[Reanimated] `pathForStringDefinitions.parentPath` is null.'
+      );
+      const initDataId =
+        pathForStringDefinitions.parentPath.scope.generateUidIdentifier(
+          `worklet_${workletHash}_init_data`
+        );
       const initDataObjectExpression = (0, types_12.objectExpression)([
-        (0, types_12.objectProperty)((0, types_12.identifier)("code"), (0, types_12.stringLiteral)(funString))
+        (0, types_12.objectProperty)(
+          (0, types_12.identifier)('code'),
+          (0, types_12.stringLiteral)(funString)
+        ),
       ]);
       const shouldInjectLocation = !(0, utils_1.isRelease)();
       if (shouldInjectLocation) {
         let location = state.file.opts.filename;
         if (state.opts.relativeSourceLocation) {
           location = (0, path_1.relative)(state.cwd, location);
-          sourceMapString = sourceMapString === null || sourceMapString === void 0 ? void 0 : sourceMapString.replace(state.file.opts.filename, location);
+          sourceMapString =
+            sourceMapString === null || sourceMapString === void 0
+              ? void 0
+              : sourceMapString.replace(state.file.opts.filename, location);
         }
-        initDataObjectExpression.properties.push((0, types_12.objectProperty)((0, types_12.identifier)("location"), (0, types_12.stringLiteral)(location)));
+        initDataObjectExpression.properties.push(
+          (0, types_12.objectProperty)(
+            (0, types_12.identifier)('location'),
+            (0, types_12.stringLiteral)(location)
+          )
+        );
       }
       if (sourceMapString) {
-        initDataObjectExpression.properties.push((0, types_12.objectProperty)((0, types_12.identifier)("sourceMap"), (0, types_12.stringLiteral)(sourceMapString)));
+        initDataObjectExpression.properties.push(
+          (0, types_12.objectProperty)(
+            (0, types_12.identifier)('sourceMap'),
+            (0, types_12.stringLiteral)(sourceMapString)
+          )
+        );
       }
       const shouldIncludeInitData = !state.opts.omitNativeOnlyData;
       if (shouldIncludeInitData && !state.opts.bundleMode) {
-        pathForStringDefinitions.insertBefore((0, types_12.variableDeclaration)("const", [
-          (0, types_12.variableDeclarator)(initDataId, initDataObjectExpression)
-        ]));
-      }
-      (0, assert_1.strict)(!(0, types_12.isFunctionDeclaration)(funExpression), "[Reanimated] `funExpression` is a `FunctionDeclaration`.");
-      (0, assert_1.strict)(!(0, types_12.isObjectMethod)(funExpression), "[Reanimated] `funExpression` is an `ObjectMethod`.");
+        pathForStringDefinitions.insertBefore(
+          (0, types_12.variableDeclaration)('const', [
+            (0, types_12.variableDeclarator)(
+              initDataId,
+              initDataObjectExpression
+            ),
+          ])
+        );
+      }
+      (0, assert_1.strict)(
+        !(0, types_12.isFunctionDeclaration)(funExpression),
+        '[Reanimated] `funExpression` is a `FunctionDeclaration`.'
+      );
+      (0, assert_1.strict)(
+        !(0, types_12.isObjectMethod)(funExpression),
+        '[Reanimated] `funExpression` is an `ObjectMethod`.'
+      );
       const statements = [
-        (0, types_12.variableDeclaration)("const", [
-          (0, types_12.variableDeclarator)((0, types_12.identifier)(reactName), funExpression)
+        (0, types_12.variableDeclaration)('const', [
+          (0, types_12.variableDeclarator)(
+            (0, types_12.identifier)(reactName),
+            funExpression
+          ),
         ]),
-        (0, types_12.expressionStatement)((0, types_12.assignmentExpression)("=", (0, types_12.memberExpression)((0, types_12.identifier)(reactName), (0, types_12.identifier)("__closure"), false), (0, types_12.objectExpression)(closureVariables.map((variable) => !state.opts.bundleMode && variable.name.endsWith(types_2.workletClassFactorySuffix) ? (0, types_12.objectProperty)((0, types_12.identifier)(variable.name), (0, types_12.memberExpression)((0, types_12.identifier)(variable.name.slice(0, variable.name.length - types_2.workletClassFactorySuffix.length)), (0, types_12.identifier)(variable.name))) : (0, types_12.objectProperty)((0, types_12.cloneNode)(variable, true), (0, types_12.cloneNode)(variable, true), false, true))))),
-        (0, types_12.expressionStatement)((0, types_12.assignmentExpression)("=", (0, types_12.memberExpression)((0, types_12.identifier)(reactName), (0, types_12.identifier)("__workletHash"), false), (0, types_12.numericLiteral)(workletHash)))
+        (0, types_12.expressionStatement)(
+          (0, types_12.assignmentExpression)(
+            '=',
+            (0, types_12.memberExpression)(
+              (0, types_12.identifier)(reactName),
+              (0, types_12.identifier)('__closure'),
+              false
+            ),
+            (0, types_12.objectExpression)(
+              closureVariables.map((variable) =>
+                !state.opts.bundleMode &&
+                variable.name.endsWith(types_2.workletClassFactorySuffix)
+                  ? (0, types_12.objectProperty)(
+                      (0, types_12.identifier)(variable.name),
+                      (0, types_12.memberExpression)(
+                        (0, types_12.identifier)(
+                          variable.name.slice(
+                            0,
+                            variable.name.length -
+                              types_2.workletClassFactorySuffix.length
+                          )
+                        ),
+                        (0, types_12.identifier)(variable.name)
+                      )
+                    )
+                  : (0, types_12.objectProperty)(
+                      (0, types_12.cloneNode)(variable, true),
+                      (0, types_12.cloneNode)(variable, true),
+                      false,
+                      true
+                    )
+              )
+            )
+          )
+        ),
+        (0, types_12.expressionStatement)(
+          (0, types_12.assignmentExpression)(
+            '=',
+            (0, types_12.memberExpression)(
+              (0, types_12.identifier)(reactName),
+              (0, types_12.identifier)('__workletHash'),
+              false
+            ),
+            (0, types_12.numericLiteral)(workletHash)
+          )
+        ),
       ];
       const shouldInjectVersion = !(0, utils_1.isRelease)();
       if (shouldInjectVersion) {
-        statements.push((0, types_12.expressionStatement)((0, types_12.assignmentExpression)("=", (0, types_12.memberExpression)((0, types_12.identifier)(reactName), (0, types_12.identifier)("__pluginVersion")), (0, types_12.stringLiteral)(shouldMockVersion() ? MOCK_VERSION : REAL_VERSION))));
+        statements.push(
+          (0, types_12.expressionStatement)(
+            (0, types_12.assignmentExpression)(
+              '=',
+              (0, types_12.memberExpression)(
+                (0, types_12.identifier)(reactName),
+                (0, types_12.identifier)('__pluginVersion')
+              ),
+              (0, types_12.stringLiteral)(
+                shouldMockVersion() ? MOCK_VERSION : REAL_VERSION
+              )
+            )
+          )
+        );
       }
       if (shouldIncludeInitData && !state.opts.bundleMode) {
-        statements.push((0, types_12.expressionStatement)((0, types_12.assignmentExpression)("=", (0, types_12.memberExpression)((0, types_12.identifier)(reactName), (0, types_12.identifier)("__initData"), false), (0, types_12.cloneNode)(initDataId, true))));
+        statements.push(
+          (0, types_12.expressionStatement)(
+            (0, types_12.assignmentExpression)(
+              '=',
+              (0, types_12.memberExpression)(
+                (0, types_12.identifier)(reactName),
+                (0, types_12.identifier)('__initData'),
+                false
+              ),
+              (0, types_12.cloneNode)(initDataId, true)
+            )
+          )
+        );
       }
       if (!(0, utils_1.isRelease)()) {
-        statements.unshift((0, types_12.variableDeclaration)("const", [
-          (0, types_12.variableDeclarator)((0, types_12.identifier)("_e"), (0, types_12.arrayExpression)([
-            (0, types_12.newExpression)((0, types_12.memberExpression)((0, types_12.identifier)("global"), (0, types_12.identifier)("Error")), []),
-            (0, types_12.numericLiteral)(lineOffset),
-            (0, types_12.numericLiteral)(-27)
-          ]))
-        ]));
-        statements.push((0, types_12.expressionStatement)((0, types_12.assignmentExpression)("=", (0, types_12.memberExpression)((0, types_12.identifier)(reactName), (0, types_12.identifier)("__stackDetails"), false), (0, types_12.identifier)("_e"))));
-      }
-      statements.push((0, types_12.returnStatement)((0, types_12.identifier)(reactName)));
+        statements.unshift(
+          (0, types_12.variableDeclaration)('const', [
+            (0, types_12.variableDeclarator)(
+              (0, types_12.identifier)('_e'),
+              (0, types_12.arrayExpression)([
+                (0, types_12.newExpression)(
+                  (0, types_12.memberExpression)(
+                    (0, types_12.identifier)('global'),
+                    (0, types_12.identifier)('Error')
+                  ),
+                  []
+                ),
+                (0, types_12.numericLiteral)(lineOffset),
+                (0, types_12.numericLiteral)(-27),
+              ])
+            ),
+          ])
+        );
+        statements.push(
+          (0, types_12.expressionStatement)(
+            (0, types_12.assignmentExpression)(
+              '=',
+              (0, types_12.memberExpression)(
+                (0, types_12.identifier)(reactName),
+                (0, types_12.identifier)('__stackDetails'),
+                false
+              ),
+              (0, types_12.identifier)('_e')
+            )
+          )
+        );
+      }
+      statements.push(
+        (0, types_12.returnStatement)((0, types_12.identifier)(reactName))
+      );
       const factoryParams = closureVariables.map((variableId) => {
         const clonedId = (0, types_12.cloneNode)(variableId, true);
-        if (!state.opts.bundleMode && clonedId.name.endsWith(types_2.workletClassFactorySuffix)) {
-          clonedId.name = clonedId.name.slice(0, clonedId.name.length - types_2.workletClassFactorySuffix.length);
+        if (
+          !state.opts.bundleMode &&
+          clonedId.name.endsWith(types_2.workletClassFactorySuffix)
+        ) {
+          clonedId.name = clonedId.name.slice(
+            0,
+            clonedId.name.length - types_2.workletClassFactorySuffix.length
+          );
         }
         return clonedId;
       });
       if (shouldIncludeInitData && !state.opts.bundleMode) {
         factoryParams.unshift((0, types_12.cloneNode)(initDataId, true));
       }
-      const factoryParamObjectPattern = (0, types_12.objectPattern)(factoryParams.map((param) => (0, types_12.objectProperty)((0, types_12.cloneNode)(param, true), (0, types_12.cloneNode)(param, true), false, true)));
-      const factory = (0, types_12.functionExpression)((0, types_12.identifier)(workletName + "Factory"), [factoryParamObjectPattern], (0, types_12.blockStatement)(statements));
-      const factoryCallArgs = factoryParams.map((param) => (0, types_12.cloneNode)(param, true));
-      const factoryCallParamPack = (0, types_12.objectExpression)(factoryCallArgs.map((param) => (0, types_12.objectProperty)((0, types_12.cloneNode)(param, true), (0, types_12.cloneNode)(param, true), false, true)));
+      const factoryParamObjectPattern = (0, types_12.objectPattern)(
+        factoryParams.map((param) =>
+          (0, types_12.objectProperty)(
+            (0, types_12.cloneNode)(param, true),
+            (0, types_12.cloneNode)(param, true),
+            false,
+            true
+          )
+        )
+      );
+      const factory = (0, types_12.functionExpression)(
+        (0, types_12.identifier)(workletName + 'Factory'),
+        [factoryParamObjectPattern],
+        (0, types_12.blockStatement)(statements)
+      );
+      const factoryCallArgs = factoryParams.map((param) =>
+        (0, types_12.cloneNode)(param, true)
+      );
+      const factoryCallParamPack = (0, types_12.objectExpression)(
+        factoryCallArgs.map((param) =>
+          (0, types_12.objectProperty)(
+            (0, types_12.cloneNode)(param, true),
+            (0, types_12.cloneNode)(param, true),
+            false,
+            true
+          )
+        )
+      );
       if (state.opts.bundleMode) {
-        (0, generate_1.generateWorkletFile)(libraryBindingsToImport, relativeBindingsToImport, factory, workletHash, state);
+        (0, generate_1.generateWorkletFile)(
+          libraryBindingsToImport,
+          relativeBindingsToImport,
+          factory,
+          workletHash,
+          state
+        );
       }
       factory.workletized = true;
       return { factory, factoryCallParamPack, workletHash };
@@ -1007,14 +1613,17 @@ var require_workletFactory = __commonJS({
     function removeWorkletDirective(fun) {
       fun.traverse({
         DirectiveLiteral(nodePath) {
-          if (nodePath.node.value === "worklet" && nodePath.getFunctionParent() === fun) {
+          if (
+            nodePath.node.value === 'worklet' &&
+            nodePath.getFunctionParent() === fun
+          ) {
             nodePath.parentPath.remove();
           }
-        }
+        },
       });
     }
     function shouldMockVersion() {
-      return process.env.REANIMATED_JEST_SHOULD_MOCK_VERSION === "1";
+      return process.env.REANIMATED_JEST_SHOULD_MOCK_VERSION === '1';
     }
     function hash(str) {
       let i = str.length;
@@ -1022,65 +1631,85 @@ var require_workletFactory = __commonJS({
       let hash2 = 52711;
       while (i--) {
         const char = str.charCodeAt(i);
-        hash1 = hash1 * 33 ^ char;
-        hash2 = hash2 * 33 ^ char;
+        hash1 = (hash1 * 33) ^ char;
+        hash2 = (hash2 * 33) ^ char;
       }
       return (hash1 >>> 0) * 4096 + (hash2 >>> 0);
     }
     function makeWorkletName(fun, state) {
-      let source = "unknownFile";
+      let source = 'unknownFile';
       if (state.file.opts.filename) {
         const filepath = state.file.opts.filename;
         source = (0, path_1.basename)(filepath);
-        const splitFilepath = filepath.split("/");
-        const nodeModulesIndex = splitFilepath.indexOf("node_modules");
+        const splitFilepath = filepath.split('/');
+        const nodeModulesIndex = splitFilepath.indexOf('node_modules');
         if (nodeModulesIndex !== -1) {
           const libraryName = splitFilepath[nodeModulesIndex + 1];
           source = `${libraryName}_${source}`;
         }
       }
       const suffix = `${source}${state.workletNumber++}`;
-      let reactName = "";
-      if ((0, types_12.isObjectMethod)(fun.node) && (0, types_12.isIdentifier)(fun.node.key)) {
+      let reactName = '';
+      if (
+        (0, types_12.isObjectMethod)(fun.node) &&
+        (0, types_12.isIdentifier)(fun.node.key)
+      ) {
         reactName = fun.node.key.name;
-      } else if (((0, types_12.isFunctionDeclaration)(fun.node) || (0, types_12.isFunctionExpression)(fun.node)) && (0, types_12.isIdentifier)(fun.node.id)) {
+      } else if (
+        ((0, types_12.isFunctionDeclaration)(fun.node) ||
+          (0, types_12.isFunctionExpression)(fun.node)) &&
+        (0, types_12.isIdentifier)(fun.node.id)
+      ) {
         reactName = fun.node.id.name;
       }
-      const workletName = reactName ? (0, types_12.toIdentifier)(`${reactName}_${suffix}`) : (0, types_12.toIdentifier)(suffix);
+      const workletName = reactName
+        ? (0, types_12.toIdentifier)(`${reactName}_${suffix}`)
+        : (0, types_12.toIdentifier)(suffix);
       reactName = reactName || (0, types_12.toIdentifier)(suffix);
       return { workletName, reactName };
     }
     var extraPlugins = [
-      require.resolve("@babel/plugin-transform-shorthand-properties"),
-      require.resolve("@babel/plugin-transform-arrow-functions"),
-      require.resolve("@babel/plugin-transform-optional-chaining"),
-      require.resolve("@babel/plugin-transform-nullish-coalescing-operator"),
+      require.resolve('@babel/plugin-transform-shorthand-properties'),
+      require.resolve('@babel/plugin-transform-arrow-functions'),
+      require.resolve('@babel/plugin-transform-optional-chaining'),
+      require.resolve('@babel/plugin-transform-nullish-coalescing-operator'),
       [
-        require.resolve("@babel/plugin-transform-template-literals"),
-        { loose: true }
-      ]
+        require.resolve('@babel/plugin-transform-template-literals'),
+        { loose: true },
+      ],
     ];
-  }
+  },
 });
 
 // lib/workletFactoryCall.js
 var require_workletFactoryCall = __commonJS({
-  "lib/workletFactoryCall.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/workletFactoryCall.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.makeWorkletFactoryCall = makeWorkletFactoryCall;
-    var types_12 = require("@babel/types");
+    var types_12 = require('@babel/types');
     var types_2 = require_types();
     var workletFactory_1 = require_workletFactory();
     function makeWorkletFactoryCall(path, state) {
-      const { factory, factoryCallParamPack, workletHash } = (0, workletFactory_1.makeWorkletFactory)(path, state);
+      const { factory, factoryCallParamPack, workletHash } = (0,
+      workletFactory_1.makeWorkletFactory)(path, state);
       let factoryCall;
       if (state.opts.bundleMode) {
-        factoryCall = (0, types_12.callExpression)((0, types_12.memberExpression)((0, types_12.callExpression)((0, types_12.identifier)("require"), [
-          (0, types_12.stringLiteral)(`react-native-worklets/${types_2.generatedWorkletsDir}/${workletHash}.js`)
-        ]), (0, types_12.identifier)("default")), [factoryCallParamPack]);
+        factoryCall = (0, types_12.callExpression)(
+          (0, types_12.memberExpression)(
+            (0, types_12.callExpression)((0, types_12.identifier)('require'), [
+              (0, types_12.stringLiteral)(
+                `react-native-worklets/${types_2.generatedWorkletsDir}/${workletHash}.js`
+              ),
+            ]),
+            (0, types_12.identifier)('default')
+          ),
+          [factoryCallParamPack]
+        );
       } else {
-        factoryCall = (0, types_12.callExpression)(factory, [factoryCallParamPack]);
+        factoryCall = (0, types_12.callExpression)(factory, [
+          factoryCallParamPack,
+        ]);
       }
       addStackTraceDataToWorkletFactory(path, factoryCall);
       const replacement = factoryCall;
@@ -1093,22 +1722,23 @@ var require_workletFactoryCall = __commonJS({
           filename: originalWorkletLocation.filename,
           identifierName: originalWorkletLocation.identifierName,
           start: originalWorkletLocation.start,
-          end: originalWorkletLocation.start
+          end: originalWorkletLocation.start,
         };
       }
     }
-  }
+  },
 });
 
 // lib/workletSubstitution.js
 var require_workletSubstitution = __commonJS({
-  "lib/workletSubstitution.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/workletSubstitution.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.processIfWithWorkletDirective = processIfWithWorkletDirective;
     exports2.processWorklet = processWorklet;
-    exports2.substituteObjectMethodWithObjectProperty = substituteObjectMethodWithObjectProperty;
-    var types_12 = require("@babel/types");
+    exports2.substituteObjectMethodWithObjectProperty =
+      substituteObjectMethodWithObjectProperty;
+    var types_12 = require('@babel/types');
     var types_2 = require_types();
     var utils_1 = require_utils();
     var workletFactoryCall_1 = require_workletFactoryCall();
@@ -1123,48 +1753,82 @@ var require_workletSubstitution = __commonJS({
       return true;
     }
     function processWorklet(path, state) {
-      path.traverse({
-        [types_2.WorkletizableFunction](subPath, passedState) {
-          processIfWithWorkletDirective(subPath, passedState);
-        }
-      }, state);
-      const workletFactoryCall = (0, workletFactoryCall_1.makeWorkletFactoryCall)(path, state);
+      path.traverse(
+        {
+          [types_2.WorkletizableFunction](subPath, passedState) {
+            processIfWithWorkletDirective(subPath, passedState);
+          },
+        },
+        state
+      );
+      const workletFactoryCall = (0,
+      workletFactoryCall_1.makeWorkletFactoryCall)(path, state);
       substituteWorkletWithWorkletFactoryCall(path, workletFactoryCall);
       path.scope.getProgramParent().crawl();
     }
     function hasWorkletDirective(directives) {
-      return directives.some((directive) => (0, types_12.isDirectiveLiteral)(directive.value) && directive.value.value === "worklet");
+      return directives.some(
+        (directive) =>
+          (0, types_12.isDirectiveLiteral)(directive.value) &&
+          directive.value.value === 'worklet'
+      );
     }
     function substituteWorkletWithWorkletFactoryCall(path, workletFactoryCall) {
       var _a;
       if (path.isObjectMethod()) {
         substituteObjectMethodWithObjectProperty(path, workletFactoryCall);
       } else {
-        const name = "id" in path.node ? (_a = path.node.id) === null || _a === void 0 ? void 0 : _a.name : void 0;
+        const name =
+          'id' in path.node
+            ? (_a = path.node.id) === null || _a === void 0
+              ? void 0
+              : _a.name
+            : void 0;
         (0, utils_1.replaceWithFactoryCall)(path, name, workletFactoryCall);
       }
     }
-    function substituteObjectMethodWithObjectProperty(path, workletFactoryCall) {
-      const replacement = (0, types_12.objectProperty)(path.node.key, workletFactoryCall);
+    function substituteObjectMethodWithObjectProperty(
+      path,
+      workletFactoryCall
+    ) {
+      const replacement = (0, types_12.objectProperty)(
+        path.node.key,
+        workletFactoryCall
+      );
       path.replaceWith(replacement);
     }
-  }
+  },
 });
 
 // lib/objectWorklets.js
 var require_objectWorklets = __commonJS({
-  "lib/objectWorklets.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/objectWorklets.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.tryProcessingNode = tryProcessingNode;
     exports2.processWorkletizableObject = processWorkletizableObject;
     var findWorklet_1 = require_findWorklet();
     var types_12 = require_types();
     var workletSubstitution_12 = require_workletSubstitution();
-    function tryProcessingNode(arg, state, acceptWorkletizableFunction, acceptObject) {
+    function tryProcessingNode(
+      arg,
+      state,
+      acceptWorkletizableFunction,
+      acceptObject
+    ) {
       var _a;
-      const maybeWorklet = (0, findWorklet_1.findWorklet)(arg, state, acceptWorkletizableFunction, acceptObject);
-      if (!maybeWorklet || ((_a = maybeWorklet.getFunctionParent()) === null || _a === void 0 ? void 0 : _a.node.workletized)) {
+      const maybeWorklet = (0, findWorklet_1.findWorklet)(
+        arg,
+        state,
+        acceptWorkletizableFunction,
+        acceptObject
+      );
+      if (
+        !maybeWorklet ||
+        ((_a = maybeWorklet.getFunctionParent()) === null || _a === void 0
+          ? void 0
+          : _a.node.workletized)
+      ) {
         return;
       }
       if ((0, types_12.isWorkletizableFunctionPath)(maybeWorklet)) {
@@ -1174,159 +1838,216 @@ var require_objectWorklets = __commonJS({
       }
     }
     function processWorkletizableObject(path, state) {
-      const properties = path.get("properties");
+      const properties = path.get('properties');
       for (const property of properties) {
         if (property.isObjectMethod()) {
           (0, workletSubstitution_12.processWorklet)(property, state);
         } else if (property.isObjectProperty()) {
-          const value = property.get("value");
+          const value = property.get('value');
           tryProcessingNode(value, state, true, false);
         } else {
-          throw new Error(`[Reanimated] '${property.type}' as to-be workletized argument is not supported for object hooks.`);
+          throw new Error(
+            `[Reanimated] '${property.type}' as to-be workletized argument is not supported for object hooks.`
+          );
         }
       }
     }
-  }
+  },
 });
 
 // lib/autoworkletization.js
 var require_autoworkletization = __commonJS({
-  "lib/autoworkletization.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.processIfAutoworkletizableCallback = processIfAutoworkletizableCallback;
-    exports2.processCalleesAutoworkletizableCallbacks = processCalleesAutoworkletizableCallbacks;
-    var types_12 = require("@babel/types");
-    var gestureHandlerAutoworkletization_1 = require_gestureHandlerAutoworkletization();
-    var layoutAnimationAutoworkletization_1 = require_layoutAnimationAutoworkletization();
+  'lib/autoworkletization.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
+    exports2.processIfAutoworkletizableCallback =
+      processIfAutoworkletizableCallback;
+    exports2.processCalleesAutoworkletizableCallbacks =
+      processCalleesAutoworkletizableCallbacks;
+    var types_12 = require('@babel/types');
+    var gestureHandlerAutoworkletization_1 =
+      require_gestureHandlerAutoworkletization();
+    var layoutAnimationAutoworkletization_1 =
+      require_layoutAnimationAutoworkletization();
     var objectWorklets_1 = require_objectWorklets();
     var workletSubstitution_12 = require_workletSubstitution();
     var reanimatedObjectHooks = /* @__PURE__ */ new Set([
-      "useAnimatedScrollHandler",
-      ...Array.from(gestureHandlerAutoworkletization_1.gestureHandlerObjectHooks)
+      'useAnimatedScrollHandler',
+      ...Array.from(
+        gestureHandlerAutoworkletization_1.gestureHandlerObjectHooks
+      ),
     ]);
     var reanimatedFunctionHooks = /* @__PURE__ */ new Set([
-      "useFrameCallback",
-      "useAnimatedStyle",
-      "useAnimatedProps",
-      "createAnimatedPropAdapter",
-      "useDerivedValue",
-      "useAnimatedScrollHandler",
-      "useAnimatedReaction",
-      "withTiming",
-      "withSpring",
-      "withDecay",
-      "withRepeat",
-      "runOnUI",
-      "executeOnUIRuntimeSync",
-      "scheduleOnUI",
-      "runOnUISync",
-      "runOnUIAsync",
-      "runOnRuntime",
-      "scheduleOnRuntime"
+      'useFrameCallback',
+      'useAnimatedStyle',
+      'useAnimatedProps',
+      'createAnimatedPropAdapter',
+      'useDerivedValue',
+      'useAnimatedScrollHandler',
+      'useAnimatedReaction',
+      'withTiming',
+      'withSpring',
+      'withDecay',
+      'withRepeat',
+      'runOnUI',
+      'executeOnUIRuntimeSync',
+      'scheduleOnUI',
+      'runOnUISync',
+      'runOnUIAsync',
+      'runOnRuntime',
+      'scheduleOnRuntime',
     ]);
     var reanimatedFunctionArgsToWorkletize = new Map([
-      ["useFrameCallback", [0]],
-      ["useAnimatedStyle", [0]],
-      ["useAnimatedProps", [0]],
-      ["createAnimatedPropAdapter", [0]],
-      ["useDerivedValue", [0]],
-      ["useAnimatedScrollHandler", [0]],
-      ["useAnimatedReaction", [0, 1]],
-      ["withTiming", [2]],
-      ["withSpring", [2]],
-      ["withDecay", [1]],
-      ["withRepeat", [3]],
-      ["runOnUI", [0]],
-      ["executeOnUIRuntimeSync", [0]],
-      ["scheduleOnUI", [0]],
-      ["runOnUISync", [0]],
-      ["runOnUIAsync", [0]],
-      ["runOnRuntime", [1]],
-      ["scheduleOnRuntime", [1]],
-      ...Array.from(gestureHandlerAutoworkletization_1.gestureHandlerObjectHooks).map((name) => [name, [0]]),
-      ...Array.from(gestureHandlerAutoworkletization_1.gestureHandlerBuilderMethods).map((name) => [name, [0]])
+      ['useFrameCallback', [0]],
+      ['useAnimatedStyle', [0]],
+      ['useAnimatedProps', [0]],
+      ['createAnimatedPropAdapter', [0]],
+      ['useDerivedValue', [0]],
+      ['useAnimatedScrollHandler', [0]],
+      ['useAnimatedReaction', [0, 1]],
+      ['withTiming', [2]],
+      ['withSpring', [2]],
+      ['withDecay', [1]],
+      ['withRepeat', [3]],
+      ['runOnUI', [0]],
+      ['executeOnUIRuntimeSync', [0]],
+      ['scheduleOnUI', [0]],
+      ['runOnUISync', [0]],
+      ['runOnUIAsync', [0]],
+      ['runOnRuntime', [1]],
+      ['scheduleOnRuntime', [1]],
+      ...Array.from(
+        gestureHandlerAutoworkletization_1.gestureHandlerObjectHooks
+      ).map((name) => [name, [0]]),
+      ...Array.from(
+        gestureHandlerAutoworkletization_1.gestureHandlerBuilderMethods
+      ).map((name) => [name, [0]]),
     ]);
     function processIfAutoworkletizableCallback(path, state) {
-      if ((0, gestureHandlerAutoworkletization_1.isGestureHandlerEventCallback)(path) || (0, layoutAnimationAutoworkletization_1.isLayoutAnimationCallback)(path)) {
+      if (
+        (0, gestureHandlerAutoworkletization_1.isGestureHandlerEventCallback)(
+          path
+        ) ||
+        (0, layoutAnimationAutoworkletization_1.isLayoutAnimationCallback)(path)
+      ) {
         (0, workletSubstitution_12.processWorklet)(path, state);
         return true;
       }
       return false;
     }
     function processCalleesAutoworkletizableCallbacks(path, state) {
-      const callee = (0, types_12.isSequenceExpression)(path.node.callee) ? path.node.callee.expressions[path.node.callee.expressions.length - 1] : path.node.callee;
-      const name = "name" in callee ? callee.name : "property" in callee && "name" in callee.property ? callee.property.name : void 0;
+      const callee = (0, types_12.isSequenceExpression)(path.node.callee)
+        ? path.node.callee.expressions[path.node.callee.expressions.length - 1]
+        : path.node.callee;
+      const name =
+        'name' in callee
+          ? callee.name
+          : 'property' in callee && 'name' in callee.property
+            ? callee.property.name
+            : void 0;
       if (name === void 0) {
         return;
       }
-      if (reanimatedFunctionHooks.has(name) || reanimatedObjectHooks.has(name)) {
+      if (
+        reanimatedFunctionHooks.has(name) ||
+        reanimatedObjectHooks.has(name)
+      ) {
         const acceptWorkletizableFunction = reanimatedFunctionHooks.has(name);
         const acceptObject = reanimatedObjectHooks.has(name);
         const argIndices = reanimatedFunctionArgsToWorkletize.get(name);
-        const args = path.get("arguments").filter((_, index) => argIndices.includes(index));
+        const args = path
+          .get('arguments')
+          .filter((_, index) => argIndices.includes(index));
         processArgs(args, state, acceptWorkletizableFunction, acceptObject);
-      } else if (!(0, types_12.isV8IntrinsicIdentifier)(callee) && (0, gestureHandlerAutoworkletization_1.isGestureObjectEventCallbackMethod)(callee)) {
-        const args = path.get("arguments");
+      } else if (
+        !(0, types_12.isV8IntrinsicIdentifier)(callee) &&
+        (0,
+        gestureHandlerAutoworkletization_1.isGestureObjectEventCallbackMethod)(
+          callee
+        )
+      ) {
+        const args = path.get('arguments');
         processArgs(args, state, true, true);
       }
     }
-    function processArgs(args, state, acceptWorkletizableFunction, acceptObject) {
+    function processArgs(
+      args,
+      state,
+      acceptWorkletizableFunction,
+      acceptObject
+    ) {
       args.forEach((arg) => {
-        (0, objectWorklets_1.tryProcessingNode)(arg, state, acceptWorkletizableFunction, acceptObject);
+        (0, objectWorklets_1.tryProcessingNode)(
+          arg,
+          state,
+          acceptWorkletizableFunction,
+          acceptObject
+        );
       });
     }
-  }
+  },
 });
 
 // lib/bundleMode.js
 var require_bundleMode = __commonJS({
-  "lib/bundleMode.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/bundleMode.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.toggleBundleMode = toggleBundleMode;
-    var types_12 = require("@babel/types");
+    var types_12 = require('@babel/types');
     function toggleBundleMode(path, state) {
       var _a;
-      if (!state.opts.bundleMode || !((_a = state.filename) === null || _a === void 0 ? void 0 : _a.includes("workletRuntimeEntry"))) {
+      if (
+        !state.opts.bundleMode ||
+        !((_a = state.filename) === null || _a === void 0
+          ? void 0
+          : _a.includes('workletRuntimeEntry'))
+      ) {
         return;
       }
-      const expressionPath = path.get("expression");
+      const expressionPath = path.get('expression');
       if (!expressionPath.isAssignmentExpression()) {
         return;
       }
-      const left = expressionPath.get("left");
+      const left = expressionPath.get('left');
       if (!left.isMemberExpression()) {
         return;
       }
-      const object = left.get("object");
-      const property = left.get("property");
-      if (!object.isIdentifier() || object.node.name !== "globalThis" || !property.isIdentifier() || property.node.name !== "_WORKLETS_BUNDLE_MODE") {
+      const object = left.get('object');
+      const property = left.get('property');
+      if (
+        !object.isIdentifier() ||
+        object.node.name !== 'globalThis' ||
+        !property.isIdentifier() ||
+        property.node.name !== '_WORKLETS_BUNDLE_MODE'
+      ) {
         return;
       }
-      const right = expressionPath.get("right");
+      const right = expressionPath.get('right');
       right.replaceWith((0, types_12.booleanLiteral)(true));
     }
-  }
+  },
 });
 
 // lib/class.js
 var require_class = __commonJS({
-  "lib/class.js"(exports2) {
-    "use strict";
-    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/class.js'(exports2) {
+    'use strict';
+    var __importDefault =
+      (exports2 && exports2.__importDefault) ||
+      function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod };
+      };
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.processIfWorkletClass = processIfWorkletClass;
-    var generator_1 = __importDefault(require("@babel/generator"));
-    var traverse_1 = __importDefault(require("@babel/traverse"));
-    var types_12 = require("@babel/types");
-    var assert_1 = require("assert");
+    var generator_1 = __importDefault(require('@babel/generator'));
+    var traverse_1 = __importDefault(require('@babel/traverse'));
+    var types_12 = require('@babel/types');
+    var assert_1 = require('assert');
     var transform_1 = require_transform();
     var types_2 = require_types();
     var utils_1 = require_utils();
-    var classWorkletMarker = "__workletClass";
+    var classWorkletMarker = '__workletClass';
     function processIfWorkletClass(classPath, state) {
       if (!isWorkletizableClass(classPath, state) || state.opts.bundleMode) {
         return false;
@@ -1341,66 +2062,134 @@ var require_class = __commonJS({
       const polyfilledClassAst = getPolyfilledAst(classPath.node, state);
       sortPolyfills(polyfilledClassAst);
       appendWorkletDirectiveToPolyfills(polyfilledClassAst.program.body);
-      replaceClassDeclarationWithFactoryAndCall(polyfilledClassAst.program.body, className);
-      polyfilledClassAst.program.body.push((0, types_12.returnStatement)((0, types_12.identifier)(className)));
-      const factoryFactory = (0, types_12.functionExpression)(null, [], (0, types_12.blockStatement)([...polyfilledClassAst.program.body]));
+      replaceClassDeclarationWithFactoryAndCall(
+        polyfilledClassAst.program.body,
+        className
+      );
+      polyfilledClassAst.program.body.push(
+        (0, types_12.returnStatement)((0, types_12.identifier)(className))
+      );
+      const factoryFactory = (0, types_12.functionExpression)(
+        null,
+        [],
+        (0, types_12.blockStatement)([...polyfilledClassAst.program.body])
+      );
       const factoryCall = (0, types_12.callExpression)(factoryFactory, []);
       (0, utils_1.replaceWithFactoryCall)(classPath, className, factoryCall);
     }
     function getPolyfilledAst(classNode, state) {
       var _a;
       const classCode = (0, generator_1.default)(classNode).code;
-      const classWithPolyfills = (0, transform_1.workletTransformSync)(classCode, {
-        extraPlugins: [
-          "@babel/plugin-transform-class-properties",
-          "@babel/plugin-transform-classes",
-          "@babel/plugin-transform-unicode-regex",
-          ...(_a = state.opts.extraPlugins) !== null && _a !== void 0 ? _a : []
-        ],
-        extraPresets: state.opts.extraPresets,
-        filename: state.file.opts.filename,
-        ast: true,
-        babelrc: false,
-        configFile: false
-      });
+      const classWithPolyfills = (0, transform_1.workletTransformSync)(
+        classCode,
+        {
+          extraPlugins: [
+            '@babel/plugin-transform-class-properties',
+            '@babel/plugin-transform-classes',
+            '@babel/plugin-transform-unicode-regex',
+            ...((_a = state.opts.extraPlugins) !== null && _a !== void 0
+              ? _a
+              : []),
+          ],
+          extraPresets: state.opts.extraPresets,
+          filename: state.file.opts.filename,
+          ast: true,
+          babelrc: false,
+          configFile: false,
+        }
+      );
       (0, assert_1.strict)(classWithPolyfills && classWithPolyfills.ast);
       return classWithPolyfills.ast;
     }
     function appendWorkletDirectiveToPolyfills(statements) {
       statements.forEach((statement) => {
         if ((0, types_12.isFunctionDeclaration)(statement)) {
-          const workletDirective = (0, types_12.directive)((0, types_12.directiveLiteral)("worklet"));
+          const workletDirective = (0, types_12.directive)(
+            (0, types_12.directiveLiteral)('worklet')
+          );
           statement.body.directives.push(workletDirective);
         }
       });
     }
     function replaceClassDeclarationWithFactoryAndCall(statements, className) {
       const classFactoryName = className + types_2.workletClassFactorySuffix;
-      const classDeclarationIndex = getPolyfilledClassDeclarationIndex(statements, className);
+      const classDeclarationIndex = getPolyfilledClassDeclarationIndex(
+        statements,
+        className
+      );
       const classDeclarationToReplace = statements[classDeclarationIndex];
-      const classDeclarationInit = classDeclarationToReplace.declarations[0].init;
-      const classFactoryDeclaration = (0, types_12.functionDeclaration)((0, types_12.identifier)(classFactoryName), [], (0, types_12.blockStatement)([
-        (0, types_12.variableDeclaration)("const", [
-          (0, types_12.variableDeclarator)((0, types_12.identifier)(className), classDeclarationInit)
-        ]),
-        (0, types_12.expressionStatement)((0, types_12.assignmentExpression)("=", (0, types_12.memberExpression)((0, types_12.identifier)(className), (0, types_12.identifier)(classFactoryName)), (0, types_12.identifier)(classFactoryName))),
-        (0, types_12.returnStatement)((0, types_12.identifier)(className))
-      ], [(0, types_12.directive)((0, types_12.directiveLiteral)("worklet"))]));
-      const newClassDeclaration = (0, types_12.variableDeclaration)("const", [
-        (0, types_12.variableDeclarator)((0, types_12.identifier)(className), (0, types_12.callExpression)((0, types_12.identifier)(classFactoryName), []))
+      const classDeclarationInit =
+        classDeclarationToReplace.declarations[0].init;
+      const classFactoryDeclaration = (0, types_12.functionDeclaration)(
+        (0, types_12.identifier)(classFactoryName),
+        [],
+        (0, types_12.blockStatement)(
+          [
+            (0, types_12.variableDeclaration)('const', [
+              (0, types_12.variableDeclarator)(
+                (0, types_12.identifier)(className),
+                classDeclarationInit
+              ),
+            ]),
+            (0, types_12.expressionStatement)(
+              (0, types_12.assignmentExpression)(
+                '=',
+                (0, types_12.memberExpression)(
+                  (0, types_12.identifier)(className),
+                  (0, types_12.identifier)(classFactoryName)
+                ),
+                (0, types_12.identifier)(classFactoryName)
+              )
+            ),
+            (0, types_12.returnStatement)((0, types_12.identifier)(className)),
+          ],
+          [(0, types_12.directive)((0, types_12.directiveLiteral)('worklet'))]
+        )
+      );
+      const newClassDeclaration = (0, types_12.variableDeclaration)('const', [
+        (0, types_12.variableDeclarator)(
+          (0, types_12.identifier)(className),
+          (0, types_12.callExpression)(
+            (0, types_12.identifier)(classFactoryName),
+            []
+          )
+        ),
       ]);
-      statements.splice(classDeclarationIndex, 1, classFactoryDeclaration, newClassDeclaration);
+      statements.splice(
+        classDeclarationIndex,
+        1,
+        classFactoryDeclaration,
+        newClassDeclaration
+      );
     }
     function getPolyfilledClassDeclarationIndex(statements, className) {
-      const index = statements.findIndex((statement) => (0, types_12.isVariableDeclaration)(statement) && statement.declarations.some((declaration) => (0, types_12.isIdentifier)(declaration.id) && declaration.id.name === className));
+      const index = statements.findIndex(
+        (statement) =>
+          (0, types_12.isVariableDeclaration)(statement) &&
+          statement.declarations.some(
+            (declaration) =>
+              (0, types_12.isIdentifier)(declaration.id) &&
+              declaration.id.name === className
+          )
+      );
       (0, assert_1.strict)(index >= 0);
       return index;
     }
     function hasWorkletClassMarker(classBody) {
-      return classBody.body.some((statement) => (0, types_12.isClassProperty)(statement) && (0, types_12.isIdentifier)(statement.key) && statement.key.name === classWorkletMarker);
+      return classBody.body.some(
+        (statement) =>
+          (0, types_12.isClassProperty)(statement) &&
+          (0, types_12.isIdentifier)(statement.key) &&
+          statement.key.name === classWorkletMarker
+      );
     }
     function removeWorkletClassMarker(classBody) {
-      classBody.body = classBody.body.filter((statement) => !(0, types_12.isClassProperty)(statement) || !(0, types_12.isIdentifier)(statement.key) || statement.key.name !== classWorkletMarker);
+      classBody.body = classBody.body.filter(
+        (statement) =>
+          !(0, types_12.isClassProperty)(statement) ||
+          !(0, types_12.isIdentifier)(statement.key) ||
+          statement.key.name !== classWorkletMarker
+      );
     }
     function sortPolyfills(ast) {
       const toSort = getPolyfillsToSort(ast);
@@ -1421,29 +2210,36 @@ var require_class = __commonJS({
       (0, traverse_1.default)(ast, {
         Program: {
           enter: (functionPath) => {
-            const statements = functionPath.get("body");
+            const statements = functionPath.get('body');
             statements.forEach((statement, index) => {
               var _a;
               const bindingIdentifiers = statement.getBindingIdentifiers();
-              if (!statement.isFunctionDeclaration() || !((_a = statement.node.id) === null || _a === void 0 ? void 0 : _a.name)) {
+              if (
+                !statement.isFunctionDeclaration() ||
+                !((_a = statement.node.id) === null || _a === void 0
+                  ? void 0
+                  : _a.name)
+              ) {
                 return;
               }
               const element = {
                 name: statement.node.id.name,
                 index,
-                dependencies: /* @__PURE__ */ new Set()
+                dependencies: /* @__PURE__ */ new Set(),
               };
               polyfills.push(element);
               statement.traverse({
                 Identifier(path) {
-                  if (isOutsideDependency(path, bindingIdentifiers, statement)) {
+                  if (
+                    isOutsideDependency(path, bindingIdentifiers, statement)
+                  ) {
                     element.dependencies.add(path.node.name);
                   }
-                }
+                },
               });
             });
-          }
-        }
+          },
+        },
       });
       return polyfills;
     }
@@ -1457,7 +2253,7 @@ var require_class = __commonJS({
     }
     function recursiveTopoSort(current, toSort, sorted, stack) {
       if (stack.has(current.name)) {
-        throw new Error("Cycle detected. This should never happen.");
+        throw new Error('Cycle detected. This should never happen.');
       }
       if (sorted.find((element) => element.name === current.name)) {
         return;
@@ -1473,36 +2269,52 @@ var require_class = __commonJS({
       sorted.push(current);
       stack.delete(current.name);
     }
-    function isOutsideDependency(identifierPath, bindingIdentifiers, functionPath) {
-      return identifierPath.isReferencedIdentifier() && !(identifierPath.node.name in bindingIdentifiers) && !functionPath.scope.hasOwnBinding(identifierPath.node.name) && functionPath.scope.hasReference(identifierPath.node.name);
+    function isOutsideDependency(
+      identifierPath,
+      bindingIdentifiers,
+      functionPath
+    ) {
+      return (
+        identifierPath.isReferencedIdentifier() &&
+        !(identifierPath.node.name in bindingIdentifiers) &&
+        !functionPath.scope.hasOwnBinding(identifierPath.node.name) &&
+        functionPath.scope.hasReference(identifierPath.node.name)
+      );
     }
     function isWorkletizableClass(classPath, state) {
       var _a;
-      const className = (_a = classPath.node.id) === null || _a === void 0 ? void 0 : _a.name;
+      const className =
+        (_a = classPath.node.id) === null || _a === void 0 ? void 0 : _a.name;
       const classNode = classPath.node;
       if (!className) {
         return false;
       }
       const isMarked = hasWorkletClassMarker(classNode.body);
-      const isMemoizedNode = state.classesToWorkletize.some((record) => record.node === classNode);
-      const isTopLevelMemoizedName = classPath.parentPath.isProgram() && state.classesToWorkletize.some((record) => record.name === className);
-      state.classesToWorkletize = state.classesToWorkletize.filter((record) => record.node !== classNode && record.name !== className);
+      const isMemoizedNode = state.classesToWorkletize.some(
+        (record) => record.node === classNode
+      );
+      const isTopLevelMemoizedName =
+        classPath.parentPath.isProgram() &&
+        state.classesToWorkletize.some((record) => record.name === className);
+      state.classesToWorkletize = state.classesToWorkletize.filter(
+        (record) => record.node !== classNode && record.name !== className
+      );
       const result = isMarked || isMemoizedNode || isTopLevelMemoizedName;
       return result;
     }
-  }
+  },
 });
 
 // lib/contextObject.js
 var require_contextObject = __commonJS({
-  "lib/contextObject.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/contextObject.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.contextObjectMarker = void 0;
     exports2.processIfWorkletContextObject = processIfWorkletContextObject;
     exports2.isContextObject = isContextObject;
-    var types_12 = require("@babel/types");
-    exports2.contextObjectMarker = "__workletContextObject";
+    var types_12 = require('@babel/types');
+    exports2.contextObjectMarker = '__workletContextObject';
     function processIfWorkletContextObject(path, _state) {
       if (!isContextObject(path.node)) {
         return false;
@@ -1512,38 +2324,72 @@ var require_contextObject = __commonJS({
       return true;
     }
     function isContextObject(objectExpression) {
-      return objectExpression.properties.some((property) => (0, types_12.isObjectProperty)(property) && (0, types_12.isIdentifier)(property.key) && property.key.name === exports2.contextObjectMarker);
+      return objectExpression.properties.some(
+        (property) =>
+          (0, types_12.isObjectProperty)(property) &&
+          (0, types_12.isIdentifier)(property.key) &&
+          property.key.name === exports2.contextObjectMarker
+      );
     }
     function processWorkletContextObject(objectExpression) {
-      const workletObjectFactory = (0, types_12.functionExpression)(null, [], (0, types_12.blockStatement)([(0, types_12.returnStatement)((0, types_12.cloneNode)(objectExpression))], [(0, types_12.directive)((0, types_12.directiveLiteral)("worklet"))]));
-      objectExpression.properties.push((0, types_12.objectProperty)((0, types_12.identifier)(`${exports2.contextObjectMarker}Factory`), workletObjectFactory));
+      const workletObjectFactory = (0, types_12.functionExpression)(
+        null,
+        [],
+        (0, types_12.blockStatement)(
+          [
+            (0, types_12.returnStatement)(
+              (0, types_12.cloneNode)(objectExpression)
+            ),
+          ],
+          [(0, types_12.directive)((0, types_12.directiveLiteral)('worklet'))]
+        )
+      );
+      objectExpression.properties.push(
+        (0, types_12.objectProperty)(
+          (0, types_12.identifier)(`${exports2.contextObjectMarker}Factory`),
+          workletObjectFactory
+        )
+      );
     }
     function removeContextObjectMarker(objectExpression) {
-      objectExpression.properties = objectExpression.properties.filter((property) => !((0, types_12.isObjectProperty)(property) && (0, types_12.isIdentifier)(property.key) && property.key.name === exports2.contextObjectMarker));
-    }
-  }
+      objectExpression.properties = objectExpression.properties.filter(
+        (property) =>
+          !(
+            (0, types_12.isObjectProperty)(property) &&
+            (0, types_12.isIdentifier)(property.key) &&
+            property.key.name === exports2.contextObjectMarker
+          )
+      );
+    }
+  },
 });
 
 // lib/file.js
 var require_file = __commonJS({
-  "lib/file.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/file.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.processIfWorkletFile = processIfWorkletFile;
     exports2.isImplicitContextObject = isImplicitContextObject;
-    var types_12 = require("@babel/types");
+    var types_12 = require('@babel/types');
     var contextObject_12 = require_contextObject();
     var types_2 = require_types();
     function processIfWorkletFile(path, state) {
-      if (!path.node.directives.some((functionDirective) => functionDirective.value.value === "worklet")) {
+      if (
+        !path.node.directives.some(
+          (functionDirective) => functionDirective.value.value === 'worklet'
+        )
+      ) {
         return false;
       }
-      path.node.directives = path.node.directives.filter((functionDirective) => functionDirective.value.value !== "worklet");
+      path.node.directives = path.node.directives.filter(
+        (functionDirective) => functionDirective.value.value !== 'worklet'
+      );
       processWorkletFile(path, state);
       return true;
     }
     function processWorkletFile(programPath, state) {
-      const statements = programPath.get("body");
+      const statements = programPath.get('body');
       dehoistCommonJSExports(programPath.node);
       statements.forEach((statement) => {
         const candidatePath = getCandidate(statement);
@@ -1551,8 +2397,11 @@ var require_file = __commonJS({
       });
     }
     function getCandidate(statementPath) {
-      if (statementPath.isExportNamedDeclaration() || statementPath.isExportDefaultDeclaration()) {
-        return statementPath.get("declaration");
+      if (
+        statementPath.isExportNamedDeclaration() ||
+        statementPath.isExportDefaultDeclaration()
+      ) {
+        return statementPath.get('declaration');
       } else {
         return statementPath;
       }
@@ -1574,52 +2423,74 @@ var require_file = __commonJS({
         processVariableDeclaration(nodePath, state);
       } else if (nodePath.isClassDeclaration()) {
         appendWorkletClassMarker(nodePath.node.body);
-        if ((_a = nodePath.node.id) === null || _a === void 0 ? void 0 : _a.name) {
+        if (
+          (_a = nodePath.node.id) === null || _a === void 0 ? void 0 : _a.name
+        ) {
           state.classesToWorkletize.push({
             node: nodePath.node,
-            name: nodePath.node.id.name
+            name: nodePath.node.id.name,
           });
         }
       }
     }
     function processVariableDeclaration(variableDeclarationPath, state) {
-      const declarations = variableDeclarationPath.get("declarations");
+      const declarations = variableDeclarationPath.get('declarations');
       declarations.forEach((declaration) => {
-        const initPath = declaration.get("init");
+        const initPath = declaration.get('init');
         if (initPath.isExpression()) {
           processWorkletizableEntity(initPath, state);
         }
       });
     }
     function processWorkletAggregator(objectPath, state) {
-      const properties = objectPath.get("properties");
+      const properties = objectPath.get('properties');
       properties.forEach((property) => {
         if (property.isObjectMethod()) {
           appendWorkletDirective(property.node.body);
         } else if (property.isObjectProperty()) {
-          const valuePath = property.get("value");
+          const valuePath = property.get('value');
           processWorkletizableEntity(valuePath, state);
         }
       });
     }
     function replaceImplicitReturnWithBlock(path) {
       if (!(0, types_12.isBlockStatement)(path.body)) {
-        path.body = (0, types_12.blockStatement)([(0, types_12.returnStatement)(path.body)]);
+        path.body = (0, types_12.blockStatement)([
+          (0, types_12.returnStatement)(path.body),
+        ]);
       }
     }
     function appendWorkletDirective(node) {
-      if (!node.directives.some((functionDirective) => functionDirective.value.value === "worklet")) {
-        node.directives.push((0, types_12.directive)((0, types_12.directiveLiteral)("worklet")));
+      if (
+        !node.directives.some(
+          (functionDirective) => functionDirective.value.value === 'worklet'
+        )
+      ) {
+        node.directives.push(
+          (0, types_12.directive)((0, types_12.directiveLiteral)('worklet'))
+        );
       }
     }
     function appendWorkletContextObjectMarker(objectExpression) {
-      if (objectExpression.properties.some((value) => (0, types_12.isObjectProperty)(value) && (0, types_12.isIdentifier)(value.key) && value.key.name === contextObject_12.contextObjectMarker)) {
+      if (
+        objectExpression.properties.some(
+          (value) =>
+            (0, types_12.isObjectProperty)(value) &&
+            (0, types_12.isIdentifier)(value.key) &&
+            value.key.name === contextObject_12.contextObjectMarker
+        )
+      ) {
         return;
       }
-      objectExpression.properties.push((0, types_12.objectProperty)((0, types_12.identifier)(`${contextObject_12.contextObjectMarker}`), (0, types_12.booleanLiteral)(true)));
+      objectExpression.properties.push(
+        (0, types_12.objectProperty)(
+          (0, types_12.identifier)(`${contextObject_12.contextObjectMarker}`),
+          (0, types_12.booleanLiteral)(true)
+        )
+      );
     }
     function isImplicitContextObject(path) {
-      const propertyPaths = path.get("properties");
+      const propertyPaths = path.get('properties');
       return propertyPaths.some((propertyPath) => {
         if (!propertyPath.isObjectMethod()) {
           return false;
@@ -1633,12 +2504,17 @@ var require_file = __commonJS({
         ThisExpression(thisPath) {
           result = true;
           thisPath.stop();
-        }
+        },
       });
       return result;
     }
     function appendWorkletClassMarker(classBody) {
-      classBody.body.push((0, types_12.classProperty)((0, types_12.identifier)("__workletClass"), (0, types_12.booleanLiteral)(true)));
+      classBody.body.push(
+        (0, types_12.classProperty)(
+          (0, types_12.identifier)('__workletClass'),
+          (0, types_12.booleanLiteral)(true)
+        )
+      );
     }
     function dehoistCommonJSExports(program) {
       const statements = program.body;
@@ -1656,41 +2532,74 @@ var require_file = __commonJS({
       }
     }
     function isCommonJSExport(statement) {
-      return (0, types_12.isExpressionStatement)(statement) && (0, types_12.isAssignmentExpression)(statement.expression) && (0, types_12.isMemberExpression)(statement.expression.left) && (0, types_12.isIdentifier)(statement.expression.left.object) && statement.expression.left.object.name === "exports";
-    }
-  }
+      return (
+        (0, types_12.isExpressionStatement)(statement) &&
+        (0, types_12.isAssignmentExpression)(statement.expression) &&
+        (0, types_12.isMemberExpression)(statement.expression.left) &&
+        (0, types_12.isIdentifier)(statement.expression.left.object) &&
+        statement.expression.left.object.name === 'exports'
+      );
+    }
+  },
 });
 
 // lib/inlineStylesWarning.js
 var require_inlineStylesWarning = __commonJS({
-  "lib/inlineStylesWarning.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/inlineStylesWarning.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.processInlineStylesWarning = processInlineStylesWarning;
-    var types_12 = require("@babel/types");
-    var assert_1 = require("assert");
+    var types_12 = require('@babel/types');
+    var assert_1 = require('assert');
     var utils_1 = require_utils();
     function generateInlineStylesWarning(path) {
-      return (0, types_12.callExpression)((0, types_12.arrowFunctionExpression)([], (0, types_12.blockStatement)([
-        (0, types_12.expressionStatement)((0, types_12.callExpression)((0, types_12.memberExpression)((0, types_12.identifier)("console"), (0, types_12.identifier)("warn")), [
-          (0, types_12.callExpression)((0, types_12.memberExpression)((0, types_12.callExpression)((0, types_12.identifier)("require"), [
-            (0, types_12.stringLiteral)("react-native-reanimated")
-          ]), (0, types_12.identifier)("getUseOfValueInStyleWarning")), [])
-        ])),
-        (0, types_12.returnStatement)(path.node)
-      ])), []);
+      return (0, types_12.callExpression)(
+        (0, types_12.arrowFunctionExpression)(
+          [],
+          (0, types_12.blockStatement)([
+            (0, types_12.expressionStatement)(
+              (0, types_12.callExpression)(
+                (0, types_12.memberExpression)(
+                  (0, types_12.identifier)('console'),
+                  (0, types_12.identifier)('warn')
+                ),
+                [
+                  (0, types_12.callExpression)(
+                    (0, types_12.memberExpression)(
+                      (0, types_12.callExpression)(
+                        (0, types_12.identifier)('require'),
+                        [(0, types_12.stringLiteral)('react-native-reanimated')]
+                      ),
+                      (0, types_12.identifier)('getUseOfValueInStyleWarning')
+                    ),
+                    []
+                  ),
+                ]
+              )
+            ),
+            (0, types_12.returnStatement)(path.node),
+          ])
+        ),
+        []
+      );
     }
     function processPropertyValueForInlineStylesWarning(path) {
-      if (path.isMemberExpression() && (0, types_12.isIdentifier)(path.node.property)) {
-        if (path.node.property.name === "value") {
+      if (
+        path.isMemberExpression() &&
+        (0, types_12.isIdentifier)(path.node.property)
+      ) {
+        if (path.node.property.name === 'value') {
           path.replaceWith(generateInlineStylesWarning(path));
         }
       }
     }
     function processTransformPropertyForInlineStylesWarning(path) {
       if ((0, types_12.isArrayExpression)(path.node)) {
-        const elements = path.get("elements");
-        (0, assert_1.strict)(Array.isArray(elements), "[Reanimated] `elements` should be an array.");
+        const elements = path.get('elements');
+        (0, assert_1.strict)(
+          Array.isArray(elements),
+          '[Reanimated] `elements` should be an array.'
+        );
         for (const element of elements) {
           if (element.isObjectExpression()) {
             processStyleObjectForInlineStylesWarning(element);
@@ -1699,11 +2608,14 @@ var require_inlineStylesWarning = __commonJS({
       }
     }
     function processStyleObjectForInlineStylesWarning(path) {
-      const properties = path.get("properties");
+      const properties = path.get('properties');
       for (const property of properties) {
         if (property.isObjectProperty()) {
-          const value = property.get("value");
-          if ((0, types_12.isIdentifier)(property.node.key) && property.node.key.name === "transform") {
+          const value = property.get('value');
+          if (
+            (0, types_12.isIdentifier)(property.node.key) &&
+            property.node.key.name === 'transform'
+          ) {
             processTransformPropertyForInlineStylesWarning(value);
           } else {
             processPropertyValueForInlineStylesWarning(value);
@@ -1718,17 +2630,23 @@ var require_inlineStylesWarning = __commonJS({
       if (state.opts.disableInlineStylesWarning) {
         return;
       }
-      if (path.node.name.name !== "style") {
+      if (path.node.name.name !== 'style') {
         return;
       }
       if (!(0, types_12.isJSXExpressionContainer)(path.node.value)) {
         return;
       }
-      const expression = path.get("value").get("expression");
-      (0, assert_1.strict)(!Array.isArray(expression), "[Reanimated] `expression` should not be an array.");
+      const expression = path.get('value').get('expression');
+      (0, assert_1.strict)(
+        !Array.isArray(expression),
+        '[Reanimated] `expression` should not be an array.'
+      );
       if (expression.isArrayExpression()) {
-        const elements = expression.get("elements");
-        (0, assert_1.strict)(Array.isArray(elements), "[Reanimated] `elements` should be an array.");
+        const elements = expression.get('elements');
+        (0, assert_1.strict)(
+          Array.isArray(elements),
+          '[Reanimated] `elements` should be an array.'
+        );
         for (const element of elements) {
           if (element.isObjectExpression()) {
             processStyleObjectForInlineStylesWarning(element);
@@ -1738,30 +2656,30 @@ var require_inlineStylesWarning = __commonJS({
         processStyleObjectForInlineStylesWarning(expression);
       }
     }
-  }
+  },
 });
 
 // lib/webOptimization.js
 var require_webOptimization = __commonJS({
-  "lib/webOptimization.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
+  'lib/webOptimization.js'(exports2) {
+    'use strict';
+    Object.defineProperty(exports2, '__esModule', { value: true });
     exports2.substituteWebCallExpression = substituteWebCallExpression;
-    var types_12 = require("@babel/types");
+    var types_12 = require('@babel/types');
     function substituteWebCallExpression(path) {
       const callee = path.node.callee;
       if ((0, types_12.isIdentifier)(callee)) {
         const name = callee.name;
-        if (name === "isWeb" || name === "shouldBeUseWeb") {
+        if (name === 'isWeb' || name === 'shouldBeUseWeb') {
           path.replaceWith((0, types_12.booleanLiteral)(true));
         }
       }
     }
-  }
+  },
 });
 
 // lib/plugin.js
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 var autoworkletization_1 = require_autoworkletization();
 var bundleMode_1 = require_bundleMode();
 var class_1 = require_class();
@@ -1779,12 +2697,12 @@ module.exports = function WorkletsBabelPlugin() {
     } catch (e) {
       const error = e;
       error.message = `[Worklets] Babel plugin exception: ${error.message}`;
-      error.name = "WorkletsBabelPluginError";
+      error.name = 'WorkletsBabelPluginError';
       throw error;
     }
   }
   return {
-    name: "worklets",
+    name: 'worklets',
     pre() {
       runWithTaggedExceptions(() => {
         (0, globals_1.initializeState)(this);
@@ -1794,24 +2712,37 @@ module.exports = function WorkletsBabelPlugin() {
       CallExpression: {
         enter(path, state) {
           runWithTaggedExceptions(() => {
-            (0, autoworkletization_1.processCalleesAutoworkletizableCallbacks)(path, state);
+            (0, autoworkletization_1.processCalleesAutoworkletizableCallbacks)(
+              path,
+              state
+            );
             if (state.opts.substituteWebPlatformChecks) {
               (0, webOptimization_1.substituteWebCallExpression)(path);
             }
           });
-        }
+        },
       },
       [types_1.WorkletizableFunction]: {
         enter(path, state) {
-          runWithTaggedExceptions(() => (0, workletSubstitution_1.processIfWithWorkletDirective)(path, state) || (0, autoworkletization_1.processIfAutoworkletizableCallback)(path, state));
-        }
+          runWithTaggedExceptions(
+            () =>
+              (0, workletSubstitution_1.processIfWithWorkletDirective)(
+                path,
+                state
+              ) ||
+              (0, autoworkletization_1.processIfAutoworkletizableCallback)(
+                path,
+                state
+              )
+          );
+        },
       },
       ObjectExpression: {
         enter(path, state) {
           runWithTaggedExceptions(() => {
             (0, contextObject_1.processIfWorkletContextObject)(path, state);
           });
-        }
+        },
       },
       ClassDeclaration: {
         enter(path, state) {
@@ -1821,28 +2752,30 @@ module.exports = function WorkletsBabelPlugin() {
             }
             (0, class_1.processIfWorkletClass)(path, state);
           });
-        }
+        },
       },
       Program: {
         enter(path, state) {
           runWithTaggedExceptions(() => {
             (0, file_1.processIfWorkletFile)(path, state);
           });
-        }
+        },
       },
       ExpressionStatement: {
         enter(path, state) {
           runWithTaggedExceptions(() => {
             (0, bundleMode_1.toggleBundleMode)(path, state);
           });
-        }
+        },
       },
       JSXAttribute: {
         enter(path, state) {
-          runWithTaggedExceptions(() => (0, inlineStylesWarning_1.processInlineStylesWarning)(path, state));
-        }
-      }
-    }
+          runWithTaggedExceptions(() =>
+            (0, inlineStylesWarning_1.processInlineStylesWarning)(path, state)
+          );
+        },
+      },
+    },
   };
 };
 //# sourceMappingURL=index.js.map