react-native-worklets 0.11.1 → 0.12.0-nightly-20260717-55ef079be

package/plugin/index.js

@@ -25,6 +25,174 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// lib/directives.js
+var require_directives = __commonJS({
+  "lib/directives.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.addDirective = addDirective;
+    exports2.replaceImplicitReturnWithBlock = replaceImplicitReturnWithBlock;
+    var types_12 = require("@babel/types");
+    function addDirective(node, dir) {
+      if (!node.directives.some((functionDirective) => functionDirective.value.value === dir)) {
+        node.directives.push((0, types_12.directive)((0, types_12.directiveLiteral)(dir)));
+      }
+    }
+    function replaceImplicitReturnWithBlock(path) {
+      if (!(0, types_12.isBlockStatement)(path.body)) {
+        path.body = (0, types_12.blockStatement)([(0, types_12.returnStatement)(path.body)]);
+      }
+    }
+  }
+});
+
+// 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;
+    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";
+    function isWorkletizableFunctionPath(path) {
+      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);
+    }
+    function isWorkletizableObjectPath(path) {
+      return path.isObjectExpression();
+    }
+    function isWorkletizableObjectNode(node) {
+      return (0, types_12.isObjectExpression)(node);
+    }
+    exports2.workletClassFactorySuffix = "__classFactory";
+    exports2.generatedWorkletsDir = ".worklets";
+  }
+});
+
+// lib/referencedWorklets.js
+var require_referencedWorklets = __commonJS({
+  "lib/referencedWorklets.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.findReferencedWorklet = findReferencedWorklet;
+    var types_12 = require("@babel/types");
+    var types_2 = require_types();
+    function findReferencedWorklet(workletIdentifier, acceptWorkletizableFunction, acceptObject, state) {
+      const workletName = workletIdentifier.node.name;
+      const scope = workletIdentifier.scope;
+      const workletBinding = scope.getBinding(workletName);
+      if (!workletBinding) {
+        return void 0;
+      }
+      if (state.opts.bundleMode && bindingIsWorklet(workletBinding)) {
+        return void 0;
+      }
+      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) {
+      const workletDeclaration = workletBinding.path;
+      if (!workletDeclaration.isVariableDeclarator()) {
+        return void 0;
+      }
+      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 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"))));
+      if (!workletDeclaration || !workletDeclaration.isAssignmentExpression()) {
+        return void 0;
+      }
+      const workletDefinition = workletDeclaration.get("right");
+      if (acceptWorkletizableFunction && (0, types_2.isWorkletizableFunctionPath)(workletDefinition)) {
+        return workletDefinition;
+      }
+      if (acceptObject && (0, types_2.isWorkletizableObjectPath)(workletDefinition)) {
+        return workletDefinition;
+      }
+      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");
+    }
+  }
+});
+
+// lib/findWorklet.js
+var require_findWorklet = __commonJS({
+  "lib/findWorklet.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.findWorklet = findWorklet;
+    exports2.forEachWorkletizableFunction = forEachWorkletizableFunction;
+    exports2.forEachWorkletizableObjectProperty = forEachWorkletizableObjectProperty;
+    var referencedWorklets_1 = require_referencedWorklets();
+    var types_12 = require_types();
+    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);
+        return worklet;
+      }
+      return void 0;
+    }
+    function forEachWorkletizableFunction(arg, state, acceptWorkletizableFunction, acceptObject, callback) {
+      const maybeWorklet = findWorklet(arg, state, acceptWorkletizableFunction, acceptObject);
+      if (!maybeWorklet) {
+        return;
+      }
+      if ((0, types_12.isWorkletizableFunctionPath)(maybeWorklet)) {
+        callback(maybeWorklet);
+      } else if ((0, types_12.isWorkletizableObjectPath)(maybeWorklet)) {
+        forEachWorkletizableObjectProperty(maybeWorklet, state, callback);
+      }
+    }
+    function forEachWorkletizableObjectProperty(path, state, callback) {
+      const properties = path.get("properties");
+      for (const property of properties) {
+        if (property.isObjectMethod()) {
+          callback(property);
+        } else if (property.isObjectProperty()) {
+          const value = property.get("value");
+          forEachWorkletizableFunction(value, state, true, false, callback);
+        } else {
+          throw new Error(`'${property.type}' as to-be workletized argument is not supported for object hooks.`);
+        }
+      }
+    }
+  }
+});
+
 // lib/gestureHandlerAutoworkletization.js
 var require_gestureHandlerAutoworkletization = __commonJS({
   "lib/gestureHandlerAutoworkletization.js"(exports2) {
@@ -251,124 +419,179 @@ var require_layoutAnimationAutoworkletization = __commonJS({
   }
 });
 
-// lib/types.js
-var require_types = __commonJS({
-  "lib/types.js"(exports2) {
+// lib/autoworkletization.js
+var require_autoworkletization = __commonJS({
+  "lib/autoworkletization.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;
+    exports2.addDirectivesToKnownCallback = addDirectivesToKnownCallback;
+    exports2.handleWorkletizableCallback = handleWorkletizableCallback;
     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();
+    var directives_1 = require_directives();
+    var findWorklet_1 = require_findWorklet();
+    var gestureHandlerAutoworkletization_1 = require_gestureHandlerAutoworkletization();
+    var layoutAnimationAutoworkletization_1 = require_layoutAnimationAutoworkletization();
+    var reanimatedObjectHooks = /* @__PURE__ */ new Set([
+      "useAnimatedScrollHandler",
+      ...Array.from(gestureHandlerAutoworkletization_1.gestureHandlerObjectHooks)
+    ]);
+    var reanimatedFunctionHooks = /* @__PURE__ */ new Set([
+      "useFrameCallback",
+      "useAnimatedStyle",
+      "useAnimatedProps",
+      "createAnimatedPropAdapter",
+      "useDerivedValue",
+      "useAnimatedScrollHandler",
+      "useAnimatedReaction",
+      // animations' callbacks
+      "withTiming",
+      "withSpring",
+      "withDecay",
+      "withRepeat",
+      // scheduling functions
+      "runOnUI",
+      "executeOnUIRuntimeSync",
+      "scheduleOnUI",
+      "runOnUISync",
+      "runOnUIAsync",
+      "runOnRuntime",
+      "runOnRuntimeSync",
+      "runOnRuntimeAsync",
+      "scheduleOnRuntime",
+      "runOnRuntimeSyncWithId",
+      "scheduleOnRuntimeWithId"
+    ]);
+    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]],
+      ["runOnRuntimeSync", [1]],
+      ["runOnRuntimeAsync", [1]],
+      ["scheduleOnRuntime", [1]],
+      ["runOnRuntimeSyncWithId", [1]],
+      ["scheduleOnRuntimeWithId", [1]],
+      ...Array.from(gestureHandlerAutoworkletization_1.gestureHandlerObjectHooks).map((name) => [name, [0]]),
+      ...Array.from(gestureHandlerAutoworkletization_1.gestureHandlerBuilderMethods).map((name) => [name, [0]])
+    ]);
+    function addDirectivesToKnownCallback(path) {
+      if ((0, gestureHandlerAutoworkletization_1.isGestureHandlerEventCallback)(path) || (0, layoutAnimationAutoworkletization_1.isLayoutAnimationCallback)(path)) {
+        addDirectives(path);
+      }
     }
-    function isWorkletizableFunctionNode(node) {
-      return (0, types_12.isFunctionDeclaration)(node) || (0, types_12.isFunctionExpression)(node) || (0, types_12.isArrowFunctionExpression)(node) || (0, types_12.isObjectMethod)(node);
+    function handleWorkletizableCallback(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;
+      if (name === void 0) {
+        return;
+      }
+      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));
+        addDirectivesToArgs(args, state, acceptWorkletizableFunction, acceptObject);
+      } else if (!(0, types_12.isV8IntrinsicIdentifier)(callee) && (0, gestureHandlerAutoworkletization_1.isGestureObjectEventCallbackMethod)(callee)) {
+        const args = path.get("arguments");
+        addDirectivesToArgs(args, state, true, true);
+      }
     }
-    function isWorkletizableObjectPath(path) {
-      return path.isObjectExpression();
+    function addDirectivesToArgs(args, state, acceptWorkletizableFunction, acceptObject) {
+      args.forEach((arg) => {
+        (0, findWorklet_1.forEachWorkletizableFunction)(arg, state, acceptWorkletizableFunction, acceptObject, addDirectives);
+      });
     }
-    function isWorkletizableObjectNode(node) {
-      return (0, types_12.isObjectExpression)(node);
+    function addDirectives(path) {
+      if (path.isArrowFunctionExpression()) {
+        (0, directives_1.replaceImplicitReturnWithBlock)(path.node);
+      }
+      (0, directives_1.addDirective)(path.node.body, "worklet");
     }
-    exports2.workletClassFactorySuffix = "__classFactory";
-    exports2.generatedWorkletsDir = ".worklets";
   }
 });
 
-// lib/referencedWorklets.js
-var require_referencedWorklets = __commonJS({
-  "lib/referencedWorklets.js"(exports2) {
+// lib/bundleMode.js
+var require_bundleMode = __commonJS({
+  "lib/bundleMode.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.findReferencedWorklet = findReferencedWorklet;
+    exports2.toggleBundleMode = toggleBundleMode;
     var types_12 = require("@babel/types");
-    var types_2 = require_types();
-    function findReferencedWorklet(workletIdentifier, acceptWorkletizableFunction, acceptObject, state) {
-      const workletName = workletIdentifier.node.name;
-      const scope = workletIdentifier.scope;
-      const workletBinding = scope.getBinding(workletName);
-      if (!workletBinding) {
-        return void 0;
-      }
-      if (state.opts.bundleMode && bindingIsWorklet(workletBinding)) {
-        return void 0;
-      }
-      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) {
-      const workletDeclaration = workletBinding.path;
-      if (!workletDeclaration.isVariableDeclarator()) {
-        return void 0;
-      }
-      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 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"))));
-      if (!workletDeclaration || !workletDeclaration.isAssignmentExpression()) {
-        return void 0;
+    var path_1 = require("path");
+    var WORKLETS_PACKAGE = "react-native-worklets";
+    var WORKLETS_SRC_DIR = (0, path_1.join)(WORKLETS_PACKAGE, "src");
+    var WORKLETS_LIB_DIR = (0, path_1.join)(WORKLETS_PACKAGE, "lib", "module");
+    var togglePaths = [
+      (0, path_1.join)(WORKLETS_SRC_DIR, "index.ts"),
+      (0, path_1.join)(WORKLETS_SRC_DIR, "debug", "bundleMode.native.ts"),
+      (0, path_1.join)(WORKLETS_LIB_DIR, "index.js"),
+      (0, path_1.join)(WORKLETS_LIB_DIR, "debug", "bundleMode.native.js")
+    ];
+    function toggleBundleMode(path, state) {
+      if (!state.opts.bundleMode || !togglePaths.some((togglePath) => {
+        var _a;
+        return (_a = state.filename) === null || _a === void 0 ? void 0 : _a.endsWith(togglePath);
+      })) {
+        return;
       }
-      const workletDefinition = workletDeclaration.get("right");
-      if (acceptWorkletizableFunction && (0, types_2.isWorkletizableFunctionPath)(workletDefinition)) {
-        return workletDefinition;
+      const expressionPath = path.get("expression");
+      if (!expressionPath.isAssignmentExpression()) {
+        return;
       }
-      if (acceptObject && (0, types_2.isWorkletizableObjectPath)(workletDefinition)) {
-        return workletDefinition;
+      const left = expressionPath.get("left");
+      if (!left.isMemberExpression()) {
+        return;
       }
-      if (workletDefinition.isIdentifier() && workletDefinition.isReferencedIdentifier()) {
-        return findReferencedWorklet(workletDefinition, acceptWorkletizableFunction, acceptObject, state);
+      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_ENABLED") {
+        return;
       }
-      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");
+      const right = expressionPath.get("right");
+      right.replaceWith((0, types_12.booleanLiteral)(true));
     }
   }
 });
 
-// lib/findWorklet.js
-var require_findWorklet = __commonJS({
-  "lib/findWorklet.js"(exports2) {
+// 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 });
-    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)) {
-        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);
-        return worklet;
-      }
-      return void 0;
+    exports2.workletTransformSync = workletTransformSync;
+    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")
+    ];
+    var defaultPlugins = [];
   }
 });
 
@@ -401,1695 +624,1478 @@ var require_utils = __commonJS({
   }
 });
 
-// lib/globals.js
-var require_globals = __commonJS({
-  "lib/globals.js"(exports2) {
+// 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 });
-    exports2.globals = exports2.defaultGlobals = void 0;
-    exports2.initializeState = initializeState;
-    exports2.isGeneratedWorkletFile = isGeneratedWorkletFile;
-    exports2.initializeGlobals = initializeGlobals;
-    exports2.addCustomGlobals = addCustomGlobals;
-    var path_1 = __importDefault(require("path"));
-    var autoworkletization_12 = require_autoworkletization();
-    var types_12 = require_types();
-    var notCapturedIdentifiers = [
-      // Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
-      // Note that objects' properties don't need to be listed since we always only capture the whole object,
-      // e.g. `global.__ErrorUtils` or `Intl.DateTimeFormat`.
-      // Value properties
-      "globalThis",
-      "Infinity",
-      "NaN",
-      "undefined",
-      // Function properties
-      "eval",
-      "isFinite",
-      "isNaN",
-      "parseFloat",
-      "parseInt",
-      "decodeURI",
-      "decodeURIComponent",
-      "encodeURI",
-      "encodeURIComponent",
-      "escape",
-      "unescape",
-      // Fundamental objects
-      "Object",
-      "Function",
-      "Boolean",
-      "Symbol",
-      // Error objects
-      "Error",
-      "AggregateError",
-      "EvalError",
-      "RangeError",
-      "ReferenceError",
-      "SyntaxError",
-      "TypeError",
-      "URIError",
-      "InternalError",
-      // Numbers and dates
-      "Number",
-      "BigInt",
-      "Math",
-      "Date",
-      // Text processing
-      "String",
-      "RegExp",
-      // Indexed collections
-      "Array",
-      "Int8Array",
-      "Uint8Array",
-      "Uint8ClampedArray",
-      "Int16Array",
-      "Uint16Array",
-      "Int32Array",
-      "Uint32Array",
-      "BigInt64Array",
-      "BigUint64Array",
-      "Float32Array",
-      "Float64Array",
-      // Keyed collections
-      "Map",
-      "Set",
-      "WeakMap",
-      "WeakSet",
-      // Structured data
-      "ArrayBuffer",
-      "SharedArrayBuffer",
-      "DataView",
-      "Atomics",
-      "JSON",
-      // Managing memory
-      "WeakRef",
-      "FinalizationRegistry",
-      // Control abstraction objects
-      "Iterator",
-      "AsyncIterator",
-      "Promise",
-      "GeneratorFunction",
-      "AsyncGeneratorFunction",
-      "Generator",
-      "AsyncGenerator",
-      "AsyncFunction",
-      // Reflection
-      "Reflect",
-      "Proxy",
-      // Internationalization
-      "Intl",
-      // Other stuff
-      "null",
-      "this",
-      "global",
-      "window",
-      "globalThis",
-      "self",
-      "console",
-      "performance",
-      "arguments",
-      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments
-      "require",
-      "fetch",
-      "XMLHttpRequest",
-      "WebSocket",
-      // Run loop
-      "queueMicrotask",
-      "requestAnimationFrame",
-      "cancelAnimationFrame",
-      "setTimeout",
-      "clearTimeout",
-      "setImmediate",
-      "clearImmediate",
-      "setInterval",
-      "clearInterval",
-      // Hermes
-      "HermesInternal",
-      // Worklets
-      "_WORKLET"
-    ];
-    function initializeState(state) {
-      var _a, _b;
-      state.skipFile = isGeneratedWorkletFile(state.file.opts.filename);
-      if (state.skipFile) {
-        return;
+    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 transform_1 = require_transform();
+    var types_2 = require_types();
+    var utils_1 = require_utils();
+    var classWorkletMarker = "__workletClass";
+    function processIfWorkletClass(classPath, state) {
+      if (!isWorkletizableClass(classPath, state) || state.opts.bundleMode) {
+        return false;
       }
-      state.workletNumber = 1;
-      state.classesToWorkletize = [];
-      state.autoworkletizationPlugin = {
-        name: "worklets-autoworkletization",
-        visitor: {
-          CallExpression: {
-            enter(nodePath) {
-              (0, autoworkletization_12.processCalleesAutoworkletizableCallbacks)(nodePath, state);
-            }
+      removeWorkletClassMarker(classPath.node.body);
+      processClass(classPath, state);
+      return true;
+    }
+    function processClass(classPath, state) {
+      (0, assert_1.strict)(classPath.node.id);
+      const className = classPath.node.id.name;
+      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]));
+      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
+      });
+      (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"));
+          statement.body.directives.push(workletDirective);
+        }
+      });
+    }
+    function replaceClassDeclarationWithFactoryAndCall(statements, className) {
+      const classFactoryName = className + types_2.workletClassFactorySuffix;
+      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), []))
+      ]);
+      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));
+      (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);
+    }
+    function removeWorkletClassMarker(classBody) {
+      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);
+      const sorted = topoSort(toSort);
+      const toSortIndices = toSort.map((element) => element.index);
+      const sortedIndices = sorted.map((element) => element.index);
+      const statements = ast.program.body;
+      const oldStatements = [...statements];
+      for (let i = 0; i < toSort.length; i++) {
+        const sourceIndex = sortedIndices[i];
+        const targetIndex = toSortIndices[i];
+        const source = oldStatements[sourceIndex];
+        statements[targetIndex] = source;
+      }
+    }
+    function getPolyfillsToSort(ast) {
+      const polyfills = [];
+      (0, traverse_1.default)(ast, {
+        Program: {
+          enter: (functionPath) => {
+            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)) {
+                return;
+              }
+              const element = {
+                name: statement.node.id.name,
+                index,
+                dependencies: /* @__PURE__ */ new Set()
+              };
+              polyfills.push(element);
+              statement.traverse({
+                Identifier(path) {
+                  if (isOutsideDependency(path, bindingIdentifiers, statement)) {
+                    element.dependencies.add(path.node.name);
+                  }
+                }
+              });
+            });
           }
         }
-      };
-      if (!state.opts.strictGlobal) {
-        initializeGlobals();
-        addCustomGlobals(state);
+      });
+      return polyfills;
+    }
+    function topoSort(toSort) {
+      const sorted = [];
+      const stack = /* @__PURE__ */ new Set();
+      for (const element of toSort) {
+        recursiveTopoSort(element, toSort, sorted, stack);
       }
-      const userImportForwarding = state.opts.importForwarding;
-      state.opts.importForwarding = {
-        relativePaths: [
-          ...defaultAllowedPaths,
-          ...(_a = userImportForwarding === null || userImportForwarding === void 0 ? void 0 : userImportForwarding.relativePaths) !== null && _a !== void 0 ? _a : []
-        ],
-        moduleNames: [
-          ...defaultAllowedModules,
-          ...(_b = userImportForwarding === null || userImportForwarding === void 0 ? void 0 : userImportForwarding.moduleNames) !== null && _b !== void 0 ? _b : []
-        ]
-      };
+      return sorted;
     }
-    function isGeneratedWorkletFile(filename) {
-      if (!filename) {
-        return false;
+    function recursiveTopoSort(current, toSort, sorted, stack) {
+      if (stack.has(current.name)) {
+        throw new Error("Cycle detected. This should never happen.");
       }
-      const generatedWorkletsDirPath = path_1.default.join("react-native-worklets", types_12.generatedWorkletsDir);
-      return filename.includes(generatedWorkletsDirPath);
+      if (sorted.find((element) => element.name === current.name)) {
+        return;
+      }
+      stack.add(current.name);
+      for (const dependency of current.dependencies) {
+        if (!sorted.find((element) => element.name === dependency)) {
+          const next = toSort.find((element) => element.name === dependency);
+          (0, assert_1.strict)(next);
+          recursiveTopoSort(next, toSort, sorted, stack);
+        }
+      }
+      sorted.push(current);
+      stack.delete(current.name);
     }
-    exports2.defaultGlobals = new Set(notCapturedIdentifiers);
-    function initializeGlobals() {
-      exports2.globals = new Set(exports2.defaultGlobals);
+    function isOutsideDependency(identifierPath, bindingIdentifiers, functionPath) {
+      return (
+        // We don't care about identifiers that were just declared.
+        identifierPath.isReferencedIdentifier() && // We don't care about identifiers that are bound in the scope.
+        !(identifierPath.node.name in bindingIdentifiers) && // This I don't exactly understand, but the function identifier itself isn't in `bindingIdentifiers`,
+        // but it return true on `hasOwnBinding`.
+        !functionPath.scope.hasOwnBinding(identifierPath.node.name) && // `hasReference` returns true for global identifiers, like `Object`,
+        // we don't want to include those.
+        functionPath.scope.hasReference(identifierPath.node.name)
+      );
     }
-    var defaultAllowedPaths = ["react-native-worklets"];
-    var defaultAllowedModules = [
-      "react-native-worklets",
-      "react-native/Libraries/Core/setUpXHR"
-    ];
-    function addCustomGlobals(state) {
-      if (state.opts && Array.isArray(state.opts.globals)) {
-        state.opts.globals.forEach((name) => {
-          exports2.globals.add(name);
-        });
+    function isWorkletizableClass(classPath, state) {
+      var _a;
+      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 result = isMarked || isMemoizedNode || isTopLevelMemoizedName;
+      return result;
     }
   }
 });
 
-// lib/imports.js
-var require_imports = __commonJS({
-  "lib/imports.js"(exports2) {
+// lib/classMethod.js
+var require_classMethod = __commonJS({
+  "lib/classMethod.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.updateRelativeRequires = updateRelativeRequires;
-    exports2.isImport = isImport;
-    exports2.isImportRelative = isImportRelative;
-    exports2.canForwardModuleImport = canForwardModuleImport;
-    exports2.canForwardRelativeImport = canForwardRelativeImport;
-    exports2.createImportPathLiteral = createImportPathLiteral;
-    var core_1 = require("@babel/core");
+    exports2.processIfWorkletMethod = processIfWorkletMethod;
     var types_12 = require("@babel/types");
-    var path_1 = require("path");
-    var types_2 = require_types();
-    function updateRelativeRequires(node, state) {
-      (0, core_1.traverse)(node, {
-        noScope: true,
-        CallExpression(nodePath) {
-          var _a;
-          if (nodePath.get("callee").isIdentifier({ name: "require" }) && ((_a = nodePath.get("arguments")[0]) === null || _a === void 0 ? void 0 : _a.isStringLiteral())) {
-            const requiredModule = nodePath.get("arguments")[0];
-            if (requiredModule.node.value.startsWith(".") && canForwardRelativeImport(state.file.opts.filename || "", state.opts.importForwarding.relativePaths)) {
-              requiredModule.replaceWith(createImportPathLiteral(requiredModule.node.value, state));
-            }
-          }
-        }
-      });
+    var assert_1 = require("assert");
+    function processIfWorkletMethod(path) {
+      if (path.node.body.directives.some((d) => d.value.value === "worklet")) {
+        (0, assert_1.strict)((0, types_12.isIdentifier)(path.node.key), "ClassMethod key must be an Identifier");
+        const methodIdentifier = path.node.key;
+        path.replaceWith((0, types_12.classProperty)((0, types_12.cloneNode)(methodIdentifier, true), (0, types_12.functionExpression)((0, types_12.cloneNode)(methodIdentifier, true), path.node.params.filter((p) => (0, types_12.isFunctionParameter)(p)).map((p) => (0, types_12.cloneNode)(p, true)), (0, types_12.cloneNode)(path.node.body, true), path.node.generator, path.node.async)));
+      }
     }
-    function isImport(binding) {
-      return binding.kind === "module" && binding.constant && (binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier()) && binding.path.parentPath.isImportDeclaration();
+  }
+});
+
+// lib/contextObject.js
+var require_contextObject = __commonJS({
+  "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";
+    function processIfWorkletContextObject(path, _state) {
+      if (!isContextObject(path.node)) {
+        return false;
+      }
+      removeContextObjectMarker(path.node);
+      processWorkletContextObject(path.node);
+      return true;
     }
-    function isImportRelative(imported) {
-      return imported.path.parentPath.node.source.value.startsWith(".");
-    }
-    function canForwardModuleImport(moduleName, forwardableModuleNames) {
-      return forwardableModuleNames.some((forwardableModuleName) => moduleName === forwardableModuleName || moduleName.startsWith(forwardableModuleName + "/"));
-    }
-    function canForwardRelativeImport(modulePath, relativePaths) {
-      return !!modulePath && relativePaths.some((relativePath) => matchesFilenameSegment(modulePath, relativePath));
+    function isContextObject(objectExpression) {
+      return objectExpression.properties.some((property) => (0, types_12.isObjectProperty)(property) && (0, types_12.isIdentifier)(property.key) && property.key.name === exports2.contextObjectMarker);
     }
-    function matchesFilenameSegment(filename, allowedPath) {
-      const pkgSegments = allowedPath.split(path_1.posix.sep);
-      let fileSegments = filename.split(path_1.sep);
-      const lastNodeModules = fileSegments.lastIndexOf("node_modules");
-      if (lastNodeModules !== -1) {
-        fileSegments = fileSegments.slice(lastNodeModules + 1);
-      }
-      for (let i = 0; i <= fileSegments.length - pkgSegments.length; i++) {
-        if (pkgSegments.every((segment, segmentIndex) => fileSegments[i + segmentIndex] === segment)) {
-          return true;
-        }
-      }
-      return false;
+    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));
     }
-    function createImportPathLiteral(originalPath, state) {
-      const generatedWorkletsDirPath = (0, path_1.resolve)((0, path_1.dirname)(require.resolve("react-native-worklets/package.json")), types_2.generatedWorkletsDir);
-      const resolved = (0, path_1.resolve)((0, path_1.dirname)(state.file.opts.filename), originalPath);
-      const relativePath = (0, path_1.relative)(generatedWorkletsDirPath, resolved);
-      return (0, types_12.stringLiteral)(path_1.sep === "/" ? relativePath : relativePath.split(path_1.sep).join("/"));
+    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));
     }
   }
 });
 
-// lib/closure.js
-var require_closure = __commonJS({
-  "lib/closure.js"(exports2) {
+// lib/file.js
+var require_file = __commonJS({
+  "lib/file.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getClosure = getClosure;
+    exports2.processIfWorkletFile = processIfWorkletFile;
+    exports2.isImplicitContextObject = isImplicitContextObject;
     var types_12 = require("@babel/types");
-    var globals_12 = require_globals();
-    var imports_1 = require_imports();
-    function getClosure(funPath, state) {
-      const capturedNames = /* @__PURE__ */ new Set();
-      const closureVariables = new Array();
-      const moduleBindingsToImport = /* @__PURE__ */ new Set();
-      const relativeBindingsToImport = /* @__PURE__ */ new Set();
-      let recrawled = false;
-      funPath.traverse({
-        "TSType|TSTypeAliasDeclaration|TSInterfaceDeclaration"(typePath) {
-          typePath.skip();
-        },
-        ReferencedIdentifier(idPath) {
-          if (idPath.isJSXIdentifier() && !state.opts.bundleMode) {
-            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 (state.opts.strictGlobal || globals_12.globals.has(name)) {
-              return;
-            }
-            capturedNames.add(name);
-            closureVariables.push((0, types_12.cloneNode)(idPath.node, true));
-            return;
-          }
-          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 && (0, imports_1.isImport)(binding)) {
-            if ((0, imports_1.isImportRelative)(binding) && (0, imports_1.canForwardRelativeImport)(state.filename, state.opts.importForwarding.relativePaths)) {
-              capturedNames.add(name);
-              relativeBindingsToImport.add(binding);
-              return;
-            }
-            const source = binding.path.parentPath.node.source.value;
-            if ((0, imports_1.canForwardModuleImport)(source, state.opts.importForwarding.moduleNames)) {
-              capturedNames.add(name);
-              moduleBindingsToImport.add(binding);
-              return;
-            }
-          }
-          capturedNames.add(name);
-          closureVariables.push((0, types_12.cloneNode)(idPath.node, true));
+    var contextObject_12 = require_contextObject();
+    var directives_1 = require_directives();
+    var types_2 = require_types();
+    function processIfWorkletFile(path, state) {
+      if (!path.node.directives.some((functionDirective) => functionDirective.value.value === "worklet")) {
+        return false;
+      }
+      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");
+      dehoistCommonJSExports(programPath.node);
+      statements.forEach((statement) => {
+        const candidatePath = getCandidate(statement);
+        processWorkletizableEntity(candidatePath, state);
+      });
+    }
+    function getCandidate(statementPath) {
+      if (statementPath.isExportNamedDeclaration() || statementPath.isExportDefaultDeclaration()) {
+        return statementPath.get("declaration");
+      } else {
+        return statementPath;
+      }
+    }
+    function processWorkletizableEntity(nodePath, state) {
+      var _a;
+      if ((0, types_2.isWorkletizableFunctionPath)(nodePath)) {
+        if (nodePath.isArrowFunctionExpression()) {
+          (0, directives_1.replaceImplicitReturnWithBlock)(nodePath.node);
         }
-      }, state);
-      return {
-        closureVariables,
-        moduleBindingsToImport,
-        relativeBindingsToImport
-      };
+        (0, directives_1.addDirective)(nodePath.node.body, "worklet");
+      } else if ((0, types_2.isWorkletizableObjectPath)(nodePath)) {
+        if (isImplicitContextObject(nodePath)) {
+          appendWorkletContextObjectMarker(nodePath.node);
+        } else {
+          processWorkletAggregator(nodePath, state);
+        }
+      } else if (nodePath.isVariableDeclaration()) {
+        processVariableDeclaration(nodePath, state);
+      } else if (nodePath.isClassDeclaration()) {
+        appendWorkletClassMarker(nodePath.node.body);
+        if ((_a = nodePath.node.id) === null || _a === void 0 ? void 0 : _a.name) {
+          state.classesToWorkletize.push({
+            node: nodePath.node,
+            name: nodePath.node.id.name
+          });
+        }
+      }
+    }
+    function processVariableDeclaration(variableDeclarationPath, state) {
+      const declarations = variableDeclarationPath.get("declarations");
+      declarations.forEach((declaration) => {
+        const initPath = declaration.get("init");
+        if (initPath.isExpression()) {
+          processWorkletizableEntity(initPath, state);
+        }
+      });
+    }
+    function processWorkletAggregator(objectPath, state) {
+      const properties = objectPath.get("properties");
+      properties.forEach((property) => {
+        if (property.isObjectMethod()) {
+          (0, directives_1.addDirective)(property.node.body, "worklet");
+        } else if (property.isObjectProperty()) {
+          const valuePath = property.get("value");
+          processWorkletizableEntity(valuePath, state);
+        }
+      });
+    }
+    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)) {
+        return;
+      }
+      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");
+      return propertyPaths.some((propertyPath) => {
+        if (!propertyPath.isObjectMethod()) {
+          return false;
+        }
+        return hasThisExpression(propertyPath);
+      });
+    }
+    function hasThisExpression(path) {
+      let result = false;
+      path.traverse({
+        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)));
+    }
+    function dehoistCommonJSExports(program) {
+      const statements = program.body;
+      let end = statements.length;
+      let current = 0;
+      while (current < end) {
+        const statement = statements[current];
+        if (!isCommonJSExport(statement)) {
+          current++;
+          continue;
+        }
+        const exportStatement = statements.splice(current, 1);
+        statements.push(...exportStatement);
+        end--;
+      }
+    }
+    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";
     }
   }
 });
 
-// lib/generate.js
-var require_generate = __commonJS({
-  "lib/generate.js"(exports2) {
+// lib/globals.js
+var require_globals = __commonJS({
+  "lib/globals.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 imports_1 = require_imports();
-    var types_2 = require_types();
-    function generateWorkletFile(moduleBindingsToImport, relativeBindingsToImport, factory, workletHash, state) {
-      var _a;
-      const libraryImports = Array.from(moduleBindingsToImport).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) => (0, types_12.importDeclaration)([(0, types_12.cloneNode)(binding.path.node, true)], (0, imports_1.createImportPathLiteral)(binding.path.parentPath.node.source.value, state)));
-      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: [resolvePresetTypescript()],
-        plugins: [state.autoworkletizationPlugin, stripJsxDevAttributesPlugin],
-        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 dedicatedFilePath = (0, path_1.resolve)(filesDirPath, `${workletHash}.js`);
-      (0, fs_1.writeFileSync)(dedicatedFilePath, transformedProg);
-    }
-    function resolvePresetTypescript() {
-      try {
-        return require.resolve("@babel/preset-typescript");
-      } catch (_a) {
-        return require.resolve("@babel/preset-typescript", {
-          paths: [(0, path_1.dirname)(require.resolve("react-native-worklets/package.json"))]
-        });
-      }
-    }
-    var stripJsxDevAttributesPlugin = {
-      name: "worklets-strip-jsx-dev-attributes",
-      visitor: {
-        JSXAttribute(path) {
-          const name = path.node.name;
-          if (name.type !== "JSXIdentifier") {
-            return;
-          }
-          if (name.name !== "__self" && name.name !== "__source") {
-            return;
-          }
-          path.remove();
-        }
-      }
-    };
-  }
-});
-
-// lib/hermesBytecode.js
-var require_hermesBytecode = __commonJS({
-  "lib/hermesBytecode.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.compileWorkletToHbc = compileWorkletToHbc;
-    var core_1 = require("@babel/core");
-    var child_process_1 = require("child_process");
-    function compileWorkletToHbc(funString, workletHash, state) {
-      if (compilationCache.has(workletHash)) {
-        return compilationCache.get(workletHash);
-      }
-      const result = compile(funString, state);
-      compilationCache.set(workletHash, result);
-      return result;
-    }
-    function compile(funString, state) {
-      const hermesc = resolveHbcBinary(state);
-      if (!hermesc) {
-        return null;
-      }
-      try {
-        return runHermesc(hermesc, funString);
-      } catch (error) {
-        if (getErrorOutput(error).includes("JSX")) {
-          const transformed = transformJsx(funString);
-          if (transformed !== null) {
-            try {
-              return runHermesc(hermesc, transformed);
-            } catch (retryError) {
-              return warnFallback(retryError);
-            }
-          }
-        }
-        return warnFallback(error);
-      }
-    }
-    var MAX_BYTECODE_BYTES = 256 * 1024 * 1024;
-    var compilationCache = /* @__PURE__ */ new Map();
-    var warnedMessages = /* @__PURE__ */ new Set();
-    function warnOnce(message) {
-      if (warnedMessages.has(message)) {
-        return;
-      }
-      warnedMessages.add(message);
-      console.warn(`[Worklets] ${message}`);
-    }
-    function resolveHbcBinary(state) {
-      const { getHBCBinary } = state.opts;
-      if (!getHBCBinary) {
-        warnOnce("The `getHBCBinary` plugin option is required to compile worklets to Hermes bytecode. Falling back to shipping worklets as source strings.");
-        return null;
-      }
-      try {
-        const binary = getHBCBinary();
-        if (!binary) {
-          throw new Error("`getHBCBinary` returned an empty path.");
-        }
-        return binary;
-      } catch (error) {
-        warnOnce(`Calling \`getHBCBinary\` failed, falling back to a source string. ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-      }
-    }
-    function runHermesc(hermesc, source) {
-      return (0, child_process_1.execFileSync)(hermesc, ["-g0", "-emit-binary", "-O", "-w", "-"], {
-        input: source,
-        maxBuffer: MAX_BYTECODE_BYTES,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    }
-    function getErrorOutput(error) {
-      const stderr = error === null || error === void 0 ? void 0 : error.stderr;
-      if (stderr) {
-        return stderr.toString();
-      }
-      return error instanceof Error ? error.message : String(error);
-    }
-    function warnFallback(error) {
-      const reason = getErrorOutput(error).trim().split("\n")[0];
-      warnOnce(`Could not compile a worklet to Hermes bytecode, falling back to a source string. ${reason}`);
-      return null;
-    }
-    var jsxPluginPath;
-    function resolveJsxPlugin() {
-      if (jsxPluginPath === void 0) {
-        try {
-          jsxPluginPath = require.resolve("@babel/plugin-transform-react-jsx");
-        } catch (_a) {
-          jsxPluginPath = null;
-        }
-      }
-      return jsxPluginPath;
-    }
-    function transformJsx(source) {
-      var _a;
-      const plugin = resolveJsxPlugin();
-      if (!plugin) {
-        return null;
-      }
-      try {
-        const result = (0, core_1.transformSync)(source, {
-          babelrc: false,
-          configFile: false,
-          compact: true,
-          plugins: [plugin]
-        });
-        return (_a = result === null || result === void 0 ? void 0 : result.code) !== null && _a !== void 0 ? _a : null;
-      } catch (_b) {
-        return null;
-      }
-    }
-  }
-});
-
-// 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 });
-    exports2.workletTransformSync = workletTransformSync;
-    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")
-    ];
-    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;
-        };
-        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;
-      };
-    })();
-    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    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 transform_1 = require_transform();
-    var types_2 = require_types();
-    var utils_1 = require_utils();
-    var MOCK_SOURCE_MAP = "mock source map";
-    var querySuffixRE = /[?#].*$/;
-    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, "`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), "`expression.body` is not a `BlockStatement`");
-      const parsedClasses = /* @__PURE__ */ new Set();
-      if (!state.opts.disableWorkletClasses) {
-        (0, core_1.traverse)(fun, {
-          NewExpression(path) {
-            if (!(0, types_12.isIdentifier)(path.node.callee)) {
-              return;
-            }
-            const constructorName = path.node.callee.name;
-            if (!closureVariables.some((variable) => variable.name === constructorName) || parsedClasses.has(constructorName)) {
-              return;
-            }
-            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));
-            (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), []))
-            ]));
-            parsedClasses.add(constructorName);
-          }
-        });
-      }
-      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, "`inputMap` is undefined.");
-      const includeSourceMap = !((0, utils_1.isRelease)(state) || state.opts.disableSourceMaps);
-      if (includeSourceMap) {
-        inputMap.sourcesContent = [];
-        for (const sourceFile of inputMap.sources) {
-          inputMap.sourcesContent.push(fs.readFileSync(sourceFile.replace(querySuffixRE, "")).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 : []
-        ],
-        extraPresets: state.opts.extraPresets,
-        compact: true,
-        sourceMaps: includeSourceMap,
-        inputSourceMap: inputMap,
-        ast: false,
-        babelrc: false,
-        configFile: false,
-        comments: false
-      });
-      (0, assert_1.strict)(transformed, "`transformed` is null.");
-      let sourceMap;
-      if (includeSourceMap) {
-        if (shouldMockSourceMap()) {
-          sourceMap = MOCK_SOURCE_MAP;
-        } else {
-          sourceMap = convertSourceMap.fromObject(transformed.map).toObject();
-          delete sourceMap.sourcesContent;
-        }
-      }
-      const wrappedCode = `(${transformed.code})`;
-      return [wrappedCode, JSON.stringify(sourceMap)];
-    }
-    function restoreRecursiveCalls(file, newName) {
-      (0, core_1.traverse)(file, {
-        FunctionExpression(path) {
-          if (!path.node.id) {
-            path.stop();
-            return;
-          }
-          const oldName = path.node.id.name;
-          const scope = path.scope;
-          scope.rename(oldName, newName);
-        }
-      });
-    }
-    function shouldMockSourceMap() {
-      return process.env.WORKLETS_JEST_SHOULD_MOCK_SOURCE_MAP === "1";
-    }
-    function prependClosure(path, closureVariables, closureDeclaration) {
-      if (closureVariables.length === 0 || !(0, types_12.isProgram)(path.parent)) {
-        return;
-      }
-      if (!(0, types_12.isExpression)(path.node.body)) {
-        path.node.body.body.unshift(closureDeclaration);
-      }
-    }
-    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 (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")))
-          ]));
-        }
-      }
-    }
-    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")))
-      ]);
-      return {
-        visitor: {
-          "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 });
-    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 closure_1 = require_closure();
-    var generate_1 = require_generate();
-    var hermesBytecode_1 = require_hermesBytecode();
-    var imports_1 = require_imports();
-    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";
-    function makeWorkletFactory(fun, state) {
-      var _a;
-      const includeClosure = state.opts.bundleMode || !hasDirective(fun, "no-worklet-closure");
-      const limitInitDataHoisting = hasDirective(fun, "limit-init-data-hoisting");
-      stripWorkletDirectives(fun);
-      (0, assert_1.strict)(state.file.opts.filename, "`state.file.opts.filename` is undefined.");
-      const codeObject = (0, generator_1.default)(fun.node, {
-        sourceMaps: true,
-        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, "`transformed` is undefined.");
-      (0, assert_1.strict)(transformed.ast, "`transformed.ast` is undefined.");
-      const { closureVariables, moduleBindingsToImport, relativeBindingsToImport } = includeClosure ? (0, closure_1.getClosure)(fun, state) : {
-        closureVariables: [],
-        moduleBindingsToImport: /* @__PURE__ */ new Set(),
-        relativeBindingsToImport: /* @__PURE__ */ new Set()
-      };
-      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 { workletName, reactName } = makeWorkletName(fun, state);
-      let mutatedClosureVariables;
-      if (state.opts.bundleMode) {
-        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, "`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, "`pathForStringDefinitions` is null.");
-      (0, assert_1.strict)(pathForStringDefinitions.parentPath, "`pathForStringDefinitions.parentPath` is null.");
-      const initDataId = pathForStringDefinitions.parentPath.scope.generateUidIdentifier(`worklet_${workletHash}_init_data`);
-      const shouldIncludeInitData = !state.opts.omitNativeOnlyData && !state.opts.bundleMode;
-      const shouldEmitBytecode = !!state.opts.hermesBytecode && (0, utils_1.isRelease)(state) && shouldIncludeInitData;
-      const bytecode = shouldEmitBytecode ? (0, hermesBytecode_1.compileWorkletToHbc)(funString, workletHash, state) : null;
-      const initDataObjectExpression = (0, types_12.objectExpression)(bytecode ? [
-        (0, types_12.objectProperty)((0, types_12.identifier)("bytecode"), (0, types_12.memberExpression)((0, types_12.newExpression)((0, types_12.identifier)("Uint8Array"), [
-          (0, types_12.arrayExpression)(Array.from(bytecode, (byte) => (0, types_12.numericLiteral)(byte)))
-        ]), (0, types_12.identifier)("buffer")))
-      ] : [(0, types_12.objectProperty)((0, types_12.identifier)("code"), (0, types_12.stringLiteral)(funString))]);
-      const shouldInjectLocation = !(0, utils_1.isRelease)(state);
-      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(toPosix(state.file.opts.filename), toPosix(location));
-        }
-        location = toPosix(location);
-        initDataObjectExpression.properties.push((0, types_12.objectProperty)((0, types_12.identifier)("location"), (0, types_12.stringLiteral)(location)));
-      }
-      if (!bytecode && sourceMapString) {
-        initDataObjectExpression.properties.push((0, types_12.objectProperty)((0, types_12.identifier)("sourceMap"), (0, types_12.stringLiteral)(sourceMapString)));
-      }
-      if (shouldIncludeInitData) {
-        const initDataDeclaration = (0, types_12.variableDeclaration)("const", [
-          (0, types_12.variableDeclarator)(initDataId, initDataObjectExpression)
-        ]);
-        if (limitInitDataHoisting) {
-          fun.getFunctionParent().node.body.body.unshift(initDataDeclaration);
-        } else {
-          pathForStringDefinitions.insertBefore(initDataDeclaration);
-        }
-      }
-      (0, assert_1.strict)(!(0, types_12.isFunctionDeclaration)(funExpression), "`funExpression` is a `FunctionDeclaration`.");
-      (0, assert_1.strict)(!(0, types_12.isObjectMethod)(funExpression), "`funExpression` is an `ObjectMethod`.");
-      const statements = [
-        (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)))
-      ];
-      const shouldInjectVersion = !(0, utils_1.isRelease)(state);
-      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))));
-      }
-      if (shouldIncludeInitData) {
-        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)(state) && !state.opts.bundleMode) {
-        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)
-            // the placement of opening bracket after Exception in line that defined '_e' variable
-          ]))
-        ]));
-        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);
-        }
-        return clonedId;
-      });
-      if (shouldIncludeInitData) {
-        factoryParams.unshift((0, types_12.cloneNode)(initDataId, true));
+    exports2.globals = exports2.defaultGlobals = void 0;
+    exports2.initializeState = initializeState;
+    exports2.isGeneratedWorkletFile = isGeneratedWorkletFile;
+    exports2.initializeGlobals = initializeGlobals;
+    exports2.addCustomGlobals = addCustomGlobals;
+    var path_1 = __importDefault(require("path"));
+    var types_12 = require_types();
+    var notCapturedIdentifiers = [
+      // Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+      // Note that objects' properties don't need to be listed since we always only capture the whole object,
+      // e.g. `global.__ErrorUtils` or `Intl.DateTimeFormat`.
+      // Value properties
+      "globalThis",
+      "Infinity",
+      "NaN",
+      "undefined",
+      // Function properties
+      "eval",
+      "isFinite",
+      "isNaN",
+      "parseFloat",
+      "parseInt",
+      "decodeURI",
+      "decodeURIComponent",
+      "encodeURI",
+      "encodeURIComponent",
+      "escape",
+      "unescape",
+      // Fundamental objects
+      "Object",
+      "Function",
+      "Boolean",
+      "Symbol",
+      // Error objects
+      "Error",
+      "AggregateError",
+      "EvalError",
+      "RangeError",
+      "ReferenceError",
+      "SyntaxError",
+      "TypeError",
+      "URIError",
+      "InternalError",
+      // Numbers and dates
+      "Number",
+      "BigInt",
+      "Math",
+      "Date",
+      // Text processing
+      "String",
+      "RegExp",
+      // Indexed collections
+      "Array",
+      "Int8Array",
+      "Uint8Array",
+      "Uint8ClampedArray",
+      "Int16Array",
+      "Uint16Array",
+      "Int32Array",
+      "Uint32Array",
+      "BigInt64Array",
+      "BigUint64Array",
+      "Float32Array",
+      "Float64Array",
+      // Keyed collections
+      "Map",
+      "Set",
+      "WeakMap",
+      "WeakSet",
+      // Structured data
+      "ArrayBuffer",
+      "SharedArrayBuffer",
+      "DataView",
+      "Atomics",
+      "JSON",
+      // Managing memory
+      "WeakRef",
+      "FinalizationRegistry",
+      // Control abstraction objects
+      "Iterator",
+      "AsyncIterator",
+      "Promise",
+      "GeneratorFunction",
+      "AsyncGeneratorFunction",
+      "Generator",
+      "AsyncGenerator",
+      "AsyncFunction",
+      // Reflection
+      "Reflect",
+      "Proxy",
+      // Internationalization
+      "Intl",
+      // Other stuff
+      "null",
+      "this",
+      "global",
+      "window",
+      "globalThis",
+      "self",
+      "console",
+      "performance",
+      "arguments",
+      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments
+      "require",
+      "fetch",
+      "XMLHttpRequest",
+      "WebSocket",
+      // Run loop
+      "queueMicrotask",
+      "requestAnimationFrame",
+      "cancelAnimationFrame",
+      "setTimeout",
+      "clearTimeout",
+      "setImmediate",
+      "clearImmediate",
+      "setInterval",
+      "clearInterval",
+      // Hermes
+      "HermesInternal",
+      // Worklets
+      "_WORKLET"
+    ];
+    function initializeState(state) {
+      var _a, _b;
+      state.skipFile = isGeneratedWorkletFile(state.file.opts.filename);
+      if (state.skipFile) {
+        return;
       }
-      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, imports_1.updateRelativeRequires)(factory, state);
-        (0, generate_1.generateWorkletFile)(moduleBindingsToImport, relativeBindingsToImport, factory, workletHash, state);
+      state.workletNumber = 1;
+      state.classesToWorkletize = [];
+      if (!state.opts.strictGlobal) {
+        initializeGlobals();
+        addCustomGlobals(state);
       }
-      factory.workletized = true;
-      return { factory, factoryCallParamPack, workletHash };
+      const userImportForwarding = state.opts.importForwarding;
+      state.opts.importForwarding = {
+        relativePaths: [
+          ...defaultAllowedPaths,
+          ...(_a = userImportForwarding === null || userImportForwarding === void 0 ? void 0 : userImportForwarding.relativePaths) !== null && _a !== void 0 ? _a : []
+        ],
+        moduleNames: [
+          ...defaultAllowedModules,
+          ...(_b = userImportForwarding === null || userImportForwarding === void 0 ? void 0 : userImportForwarding.moduleNames) !== null && _b !== void 0 ? _b : []
+        ]
+      };
     }
-    function hasDirective(path, directiveText) {
-      if (!path.node.body) {
+    function isGeneratedWorkletFile(filename) {
+      if (!filename) {
         return false;
       }
-      const bodyPath = path.get("body");
-      let has = false;
-      if (bodyPath.isBlockStatement()) {
-        has = bodyPath.get("directives").some((directivePath) => {
-          if (directivePath.isDirective() && directivePath.node.value.value === directiveText) {
-            return true;
-          }
-        });
-      }
-      return has;
-    }
-    function stripWorkletDirectives(fun) {
-      fun.traverse({
-        DirectiveLiteral(nodePath) {
-          if ((nodePath.node.value === "worklet" || nodePath.node.value === "no-worklet-closure" || nodePath.node.value === "limit-init-data-hoisting") && nodePath.getFunctionParent() === fun) {
-            nodePath.parentPath.remove();
-          }
-        }
-      });
-    }
-    function shouldMockVersion() {
-      return process.env.WORKLETS_JEST_SHOULD_MOCK_VERSION === "1";
-    }
-    function hash(str) {
-      let i = str.length;
-      let hash1 = 5381;
-      let hash2 = 52711;
-      while (i--) {
-        const char = str.charCodeAt(i);
-        hash1 = hash1 * 33 ^ char;
-        hash2 = hash2 * 33 ^ char;
-      }
-      return (hash1 >>> 0) * 4096 + (hash2 >>> 0);
-    }
-    function makeWorkletName(fun, state) {
-      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");
-        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)) {
-        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)) {
-        reactName = fun.node.id.name;
-      }
-      const workletName = reactName ? (0, types_12.toIdentifier)(`${reactName}_${suffix}`) : (0, types_12.toIdentifier)(suffix);
-      reactName = reactName || (0, types_12.toIdentifier)(suffix);
-      return { workletName, reactName };
+      const generatedWorkletsDirPath = path_1.default.join("react-native-worklets", types_12.generatedWorkletsDir);
+      return filename.includes(generatedWorkletsDirPath);
     }
-    function toPosix(p) {
-      return path_1.sep === "/" ? p : p.split(path_1.sep).join("/");
+    exports2.defaultGlobals = new Set(notCapturedIdentifiers);
+    function initializeGlobals() {
+      exports2.globals = new Set(exports2.defaultGlobals);
     }
-    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-template-literals"),
-        { loose: true }
-      ]
+    var defaultAllowedPaths = ["react-native-worklets"];
+    var defaultAllowedModules = [
+      "react-native-worklets",
+      "react-native/Libraries/Core/setUpXHR"
     ];
-  }
-});
-
-// lib/workletFactoryCall.js
-var require_workletFactoryCall = __commonJS({
-  "lib/workletFactoryCall.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.makeWorkletFactoryCall = makeWorkletFactoryCall;
-    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);
-      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]);
-      } else {
-        factoryCall = (0, types_12.callExpression)(factory, [factoryCallParamPack]);
-      }
-      addStackTraceDataToWorkletFactory(path, factoryCall);
-      const replacement = factoryCall;
-      return replacement;
-    }
-    function addStackTraceDataToWorkletFactory(path, workletFactoryCall) {
-      const originalWorkletLocation = path.node.loc;
-      if (originalWorkletLocation) {
-        workletFactoryCall.callee.loc = {
-          filename: originalWorkletLocation.filename,
-          identifierName: originalWorkletLocation.identifierName,
-          start: originalWorkletLocation.start,
-          end: originalWorkletLocation.start
-        };
+    function addCustomGlobals(state) {
+      if (state.opts && Array.isArray(state.opts.globals)) {
+        state.opts.globals.forEach((name) => {
+          exports2.globals.add(name);
+        });
       }
     }
   }
 });
 
-// lib/workletSubstitution.js
-var require_workletSubstitution = __commonJS({
-  "lib/workletSubstitution.js"(exports2) {
+// lib/inlineStylesWarning.js
+var require_inlineStylesWarning = __commonJS({
+  "lib/inlineStylesWarning.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.processIfWithWorkletDirective = processIfWithWorkletDirective;
-    exports2.processWorklet = processWorklet;
-    exports2.substituteObjectMethodWithObjectProperty = substituteObjectMethodWithObjectProperty;
+    exports2.processInlineStylesWarning = processInlineStylesWarning;
     var types_12 = require("@babel/types");
-    var types_2 = require_types();
+    var assert_1 = require("assert");
     var utils_1 = require_utils();
-    var workletFactoryCall_1 = require_workletFactoryCall();
-    function processIfWithWorkletDirective(path, state) {
-      if (!(0, types_12.isBlockStatement)(path.node.body)) {
-        return false;
-      }
-      if (!hasWorkletDirective(path.node.body.directives)) {
-        return false;
+    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)
+      ])), []);
+    }
+    function processPropertyValueForInlineStylesWarning(path) {
+      if (path.isMemberExpression() && (0, types_12.isIdentifier)(path.node.property)) {
+        if (!path.node.computed && path.node.property.name === "value") {
+          path.replaceWith(generateInlineStylesWarning(path));
+        }
       }
-      processWorklet(path, state);
-      return true;
     }
-    function processWorklet(path, state) {
-      path.traverse({
-        // @ts-expect-error TypeScript doesn't like this syntax here.
-        [types_2.WorkletizableFunction](subPath, passedState) {
-          processIfWithWorkletDirective(subPath, passedState);
+    function processTransformPropertyForInlineStylesWarning(path) {
+      if ((0, types_12.isArrayExpression)(path.node)) {
+        const elements = path.get("elements");
+        (0, assert_1.strict)(Array.isArray(elements), "`elements` should be an array.");
+        for (const element of elements) {
+          if (element.isObjectExpression()) {
+            processStyleObjectForInlineStylesWarning(element);
+          }
         }
-      }, 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");
+      }
     }
-    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;
-        (0, utils_1.replaceWithFactoryCall)(path, name, workletFactoryCall);
+    function processStyleObjectForInlineStylesWarning(path) {
+      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") {
+            processTransformPropertyForInlineStylesWarning(value);
+          } else {
+            processPropertyValueForInlineStylesWarning(value);
+          }
+        }
       }
     }
-    function substituteObjectMethodWithObjectProperty(path, workletFactoryCall) {
-      const replacement = (0, types_12.objectProperty)(path.node.key, workletFactoryCall);
-      path.replaceWith(replacement);
+    function processInlineStylesWarning(path, state) {
+      if ((0, utils_1.isRelease)(state)) {
+        return;
+      }
+      if (state.opts.disableInlineStylesWarning) {
+        return;
+      }
+      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), "`expression` should not be an array.");
+      if (expression.isArrayExpression()) {
+        const elements = expression.get("elements");
+        (0, assert_1.strict)(Array.isArray(elements), "`elements` should be an array.");
+        for (const element of elements) {
+          if (element.isObjectExpression()) {
+            processStyleObjectForInlineStylesWarning(element);
+          }
+        }
+      } else if (expression.isObjectExpression()) {
+        processStyleObjectForInlineStylesWarning(expression);
+      }
     }
   }
 });
 
-// lib/objectWorklets.js
-var require_objectWorklets = __commonJS({
-  "lib/objectWorklets.js"(exports2) {
+// lib/webOptimization.js
+var require_webOptimization = __commonJS({
+  "lib/webOptimization.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) {
-      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)) {
-        return;
-      }
-      if ((0, types_12.isWorkletizableFunctionPath)(maybeWorklet)) {
-        (0, workletSubstitution_12.processWorklet)(maybeWorklet, state);
-      } else if ((0, types_12.isWorkletizableObjectPath)(maybeWorklet)) {
-        processWorkletizableObject(maybeWorklet, state);
-      }
-    }
-    function processWorkletizableObject(path, state) {
-      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");
-          tryProcessingNode(
-            value,
-            state,
-            true,
-            // acceptWorkletizableFunction
-            false
-            // acceptObject
-          );
-        } else {
-          throw new Error(`'${property.type}' as to-be workletized argument is not supported for object hooks.`);
+    exports2.substituteWebCallExpression = substituteWebCallExpression;
+    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") {
+          path.replaceWith((0, types_12.booleanLiteral)(true));
         }
       }
     }
   }
 });
 
-// lib/autoworkletization.js
-var require_autoworkletization = __commonJS({
-  "lib/autoworkletization.js"(exports2) {
+// lib/imports.js
+var require_imports = __commonJS({
+  "lib/imports.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.processIfAutoworkletizableCallback = processIfAutoworkletizableCallback;
-    exports2.processCalleesAutoworkletizableCallbacks = processCalleesAutoworkletizableCallbacks;
+    exports2.updateRelativeRequires = updateRelativeRequires;
+    exports2.isImport = isImport;
+    exports2.isImportRelative = isImportRelative;
+    exports2.canForwardModuleImport = canForwardModuleImport;
+    exports2.canForwardRelativeImport = canForwardRelativeImport;
+    exports2.createImportPathLiteral = createImportPathLiteral;
+    var core_1 = require("@babel/core");
     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)
-    ]);
-    var reanimatedFunctionHooks = /* @__PURE__ */ new Set([
-      "useFrameCallback",
-      "useAnimatedStyle",
-      "useAnimatedProps",
-      "createAnimatedPropAdapter",
-      "useDerivedValue",
-      "useAnimatedScrollHandler",
-      "useAnimatedReaction",
-      // animations' callbacks
-      "withTiming",
-      "withSpring",
-      "withDecay",
-      "withRepeat",
-      // scheduling functions
-      "runOnUI",
-      "executeOnUIRuntimeSync",
-      "scheduleOnUI",
-      "runOnUISync",
-      "runOnUIAsync",
-      "runOnRuntime",
-      "runOnRuntimeSync",
-      "runOnRuntimeAsync",
-      "scheduleOnRuntime",
-      "runOnRuntimeSyncWithId",
-      "scheduleOnRuntimeWithId"
-    ]);
-    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]],
-      ["runOnRuntimeSync", [1]],
-      ["runOnRuntimeAsync", [1]],
-      ["scheduleOnRuntime", [1]],
-      ["runOnRuntimeSyncWithId", [1]],
-      ["scheduleOnRuntimeWithId", [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)) {
-        (0, workletSubstitution_12.processWorklet)(path, state);
-        return true;
-      }
-      return false;
+    var path_1 = require("path");
+    var types_2 = require_types();
+    function updateRelativeRequires(node, state) {
+      (0, core_1.traverse)(node, {
+        noScope: true,
+        CallExpression(nodePath) {
+          var _a;
+          if (nodePath.get("callee").isIdentifier({ name: "require" }) && ((_a = nodePath.get("arguments")[0]) === null || _a === void 0 ? void 0 : _a.isStringLiteral())) {
+            const requiredModule = nodePath.get("arguments")[0];
+            if (requiredModule.node.value.startsWith(".") && canForwardRelativeImport(state.file.opts.filename || "", state.opts.importForwarding.relativePaths)) {
+              requiredModule.replaceWith(createImportPathLiteral(requiredModule.node.value, state));
+            }
+          }
+        }
+      });
     }
-    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;
-      if (name === void 0) {
-        return;
+    function isImport(binding) {
+      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(".");
+    }
+    function canForwardModuleImport(moduleName, forwardableModuleNames) {
+      return forwardableModuleNames.some((forwardableModuleName) => moduleName === forwardableModuleName || moduleName.startsWith(forwardableModuleName + "/"));
+    }
+    function canForwardRelativeImport(modulePath, relativePaths) {
+      return !!modulePath && relativePaths.some((relativePath) => matchesFilenameSegment(modulePath, relativePath));
+    }
+    function matchesFilenameSegment(filename, allowedPath) {
+      const pkgSegments = allowedPath.split(path_1.posix.sep);
+      let fileSegments = filename.split(path_1.sep);
+      const lastNodeModules = fileSegments.lastIndexOf("node_modules");
+      if (lastNodeModules !== -1) {
+        fileSegments = fileSegments.slice(lastNodeModules + 1);
       }
-      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));
-        processArgs(args, state, acceptWorkletizableFunction, acceptObject);
-      } else if (!(0, types_12.isV8IntrinsicIdentifier)(callee) && (0, gestureHandlerAutoworkletization_1.isGestureObjectEventCallbackMethod)(callee)) {
-        const args = path.get("arguments");
-        processArgs(args, state, true, true);
+      for (let i = 0; i <= fileSegments.length - pkgSegments.length; i++) {
+        if (pkgSegments.every((segment, segmentIndex) => fileSegments[i + segmentIndex] === segment)) {
+          return true;
+        }
       }
+      return false;
     }
-    function processArgs(args, state, acceptWorkletizableFunction, acceptObject) {
-      args.forEach((arg) => {
-        (0, objectWorklets_1.tryProcessingNode)(arg, state, acceptWorkletizableFunction, acceptObject);
-      });
+    function createImportPathLiteral(originalPath, state) {
+      const generatedWorkletsDirPath = (0, path_1.resolve)((0, path_1.dirname)(require.resolve("react-native-worklets/package.json")), types_2.generatedWorkletsDir);
+      const resolved = (0, path_1.resolve)((0, path_1.dirname)(state.file.opts.filename), originalPath);
+      const relativePath = (0, path_1.relative)(generatedWorkletsDirPath, resolved);
+      return (0, types_12.stringLiteral)(path_1.sep === "/" ? relativePath : relativePath.split(path_1.sep).join("/"));
     }
   }
 });
 
-// lib/bundleMode.js
-var require_bundleMode = __commonJS({
-  "lib/bundleMode.js"(exports2) {
+// lib/closure.js
+var require_closure = __commonJS({
+  "lib/closure.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.toggleBundleMode = toggleBundleMode;
+    exports2.getClosure = getClosure;
     var types_12 = require("@babel/types");
-    var path_1 = require("path");
-    var WORKLETS_PACKAGE = "react-native-worklets";
-    var WORKLETS_SRC_DIR = (0, path_1.join)(WORKLETS_PACKAGE, "src");
-    var WORKLETS_LIB_DIR = (0, path_1.join)(WORKLETS_PACKAGE, "lib", "module");
-    var togglePaths = [
-      (0, path_1.join)(WORKLETS_SRC_DIR, "index.ts"),
-      (0, path_1.join)(WORKLETS_SRC_DIR, "debug", "bundleMode.native.ts"),
-      (0, path_1.join)(WORKLETS_LIB_DIR, "index.js"),
-      (0, path_1.join)(WORKLETS_LIB_DIR, "debug", "bundleMode.native.js")
-    ];
-    function toggleBundleMode(path, state) {
-      if (!state.opts.bundleMode || !togglePaths.some((togglePath) => {
-        var _a;
-        return (_a = state.filename) === null || _a === void 0 ? void 0 : _a.endsWith(togglePath);
-      })) {
-        return;
-      }
-      const expressionPath = path.get("expression");
-      if (!expressionPath.isAssignmentExpression()) {
-        return;
-      }
-      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_ENABLED") {
-        return;
-      }
-      const right = expressionPath.get("right");
-      right.replaceWith((0, types_12.booleanLiteral)(true));
+    var globals_12 = require_globals();
+    var imports_1 = require_imports();
+    function getClosure(funPath, state) {
+      const capturedNames = /* @__PURE__ */ new Set();
+      const closureVariables = new Array();
+      const moduleBindingsToImport = /* @__PURE__ */ new Set();
+      const relativeBindingsToImport = /* @__PURE__ */ new Set();
+      let recrawled = false;
+      funPath.traverse({
+        "TSType|TSTypeAliasDeclaration|TSInterfaceDeclaration"(typePath) {
+          typePath.skip();
+        },
+        ReferencedIdentifier(idPath) {
+          if (idPath.isJSXIdentifier() && !state.opts.bundleMode) {
+            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 (state.opts.strictGlobal || globals_12.globals.has(name)) {
+              return;
+            }
+            capturedNames.add(name);
+            closureVariables.push((0, types_12.cloneNode)(idPath.node, true));
+            return;
+          }
+          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 && (0, imports_1.isImport)(binding)) {
+            if ((0, imports_1.isImportRelative)(binding) && (0, imports_1.canForwardRelativeImport)(state.filename, state.opts.importForwarding.relativePaths)) {
+              capturedNames.add(name);
+              relativeBindingsToImport.add(binding);
+              return;
+            }
+            const source = binding.path.parentPath.node.source.value;
+            if ((0, imports_1.canForwardModuleImport)(source, state.opts.importForwarding.moduleNames)) {
+              capturedNames.add(name);
+              moduleBindingsToImport.add(binding);
+              return;
+            }
+          }
+          capturedNames.add(name);
+          closureVariables.push((0, types_12.cloneNode)(idPath.node, true));
+        }
+      }, state);
+      return {
+        closureVariables,
+        moduleBindingsToImport,
+        relativeBindingsToImport
+      };
     }
   }
 });
 
-// lib/class.js
-var require_class = __commonJS({
-  "lib/class.js"(exports2) {
+// 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 });
-    exports2.processIfWorkletClass = processIfWorkletClass;
-    var generator_1 = __importDefault(require("@babel/generator"));
-    var traverse_1 = __importDefault(require("@babel/traverse"));
+    exports2.generateWorkletFile = generateWorkletFile;
+    var core_1 = require("@babel/core");
     var types_12 = require("@babel/types");
-    var assert_1 = require("assert");
-    var transform_1 = require_transform();
+    var assert_1 = __importDefault(require("assert"));
+    var fs_1 = require("fs");
+    var path_1 = require("path");
+    var imports_1 = require_imports();
     var types_2 = require_types();
-    var utils_1 = require_utils();
-    var classWorkletMarker = "__workletClass";
-    function processIfWorkletClass(classPath, state) {
-      if (!isWorkletizableClass(classPath, state) || state.opts.bundleMode) {
-        return false;
-      }
-      removeWorkletClassMarker(classPath.node.body);
-      processClass(classPath, state);
-      return true;
-    }
-    function processClass(classPath, state) {
-      (0, assert_1.strict)(classPath.node.id);
-      const className = classPath.node.id.name;
-      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]));
-      const factoryCall = (0, types_12.callExpression)(factoryFactory, []);
-      (0, utils_1.replaceWithFactoryCall)(classPath, className, factoryCall);
-    }
-    function getPolyfilledAst(classNode, state) {
+    function generateWorkletFile(moduleBindingsToImport, relativeBindingsToImport, factory, workletHash, 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,
+      const libraryImports = Array.from(moduleBindingsToImport).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) => (0, types_12.importDeclaration)([(0, types_12.cloneNode)(binding.path.node, true)], (0, imports_1.createImportPathLiteral)(binding.path.parentPath.node.source.value, state)));
+      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,
-        ast: true,
+        presets: [resolvePresetTypescript()],
+        plugins: [stripJsxDevAttributesPlugin],
+        ast: false,
         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"));
-          statement.body.directives.push(workletDirective);
-        }
-      });
-    }
-    function replaceClassDeclarationWithFactoryAndCall(statements, className) {
-      const classFactoryName = className + types_2.workletClassFactorySuffix;
-      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), []))
-      ]);
-      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));
-      (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);
+        configFile: false,
+        comments: false
+      })) === null || _a === void 0 ? void 0 : _a.code;
+      (0, assert_1.default)(transformedProg, "[Worklets] `transformedProg` is undefined.");
+      const dedicatedFilePath = (0, path_1.resolve)(filesDirPath, `${workletHash}.js`);
+      (0, fs_1.writeFileSync)(dedicatedFilePath, transformedProg);
     }
-    function removeWorkletClassMarker(classBody) {
-      classBody.body = classBody.body.filter((statement) => !(0, types_12.isClassProperty)(statement) || !(0, types_12.isIdentifier)(statement.key) || statement.key.name !== classWorkletMarker);
+    function resolvePresetTypescript() {
+      try {
+        return require.resolve("@babel/preset-typescript");
+      } catch (_a) {
+        return require.resolve("@babel/preset-typescript", {
+          paths: [(0, path_1.dirname)(require.resolve("react-native-worklets/package.json"))]
+        });
+      }
     }
-    function sortPolyfills(ast) {
-      const toSort = getPolyfillsToSort(ast);
-      const sorted = topoSort(toSort);
-      const toSortIndices = toSort.map((element) => element.index);
-      const sortedIndices = sorted.map((element) => element.index);
-      const statements = ast.program.body;
-      const oldStatements = [...statements];
-      for (let i = 0; i < toSort.length; i++) {
-        const sourceIndex = sortedIndices[i];
-        const targetIndex = toSortIndices[i];
-        const source = oldStatements[sourceIndex];
-        statements[targetIndex] = source;
+    var stripJsxDevAttributesPlugin = {
+      name: "worklets-strip-jsx-dev-attributes",
+      visitor: {
+        JSXAttribute(path) {
+          const name = path.node.name;
+          if (name.type !== "JSXIdentifier") {
+            return;
+          }
+          if (name.name !== "__self" && name.name !== "__source") {
+            return;
+          }
+          path.remove();
+        }
+      }
+    };
+  }
+});
+
+// lib/hermesBytecode.js
+var require_hermesBytecode = __commonJS({
+  "lib/hermesBytecode.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.compileWorkletToHbc = compileWorkletToHbc;
+    var core_1 = require("@babel/core");
+    var child_process_1 = require("child_process");
+    function compileWorkletToHbc(funString, workletHash, state) {
+      if (compilationCache.has(workletHash)) {
+        return compilationCache.get(workletHash);
       }
+      const result = compile(funString, state);
+      compilationCache.set(workletHash, result);
+      return result;
     }
-    function getPolyfillsToSort(ast) {
-      const polyfills = [];
-      (0, traverse_1.default)(ast, {
-        Program: {
-          enter: (functionPath) => {
-            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)) {
-                return;
-              }
-              const element = {
-                name: statement.node.id.name,
-                index,
-                dependencies: /* @__PURE__ */ new Set()
-              };
-              polyfills.push(element);
-              statement.traverse({
-                Identifier(path) {
-                  if (isOutsideDependency(path, bindingIdentifiers, statement)) {
-                    element.dependencies.add(path.node.name);
-                  }
-                }
-              });
-            });
+    function compile(funString, state) {
+      const hermesc = resolveHbcBinary(state);
+      if (!hermesc) {
+        return null;
+      }
+      try {
+        return runHermesc(hermesc, funString);
+      } catch (error) {
+        if (getErrorOutput(error).includes("JSX")) {
+          const transformed = transformJsx(funString);
+          if (transformed !== null) {
+            try {
+              return runHermesc(hermesc, transformed);
+            } catch (retryError) {
+              return warnFallback(retryError);
+            }
           }
         }
-      });
-      return polyfills;
-    }
-    function topoSort(toSort) {
-      const sorted = [];
-      const stack = /* @__PURE__ */ new Set();
-      for (const element of toSort) {
-        recursiveTopoSort(element, toSort, sorted, stack);
+        return warnFallback(error);
       }
-      return sorted;
     }
-    function recursiveTopoSort(current, toSort, sorted, stack) {
-      if (stack.has(current.name)) {
-        throw new Error("Cycle detected. This should never happen.");
-      }
-      if (sorted.find((element) => element.name === current.name)) {
+    var MAX_BYTECODE_BYTES = 256 * 1024 * 1024;
+    var compilationCache = /* @__PURE__ */ new Map();
+    var warnedMessages = /* @__PURE__ */ new Set();
+    function warnOnce(message) {
+      if (warnedMessages.has(message)) {
         return;
       }
-      stack.add(current.name);
-      for (const dependency of current.dependencies) {
-        if (!sorted.find((element) => element.name === dependency)) {
-          const next = toSort.find((element) => element.name === dependency);
-          (0, assert_1.strict)(next);
-          recursiveTopoSort(next, toSort, sorted, stack);
+      warnedMessages.add(message);
+      console.warn(`[Worklets] ${message}`);
+    }
+    function resolveHbcBinary(state) {
+      const { getHBCBinary } = state.opts;
+      if (!getHBCBinary) {
+        warnOnce("The `getHBCBinary` plugin option is required to compile worklets to Hermes bytecode. Falling back to shipping worklets as source strings.");
+        return null;
+      }
+      try {
+        const binary = getHBCBinary();
+        if (!binary) {
+          throw new Error("`getHBCBinary` returned an empty path.");
         }
+        return binary;
+      } catch (error) {
+        warnOnce(`Calling \`getHBCBinary\` failed, falling back to a source string. ${error instanceof Error ? error.message : String(error)}`);
+        return null;
       }
-      sorted.push(current);
-      stack.delete(current.name);
     }
-    function isOutsideDependency(identifierPath, bindingIdentifiers, functionPath) {
-      return (
-        // We don't care about identifiers that were just declared.
-        identifierPath.isReferencedIdentifier() && // We don't care about identifiers that are bound in the scope.
-        !(identifierPath.node.name in bindingIdentifiers) && // This I don't exactly understand, but the function identifier itself isn't in `bindingIdentifiers`,
-        // but it return true on `hasOwnBinding`.
-        !functionPath.scope.hasOwnBinding(identifierPath.node.name) && // `hasReference` returns true for global identifiers, like `Object`,
-        // we don't want to include those.
-        functionPath.scope.hasReference(identifierPath.node.name)
-      );
+    function runHermesc(hermesc, source) {
+      return (0, child_process_1.execFileSync)(hermesc, ["-g0", "-emit-binary", "-O", "-w", "-"], {
+        input: source,
+        maxBuffer: MAX_BYTECODE_BYTES,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
     }
-    function isWorkletizableClass(classPath, state) {
+    function getErrorOutput(error) {
+      const stderr = error === null || error === void 0 ? void 0 : error.stderr;
+      if (stderr) {
+        return stderr.toString();
+      }
+      return error instanceof Error ? error.message : String(error);
+    }
+    function warnFallback(error) {
+      const reason = getErrorOutput(error).trim().split("\n")[0];
+      warnOnce(`Could not compile a worklet to Hermes bytecode, falling back to a source string. ${reason}`);
+      return null;
+    }
+    var jsxPluginPath;
+    function resolveJsxPlugin() {
+      if (jsxPluginPath === void 0) {
+        try {
+          jsxPluginPath = require.resolve("@babel/plugin-transform-react-jsx");
+        } catch (_a) {
+          jsxPluginPath = null;
+        }
+      }
+      return jsxPluginPath;
+    }
+    function transformJsx(source) {
       var _a;
-      const className = (_a = classPath.node.id) === null || _a === void 0 ? void 0 : _a.name;
-      const classNode = classPath.node;
-      if (!className) {
-        return false;
+      const plugin = resolveJsxPlugin();
+      if (!plugin) {
+        return null;
+      }
+      try {
+        const result = (0, core_1.transformSync)(source, {
+          babelrc: false,
+          configFile: false,
+          compact: true,
+          plugins: [plugin]
+        });
+        return (_a = result === null || result === void 0 ? void 0 : result.code) !== null && _a !== void 0 ? _a : null;
+      } catch (_b) {
+        return null;
       }
-      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 result = isMarked || isMemoizedNode || isTopLevelMemoizedName;
-      return result;
     }
   }
 });
 
-// lib/contextObject.js
-var require_contextObject = __commonJS({
-  "lib/contextObject.js"(exports2) {
+// 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;
+        };
+        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;
+      };
+    })();
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.contextObjectMarker = void 0;
-    exports2.processIfWorkletContextObject = processIfWorkletContextObject;
-    exports2.isContextObject = isContextObject;
+    exports2.buildWorkletString = buildWorkletString;
+    var core_1 = require("@babel/core");
+    var generator_1 = __importDefault(require("@babel/generator"));
     var types_12 = require("@babel/types");
-    exports2.contextObjectMarker = "__workletContextObject";
-    function processIfWorkletContextObject(path, _state) {
-      if (!isContextObject(path.node)) {
-        return false;
+    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";
+    var querySuffixRE = /[?#].*$/;
+    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, "`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), "`expression.body` is not a `BlockStatement`");
+      const parsedClasses = /* @__PURE__ */ new Set();
+      if (!state.opts.disableWorkletClasses) {
+        (0, core_1.traverse)(fun, {
+          NewExpression(path) {
+            if (!(0, types_12.isIdentifier)(path.node.callee)) {
+              return;
+            }
+            const constructorName = path.node.callee.name;
+            if (!closureVariables.some((variable) => variable.name === constructorName) || parsedClasses.has(constructorName)) {
+              return;
+            }
+            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));
+            (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), []))
+            ]));
+            parsedClasses.add(constructorName);
+          }
+        });
       }
-      removeContextObjectMarker(path.node);
-      processWorkletContextObject(path.node);
-      return true;
+      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, "`inputMap` is undefined.");
+      const includeSourceMap = !((0, utils_1.isRelease)(state) || state.opts.disableSourceMaps);
+      if (includeSourceMap) {
+        inputMap.sourcesContent = [];
+        for (const sourceFile of inputMap.sources) {
+          inputMap.sourcesContent.push(fs.readFileSync(sourceFile.replace(querySuffixRE, "")).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 : []
+        ],
+        extraPresets: state.opts.extraPresets,
+        compact: true,
+        sourceMaps: includeSourceMap,
+        inputSourceMap: inputMap,
+        ast: false,
+        babelrc: false,
+        configFile: false,
+        comments: false
+      });
+      (0, assert_1.strict)(transformed, "`transformed` is null.");
+      let sourceMap;
+      if (includeSourceMap) {
+        if (shouldMockSourceMap()) {
+          sourceMap = MOCK_SOURCE_MAP;
+        } else {
+          sourceMap = convertSourceMap.fromObject(transformed.map).toObject();
+          delete sourceMap.sourcesContent;
+        }
+      }
+      const wrappedCode = `(${transformed.code})`;
+      return [wrappedCode, JSON.stringify(sourceMap)];
+    }
+    function restoreRecursiveCalls(file, newName) {
+      (0, core_1.traverse)(file, {
+        FunctionExpression(path) {
+          if (!path.node.id) {
+            path.stop();
+            return;
+          }
+          const oldName = path.node.id.name;
+          const scope = path.scope;
+          scope.rename(oldName, newName);
+        }
+      });
     }
-    function isContextObject(objectExpression) {
-      return objectExpression.properties.some((property) => (0, types_12.isObjectProperty)(property) && (0, types_12.isIdentifier)(property.key) && property.key.name === exports2.contextObjectMarker);
+    function shouldMockSourceMap() {
+      return process.env.WORKLETS_JEST_SHOULD_MOCK_SOURCE_MAP === "1";
     }
-    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));
+    function prependClosure(path, closureVariables, closureDeclaration) {
+      if (closureVariables.length === 0 || !(0, types_12.isProgram)(path.parent)) {
+        return;
+      }
+      if (!(0, types_12.isExpression)(path.node.body)) {
+        path.node.body.body.unshift(closureDeclaration);
+      }
     }
-    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));
+    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 (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")))
+          ]));
+        }
+      }
+    }
+    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")))
+      ]);
+      return {
+        visitor: {
+          "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ObjectMethod": (path) => {
+            prependClosure(path, closureVariables, closureDeclaration);
+            prependRecursiveDeclaration(path);
+          }
+        }
+      };
     }
   }
 });
 
-// lib/file.js
-var require_file = __commonJS({
-  "lib/file.js"(exports2) {
+// 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 });
-    exports2.processIfWorkletFile = processIfWorkletFile;
-    exports2.isImplicitContextObject = isImplicitContextObject;
+    exports2.makeWorkletFactory = makeWorkletFactory;
+    var generator_1 = __importDefault(require("@babel/generator"));
     var types_12 = require("@babel/types");
-    var contextObject_12 = require_contextObject();
+    var assert_1 = require("assert");
+    var path_1 = require("path");
+    var closure_1 = require_closure();
+    var generate_1 = require_generate();
+    var hermesBytecode_1 = require_hermesBytecode();
+    var imports_1 = require_imports();
+    var transform_1 = require_transform();
     var types_2 = require_types();
-    function processIfWorkletFile(path, state) {
-      if (!path.node.directives.some((functionDirective) => functionDirective.value.value === "worklet")) {
-        return false;
-      }
-      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");
-      dehoistCommonJSExports(programPath.node);
-      statements.forEach((statement) => {
-        const candidatePath = getCandidate(statement);
-        processWorkletizableEntity(candidatePath, state);
+    var utils_1 = require_utils();
+    var workletStringCode_1 = require_workletStringCode();
+    var REAL_VERSION = require("../package.json").version;
+    var MOCK_VERSION = "x.y.z";
+    function makeWorkletFactory(fun, state) {
+      var _a;
+      const includeClosure = state.opts.bundleMode || !hasDirective(fun, "no-worklet-closure");
+      const limitInitDataHoisting = hasDirective(fun, "limit-init-data-hoisting");
+      stripWorkletDirectives(fun);
+      (0, assert_1.strict)(state.file.opts.filename, "`state.file.opts.filename` is undefined.");
+      const codeObject = (0, generator_1.default)(fun.node, {
+        sourceMaps: true,
+        sourceFileName: state.file.opts.filename
       });
-    }
-    function getCandidate(statementPath) {
-      if (statementPath.isExportNamedDeclaration() || statementPath.isExportDefaultDeclaration()) {
-        return statementPath.get("declaration");
+      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, "`transformed` is undefined.");
+      (0, assert_1.strict)(transformed.ast, "`transformed.ast` is undefined.");
+      const { closureVariables, moduleBindingsToImport, relativeBindingsToImport } = includeClosure ? (0, closure_1.getClosure)(fun, state) : {
+        closureVariables: [],
+        moduleBindingsToImport: /* @__PURE__ */ new Set(),
+        relativeBindingsToImport: /* @__PURE__ */ new Set()
+      };
+      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 { workletName, reactName } = makeWorkletName(fun, state);
+      let mutatedClosureVariables;
+      if (state.opts.bundleMode) {
+        mutatedClosureVariables = closureVariables.map((variable) => (0, types_12.cloneNode)(variable, true));
       } else {
-        return statementPath;
+        mutatedClosureVariables = closureVariables;
       }
-    }
-    function processWorkletizableEntity(nodePath, state) {
-      var _a;
-      if ((0, types_2.isWorkletizableFunctionPath)(nodePath)) {
-        if (nodePath.isArrowFunctionExpression()) {
-          replaceImplicitReturnWithBlock(nodePath.node);
+      let [funString, sourceMapString] = (0, workletStringCode_1.buildWorkletString)(transformed.ast, state, mutatedClosureVariables, workletName, transformed.map);
+      (0, assert_1.strict)(funString, "`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, "`pathForStringDefinitions` is null.");
+      (0, assert_1.strict)(pathForStringDefinitions.parentPath, "`pathForStringDefinitions.parentPath` is null.");
+      const initDataId = pathForStringDefinitions.parentPath.scope.generateUidIdentifier(`worklet_${workletHash}_init_data`);
+      const shouldIncludeInitData = !state.opts.omitNativeOnlyData && !state.opts.bundleMode;
+      const shouldEmitBytecode = !!state.opts.hermesBytecode && (0, utils_1.isRelease)(state) && shouldIncludeInitData;
+      const bytecode = shouldEmitBytecode ? (0, hermesBytecode_1.compileWorkletToHbc)(funString, workletHash, state) : null;
+      const initDataObjectExpression = (0, types_12.objectExpression)(bytecode ? [
+        (0, types_12.objectProperty)((0, types_12.identifier)("bytecode"), (0, types_12.memberExpression)((0, types_12.newExpression)((0, types_12.identifier)("Uint8Array"), [
+          (0, types_12.arrayExpression)(Array.from(bytecode, (byte) => (0, types_12.numericLiteral)(byte)))
+        ]), (0, types_12.identifier)("buffer")))
+      ] : [(0, types_12.objectProperty)((0, types_12.identifier)("code"), (0, types_12.stringLiteral)(funString))]);
+      const shouldInjectLocation = !(0, utils_1.isRelease)(state);
+      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(toPosix(state.file.opts.filename), toPosix(location));
         }
-        appendWorkletDirective(nodePath.node.body);
-      } else if ((0, types_2.isWorkletizableObjectPath)(nodePath)) {
-        if (isImplicitContextObject(nodePath)) {
-          appendWorkletContextObjectMarker(nodePath.node);
+        location = toPosix(location);
+        initDataObjectExpression.properties.push((0, types_12.objectProperty)((0, types_12.identifier)("location"), (0, types_12.stringLiteral)(location)));
+      }
+      if (!bytecode && sourceMapString) {
+        initDataObjectExpression.properties.push((0, types_12.objectProperty)((0, types_12.identifier)("sourceMap"), (0, types_12.stringLiteral)(sourceMapString)));
+      }
+      if (shouldIncludeInitData) {
+        const initDataDeclaration = (0, types_12.variableDeclaration)("const", [
+          (0, types_12.variableDeclarator)(initDataId, initDataObjectExpression)
+        ]);
+        if (limitInitDataHoisting) {
+          fun.getFunctionParent().node.body.body.unshift(initDataDeclaration);
         } else {
-          processWorkletAggregator(nodePath, state);
-        }
-      } else if (nodePath.isVariableDeclaration()) {
-        processVariableDeclaration(nodePath, state);
-      } else if (nodePath.isClassDeclaration()) {
-        appendWorkletClassMarker(nodePath.node.body);
-        if ((_a = nodePath.node.id) === null || _a === void 0 ? void 0 : _a.name) {
-          state.classesToWorkletize.push({
-            node: nodePath.node,
-            name: nodePath.node.id.name
-          });
+          pathForStringDefinitions.insertBefore(initDataDeclaration);
         }
       }
-    }
-    function processVariableDeclaration(variableDeclarationPath, state) {
-      const declarations = variableDeclarationPath.get("declarations");
-      declarations.forEach((declaration) => {
-        const initPath = declaration.get("init");
-        if (initPath.isExpression()) {
-          processWorkletizableEntity(initPath, state);
-        }
-      });
-    }
-    function processWorkletAggregator(objectPath, state) {
-      const properties = objectPath.get("properties");
-      properties.forEach((property) => {
-        if (property.isObjectMethod()) {
-          appendWorkletDirective(property.node.body);
-        } else if (property.isObjectProperty()) {
-          const valuePath = property.get("value");
-          processWorkletizableEntity(valuePath, state);
+      (0, assert_1.strict)(!(0, types_12.isFunctionDeclaration)(funExpression), "`funExpression` is a `FunctionDeclaration`.");
+      (0, assert_1.strict)(!(0, types_12.isObjectMethod)(funExpression), "`funExpression` is an `ObjectMethod`.");
+      const statements = [
+        (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)))
+      ];
+      const shouldInjectVersion = !(0, utils_1.isRelease)(state);
+      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))));
+      }
+      if (shouldIncludeInitData) {
+        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)(state) && !state.opts.bundleMode) {
+        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)
+            // the placement of opening bracket after Exception in line that defined '_e' variable
+          ]))
+        ]));
+        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);
         }
+        return clonedId;
       });
-    }
-    function replaceImplicitReturnWithBlock(path) {
-      if (!(0, types_12.isBlockStatement)(path.body)) {
-        path.body = (0, types_12.blockStatement)([(0, types_12.returnStatement)(path.body)]);
+      if (shouldIncludeInitData) {
+        factoryParams.unshift((0, types_12.cloneNode)(initDataId, true));
       }
-    }
-    function appendWorkletDirective(node) {
-      if (!node.directives.some((functionDirective) => functionDirective.value.value === "worklet")) {
-        node.directives.push((0, types_12.directive)((0, types_12.directiveLiteral)("worklet")));
+      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, imports_1.updateRelativeRequires)(factory, state);
+        (0, generate_1.generateWorkletFile)(moduleBindingsToImport, relativeBindingsToImport, factory, workletHash, state);
       }
+      factory.workletized = true;
+      return { factory, factoryCallParamPack, workletHash };
     }
-    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)) {
-        return;
+    function hasDirective(path, directiveText) {
+      if (!path.node.body) {
+        return false;
       }
-      objectExpression.properties.push((0, types_12.objectProperty)((0, types_12.identifier)(`${contextObject_12.contextObjectMarker}`), (0, types_12.booleanLiteral)(true)));
+      const bodyPath = path.get("body");
+      let has = false;
+      if (bodyPath.isBlockStatement()) {
+        has = bodyPath.get("directives").some((directivePath) => {
+          if (directivePath.isDirective() && directivePath.node.value.value === directiveText) {
+            return true;
+          }
+        });
+      }
+      return has;
     }
-    function isImplicitContextObject(path) {
-      const propertyPaths = path.get("properties");
-      return propertyPaths.some((propertyPath) => {
-        if (!propertyPath.isObjectMethod()) {
-          return false;
+    function stripWorkletDirectives(fun) {
+      fun.traverse({
+        DirectiveLiteral(nodePath) {
+          if ((nodePath.node.value === "worklet" || nodePath.node.value === "no-worklet-closure" || nodePath.node.value === "limit-init-data-hoisting") && nodePath.getFunctionParent() === fun) {
+            nodePath.parentPath.remove();
+          }
         }
-        return hasThisExpression(propertyPath);
       });
     }
-    function hasThisExpression(path) {
-      let result = false;
-      path.traverse({
-        ThisExpression(thisPath) {
-          result = true;
-          thisPath.stop();
-        }
-      });
-      return result;
+    function shouldMockVersion() {
+      return process.env.WORKLETS_JEST_SHOULD_MOCK_VERSION === "1";
     }
-    function appendWorkletClassMarker(classBody) {
-      classBody.body.push((0, types_12.classProperty)((0, types_12.identifier)("__workletClass"), (0, types_12.booleanLiteral)(true)));
+    function hash(str) {
+      let i = str.length;
+      let hash1 = 5381;
+      let hash2 = 52711;
+      while (i--) {
+        const char = str.charCodeAt(i);
+        hash1 = hash1 * 33 ^ char;
+        hash2 = hash2 * 33 ^ char;
+      }
+      return (hash1 >>> 0) * 4096 + (hash2 >>> 0);
     }
-    function dehoistCommonJSExports(program) {
-      const statements = program.body;
-      let end = statements.length;
-      let current = 0;
-      while (current < end) {
-        const statement = statements[current];
-        if (!isCommonJSExport(statement)) {
-          current++;
-          continue;
+    function makeWorkletName(fun, state) {
+      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");
+        if (nodeModulesIndex !== -1) {
+          const libraryName = splitFilepath[nodeModulesIndex + 1];
+          source = `${libraryName}_${source}`;
         }
-        const exportStatement = statements.splice(current, 1);
-        statements.push(...exportStatement);
-        end--;
       }
+      const suffix = `${source}${state.workletNumber++}`;
+      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)) {
+        reactName = fun.node.id.name;
+      }
+      const workletName = reactName ? (0, types_12.toIdentifier)(`${reactName}_${suffix}`) : (0, types_12.toIdentifier)(suffix);
+      reactName = reactName || (0, types_12.toIdentifier)(suffix);
+      return { workletName, reactName };
     }
-    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";
+    function toPosix(p) {
+      return path_1.sep === "/" ? p : p.split(path_1.sep).join("/");
     }
+    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-template-literals"),
+        { loose: true }
+      ]
+    ];
   }
 });
 
-// lib/inlineStylesWarning.js
-var require_inlineStylesWarning = __commonJS({
-  "lib/inlineStylesWarning.js"(exports2) {
+// lib/workletFactoryCall.js
+var require_workletFactoryCall = __commonJS({
+  "lib/workletFactoryCall.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.processInlineStylesWarning = processInlineStylesWarning;
+    exports2.makeWorkletFactoryCall = makeWorkletFactoryCall;
     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)
-      ])), []);
-    }
-    function processPropertyValueForInlineStylesWarning(path) {
-      if (path.isMemberExpression() && (0, types_12.isIdentifier)(path.node.property)) {
-        if (!path.node.computed && 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), "`elements` should be an array.");
-        for (const element of elements) {
-          if (element.isObjectExpression()) {
-            processStyleObjectForInlineStylesWarning(element);
-          }
-        }
-      }
-    }
-    function processStyleObjectForInlineStylesWarning(path) {
-      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") {
-            processTransformPropertyForInlineStylesWarning(value);
-          } else {
-            processPropertyValueForInlineStylesWarning(value);
-          }
-        }
+    var types_2 = require_types();
+    var workletFactory_1 = require_workletFactory();
+    function makeWorkletFactoryCall(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]);
+      } else {
+        factoryCall = (0, types_12.callExpression)(factory, [factoryCallParamPack]);
       }
+      addStackTraceDataToWorkletFactory(path, factoryCall);
+      const replacement = factoryCall;
+      return replacement;
     }
-    function processInlineStylesWarning(path, state) {
-      if ((0, utils_1.isRelease)(state)) {
-        return;
-      }
-      if (state.opts.disableInlineStylesWarning) {
-        return;
-      }
-      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), "`expression` should not be an array.");
-      if (expression.isArrayExpression()) {
-        const elements = expression.get("elements");
-        (0, assert_1.strict)(Array.isArray(elements), "`elements` should be an array.");
-        for (const element of elements) {
-          if (element.isObjectExpression()) {
-            processStyleObjectForInlineStylesWarning(element);
-          }
-        }
-      } else if (expression.isObjectExpression()) {
-        processStyleObjectForInlineStylesWarning(expression);
+    function addStackTraceDataToWorkletFactory(path, workletFactoryCall) {
+      const originalWorkletLocation = path.node.loc;
+      if (originalWorkletLocation) {
+        workletFactoryCall.callee.loc = {
+          filename: originalWorkletLocation.filename,
+          identifierName: originalWorkletLocation.identifierName,
+          start: originalWorkletLocation.start,
+          end: originalWorkletLocation.start
+        };
       }
     }
   }
 });
 
-// lib/webOptimization.js
-var require_webOptimization = __commonJS({
-  "lib/webOptimization.js"(exports2) {
+// lib/workletSubstitution.js
+var require_workletSubstitution = __commonJS({
+  "lib/workletSubstitution.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.substituteWebCallExpression = substituteWebCallExpression;
+    exports2.processIfWithWorkletDirective = processIfWithWorkletDirective;
+    exports2.processWorklet = processWorklet;
+    exports2.substituteObjectMethodWithObjectProperty = substituteObjectMethodWithObjectProperty;
     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") {
-          path.replaceWith((0, types_12.booleanLiteral)(true));
+    var types_2 = require_types();
+    var utils_1 = require_utils();
+    var workletFactoryCall_1 = require_workletFactoryCall();
+    function processIfWithWorkletDirective(path, state) {
+      if (!(0, types_12.isBlockStatement)(path.node.body)) {
+        return false;
+      }
+      if (!hasWorkletDirective(path.node.body.directives)) {
+        return false;
+      }
+      processWorklet(path, state);
+      return true;
+    }
+    function processWorklet(path, state) {
+      path.traverse({
+        // @ts-expect-error TypeScript doesn't like this syntax here.
+        [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");
+    }
+    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;
+        (0, utils_1.replaceWithFactoryCall)(path, name, workletFactoryCall);
       }
     }
+    function substituteObjectMethodWithObjectProperty(path, workletFactoryCall) {
+      const replacement = (0, types_12.objectProperty)(path.node.key, workletFactoryCall);
+      path.replaceWith(replacement);
+    }
   }
 });
 
 // lib/plugin.js
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAutoworkletizationMicroPlugin = getAutoworkletizationMicroPlugin;
 var autoworkletization_1 = require_autoworkletization();
 var bundleMode_1 = require_bundleMode();
 var class_1 = require_class();
+var classMethod_1 = require_classMethod();
 var contextObject_1 = require_contextObject();
 var file_1 = require_file();
 var globals_1 = require_globals();
@@ -2116,13 +2122,13 @@ module.exports = function WorkletsBabelPlugin() {
     pre() {
       runWithTaggedExceptions(this, () => {
         (0, globals_1.initializeState)(this);
+        this.file.path.traverse(getAutoworkletizationMicroPlugin(), this);
       });
     },
     visitor: {
       CallExpression: {
         enter(path, state) {
           runWithTaggedExceptions(state, () => {
-            (0, autoworkletization_1.processCalleesAutoworkletizableCallbacks)(path, state);
             if (state.opts.substituteWebPlatformChecks) {
               (0, webOptimization_1.substituteWebCallExpression)(path);
             }
@@ -2131,7 +2137,9 @@ module.exports = function WorkletsBabelPlugin() {
       },
       [types_1.WorkletizableFunction]: {
         enter(path, state) {
-          runWithTaggedExceptions(state, () => (0, workletSubstitution_1.processIfWithWorkletDirective)(path, state) || (0, autoworkletization_1.processIfAutoworkletizableCallback)(path, state));
+          runWithTaggedExceptions(state, () => {
+            (0, workletSubstitution_1.processIfWithWorkletDirective)(path, state);
+          });
         }
       },
       ObjectExpression: {
@@ -2151,6 +2159,13 @@ module.exports = function WorkletsBabelPlugin() {
           });
         }
       },
+      ClassMethod: {
+        enter(path, state) {
+          runWithTaggedExceptions(state, () => {
+            (0, classMethod_1.processIfWorkletMethod)(path);
+          });
+        }
+      },
       Program: {
         enter(path, state) {
           runWithTaggedExceptions(state, () => {
@@ -2173,4 +2188,18 @@ module.exports = function WorkletsBabelPlugin() {
     }
   };
 };
+function getAutoworkletizationMicroPlugin() {
+  return {
+    CallExpression: {
+      enter(path, state) {
+        (0, autoworkletization_1.handleWorkletizableCallback)(path, state);
+      }
+    },
+    [types_1.WorkletizableFunction]: {
+      enter(path) {
+        (0, autoworkletization_1.addDirectivesToKnownCallback)(path);
+      }
+    }
+  };
+}
 //# sourceMappingURL=index.js.map