@depup/react-native-worklets 0.11.3-depup.0

package/plugin/index.js

@@ -0,0 +1,2188 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// lib/gestureHandlerAutoworkletization.js
+var require_gestureHandlerAutoworkletization = __commonJS({
+  "lib/gestureHandlerAutoworkletization.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.gestureHandlerObjectHooks = exports2.gestureHandlerBuilderMethods = void 0;
+    exports2.isGestureHandlerEventCallback = isGestureHandlerEventCallback;
+    exports2.isGestureObjectEventCallbackMethod = isGestureObjectEventCallbackMethod;
+    var types_12 = require("@babel/types");
+    var gestureHandlerGestureObjects = /* @__PURE__ */ new Set([
+      "Tap",
+      "Pan",
+      "Pinch",
+      "Rotation",
+      "Fling",
+      "LongPress",
+      "ForceTouch",
+      "Native",
+      "Manual",
+      "Race",
+      "Simultaneous",
+      "Exclusive",
+      "Hover"
+    ]);
+    exports2.gestureHandlerBuilderMethods = /* @__PURE__ */ new Set([
+      "onBegin",
+      "onStart",
+      "onEnd",
+      "onFinalize",
+      "onUpdate",
+      "onChange",
+      "onTouchesDown",
+      "onTouchesMove",
+      "onTouchesUp",
+      "onTouchesCancelled"
+    ]);
+    exports2.gestureHandlerObjectHooks = /* @__PURE__ */ new Set([
+      "useTapGesture",
+      "usePanGesture",
+      "usePinchGesture",
+      "useRotationGesture",
+      "useFlingGesture",
+      "useLongPressGesture",
+      "useNativeGesture",
+      "useManualGesture",
+      "useHoverGesture"
+    ]);
+    function isGestureHandlerEventCallback(path) {
+      return (0, types_12.isCallExpression)(path.parent) && (0, types_12.isExpression)(path.parent.callee) && isGestureObjectEventCallbackMethod(path.parent.callee);
+    }
+    function isGestureObjectEventCallbackMethod(exp) {
+      return (0, types_12.isMemberExpression)(exp) && (0, types_12.isIdentifier)(exp.property) && exports2.gestureHandlerBuilderMethods.has(exp.property.name) && containsGestureObject(exp.object);
+    }
+    function containsGestureObject(exp) {
+      if (isGestureObject(exp)) {
+        return true;
+      }
+      if ((0, types_12.isCallExpression)(exp) && (0, types_12.isMemberExpression)(exp.callee) && containsGestureObject(exp.callee.object)) {
+        return true;
+      }
+      return false;
+    }
+    function isGestureObject(exp) {
+      return (0, types_12.isCallExpression)(exp) && (0, types_12.isMemberExpression)(exp.callee) && (0, types_12.isIdentifier)(exp.callee.object) && exp.callee.object.name === "Gesture" && (0, types_12.isIdentifier)(exp.callee.property) && gestureHandlerGestureObjects.has(exp.callee.property.name);
+    }
+  }
+});
+
+// lib/layoutAnimationAutoworkletization.js
+var require_layoutAnimationAutoworkletization = __commonJS({
+  "lib/layoutAnimationAutoworkletization.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isLayoutAnimationCallback = isLayoutAnimationCallback;
+    var types_12 = require("@babel/types");
+    var EntryExitAnimations = /* @__PURE__ */ new Set([
+      "BounceIn",
+      "BounceInDown",
+      "BounceInLeft",
+      "BounceInRight",
+      "BounceInUp",
+      "BounceOut",
+      "BounceOutDown",
+      "BounceOutLeft",
+      "BounceOutRight",
+      "BounceOutUp",
+      "FadeIn",
+      "FadeInDown",
+      "FadeInLeft",
+      "FadeInRight",
+      "FadeInUp",
+      "FadeOut",
+      "FadeOutDown",
+      "FadeOutLeft",
+      "FadeOutRight",
+      "FadeOutUp",
+      "FlipInEasyX",
+      "FlipInEasyY",
+      "FlipInXDown",
+      "FlipInXUp",
+      "FlipInYLeft",
+      "FlipInYRight",
+      "FlipOutEasyX",
+      "FlipOutEasyY",
+      "FlipOutXDown",
+      "FlipOutXUp",
+      "FlipOutYLeft",
+      "FlipOutYRight",
+      "LightSpeedInLeft",
+      "LightSpeedInRight",
+      "LightSpeedOutLeft",
+      "LightSpeedOutRight",
+      "PinwheelIn",
+      "PinwheelOut",
+      "RollInLeft",
+      "RollInRight",
+      "RollOutLeft",
+      "RollOutRight",
+      "RotateInDownLeft",
+      "RotateInDownRight",
+      "RotateInUpLeft",
+      "RotateInUpRight",
+      "RotateOutDownLeft",
+      "RotateOutDownRight",
+      "RotateOutUpLeft",
+      "RotateOutUpRight",
+      "SlideInDown",
+      "SlideInLeft",
+      "SlideInRight",
+      "SlideInUp",
+      "SlideOutDown",
+      "SlideOutLeft",
+      "SlideOutRight",
+      "SlideOutUp",
+      "StretchInX",
+      "StretchInY",
+      "StretchOutX",
+      "StretchOutY",
+      "ZoomIn",
+      "ZoomInDown",
+      "ZoomInEasyDown",
+      "ZoomInEasyUp",
+      "ZoomInLeft",
+      "ZoomInRight",
+      "ZoomInRotate",
+      "ZoomInUp",
+      "ZoomOut",
+      "ZoomOutDown",
+      "ZoomOutEasyDown",
+      "ZoomOutEasyUp",
+      "ZoomOutLeft",
+      "ZoomOutRight",
+      "ZoomOutRotate",
+      "ZoomOutUp"
+    ]);
+    var LayoutTransitions = /* @__PURE__ */ new Set([
+      "Layout",
+      "LinearTransition",
+      "SequencedTransition",
+      "FadingTransition",
+      "JumpingTransition",
+      "CurvedTransition",
+      "EntryExitTransition"
+    ]);
+    var LayoutAnimations = /* @__PURE__ */ new Set([
+      ...EntryExitAnimations,
+      ...LayoutTransitions
+    ]);
+    var BaseAnimationsChainableMethods = /* @__PURE__ */ new Set([
+      "build",
+      "duration",
+      "delay",
+      "getDuration",
+      "randomDelay",
+      "getDelay",
+      "getDelayFunction"
+    ]);
+    var ComplexAnimationsChainableMethods = /* @__PURE__ */ new Set([
+      "easing",
+      "rotate",
+      "springify",
+      "damping",
+      "mass",
+      "stiffness",
+      "overshootClamping",
+      "energyThreshold",
+      "restDisplacementThreshold",
+      "restSpeedThreshold",
+      "withInitialValues",
+      "getAnimationAndConfig"
+    ]);
+    var DefaultTransitionChainableMethods = /* @__PURE__ */ new Set([
+      "easingX",
+      "easingY",
+      "easingWidth",
+      "easingHeight",
+      "entering",
+      "exiting",
+      "reverse"
+    ]);
+    var LayoutAnimationsChainableMethods = /* @__PURE__ */ new Set([
+      ...BaseAnimationsChainableMethods,
+      ...ComplexAnimationsChainableMethods,
+      ...DefaultTransitionChainableMethods
+    ]);
+    var LayoutAnimationsCallbacks = /* @__PURE__ */ new Set(["withCallback"]);
+    function isLayoutAnimationCallback(path) {
+      return (0, types_12.isCallExpression)(path.parent) && (0, types_12.isExpression)(path.parent.callee) && isLayoutAnimationCallbackMethod(path.parent.callee);
+    }
+    function isLayoutAnimationCallbackMethod(exp) {
+      return (0, types_12.isMemberExpression)(exp) && (0, types_12.isIdentifier)(exp.property) && LayoutAnimationsCallbacks.has(exp.property.name) && isLayoutAnimationsChainableOrNewOperator(exp.object);
+    }
+    function isLayoutAnimationsChainableOrNewOperator(exp) {
+      if ((0, types_12.isIdentifier)(exp) && LayoutAnimations.has(exp.name)) {
+        return true;
+      } else if ((0, types_12.isNewExpression)(exp) && (0, types_12.isIdentifier)(exp.callee) && LayoutAnimations.has(exp.callee.name)) {
+        return true;
+      }
+      if ((0, types_12.isCallExpression)(exp) && (0, types_12.isMemberExpression)(exp.callee) && (0, types_12.isIdentifier)(exp.callee.property) && LayoutAnimationsChainableMethods.has(exp.callee.property.name) && isLayoutAnimationsChainableOrNewOperator(exp.callee.object)) {
+        return true;
+      }
+      return false;
+    }
+  }
+});
+
+// lib/types.js
+var require_types = __commonJS({
+  "lib/types.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.generatedWorkletsDir = exports2.workletClassFactorySuffix = exports2.WorkletizableObject = exports2.WorkletizableFunction = void 0;
+    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;
+    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;
+    }
+  }
+});
+
+// lib/utils.js
+var require_utils = __commonJS({
+  "lib/utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isRelease = isRelease;
+    exports2.replaceWithFactoryCall = replaceWithFactoryCall;
+    var types_12 = require("@babel/types");
+    function isRelease(state) {
+      var _a, _b;
+      const releasePattern = /(prod|release|stag[ei])/i;
+      const developmentPattern = /dev/i;
+      const envName = state.file.opts.envName;
+      if (envName) {
+        if (envName.match(releasePattern)) {
+          return true;
+        }
+        if (envName.match(developmentPattern)) {
+          return false;
+        }
+      }
+      return !!(((_a = process.env.BABEL_ENV) === null || _a === void 0 ? void 0 : _a.match(releasePattern)) || ((_b = process.env.NODE_ENV) === null || _b === void 0 ? void 0 : _b.match(releasePattern)));
+    }
+    function replaceWithFactoryCall(toReplace, name, factoryCall) {
+      if (!name || !needsDeclaration(toReplace)) {
+        toReplace.replaceWith(factoryCall);
+      } else {
+        const replacement = (0, types_12.variableDeclaration)("const", [
+          (0, types_12.variableDeclarator)((0, types_12.identifier)(name), factoryCall)
+        ]);
+        toReplace.replaceWith(replacement);
+      }
+    }
+    function needsDeclaration(nodePath) {
+      return (0, types_12.isScopable)(nodePath.parent) || (0, types_12.isExportNamedDeclaration)(nodePath.parent);
+    }
+  }
+});
+
+// lib/globals.js
+var require_globals = __commonJS({
+  "lib/globals.js"(exports2) {
+    "use strict";
+    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 assert_1 = require("assert");
+    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;
+      }
+      state.workletNumber = 1;
+      state.classesToWorkletize = [];
+      state.autoworkletizationPlugin = {
+        name: "worklets-autoworkletization",
+        visitor: {
+          CallExpression: {
+            enter(nodePath) {
+              (0, autoworkletization_12.processCalleesAutoworkletizableCallbacks)(nodePath, state);
+            }
+          }
+        }
+      };
+      if (!state.opts.strictGlobal) {
+        initializeGlobals();
+        addCustomGlobals(state);
+      }
+      const userImportForwarding = state.opts.importForwarding;
+      (0, assert_1.strict)(state.importForwarding === void 0, "state.importForwarding should be undefined at this point");
+      state.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 isGeneratedWorkletFile(filename) {
+      if (!filename) {
+        return false;
+      }
+      const generatedWorkletsDirPath = path_1.default.join("react-native-worklets", types_12.generatedWorkletsDir);
+      return filename.includes(generatedWorkletsDirPath);
+    }
+    exports2.defaultGlobals = new Set(notCapturedIdentifiers);
+    function initializeGlobals() {
+      exports2.globals = new Set(exports2.defaultGlobals);
+    }
+    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);
+        });
+      }
+    }
+  }
+});
+
+// lib/imports.js
+var require_imports = __commonJS({
+  "lib/imports.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");
+    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.importForwarding.relativePaths)) {
+              requiredModule.replaceWith(createImportPathLiteral(requiredModule.node.value, state));
+            }
+          }
+        }
+      });
+    }
+    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);
+      }
+      for (let i = 0; i <= fileSegments.length - pkgSegments.length; i++) {
+        if (pkgSegments.every((segment, segmentIndex) => fileSegments[i + segmentIndex] === segment)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    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/closure.js
+var require_closure = __commonJS({
+  "lib/closure.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getClosure = getClosure;
+    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.importForwarding.relativePaths)) {
+              capturedNames.add(name);
+              relativeBindingsToImport.add(binding);
+              return;
+            }
+            const source = binding.path.parentPath.node.source.value;
+            if ((0, imports_1.canForwardModuleImport)(source, state.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/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.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));
+      }
+      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 hasDirective(path, directiveText) {
+      if (!path.node.body) {
+        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 };
+    }
+    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/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
+        };
+      }
+    }
+  }
+});
+
+// lib/workletSubstitution.js
+var require_workletSubstitution = __commonJS({
+  "lib/workletSubstitution.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.processIfWithWorkletDirective = processIfWithWorkletDirective;
+    exports2.processWorklet = processWorklet;
+    exports2.substituteObjectMethodWithObjectProperty = substituteObjectMethodWithObjectProperty;
+    var types_12 = require("@babel/types");
+    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/objectWorklets.js
+var require_objectWorklets = __commonJS({
+  "lib/objectWorklets.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.tryProcessingNode = tryProcessingNode;
+    exports2.processWorkletizableObject = processWorkletizableObject;
+    var findWorklet_1 = require_findWorklet();
+    var types_12 = require_types();
+    var workletSubstitution_12 = require_workletSubstitution();
+    function tryProcessingNode(arg, state, acceptWorkletizableFunction, acceptObject) {
+      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.`);
+        }
+      }
+    }
+  }
+});
+
+// lib/autoworkletization.js
+var require_autoworkletization = __commonJS({
+  "lib/autoworkletization.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.processIfAutoworkletizableCallback = processIfAutoworkletizableCallback;
+    exports2.processCalleesAutoworkletizableCallbacks = processCalleesAutoworkletizableCallbacks;
+    var types_12 = require("@babel/types");
+    var gestureHandlerAutoworkletization_1 = require_gestureHandlerAutoworkletization();
+    var layoutAnimationAutoworkletization_1 = require_layoutAnimationAutoworkletization();
+    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;
+    }
+    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;
+      }
+      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);
+      }
+    }
+    function processArgs(args, state, acceptWorkletizableFunction, acceptObject) {
+      args.forEach((arg) => {
+        (0, objectWorklets_1.tryProcessingNode)(arg, state, acceptWorkletizableFunction, acceptObject);
+      });
+    }
+  }
+});
+
+// lib/bundleMode.js
+var require_bundleMode = __commonJS({
+  "lib/bundleMode.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.toggleBundleMode = toggleBundleMode;
+    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));
+    }
+  }
+});
+
+// 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.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;
+      }
+      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);
+                  }
+                }
+              });
+            });
+          }
+        }
+      });
+      return polyfills;
+    }
+    function topoSort(toSort) {
+      const sorted = [];
+      const stack = /* @__PURE__ */ new Set();
+      for (const element of toSort) {
+        recursiveTopoSort(element, toSort, sorted, stack);
+      }
+      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)) {
+        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);
+    }
+    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 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/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 isContextObject(objectExpression) {
+      return objectExpression.properties.some((property) => (0, types_12.isObjectProperty)(property) && (0, types_12.isIdentifier)(property.key) && property.key.name === exports2.contextObjectMarker);
+    }
+    function processWorkletContextObject(objectExpression) {
+      const workletObjectFactory = (0, types_12.functionExpression)(null, [], (0, types_12.blockStatement)([(0, types_12.returnStatement)((0, types_12.cloneNode)(objectExpression))], [(0, types_12.directive)((0, types_12.directiveLiteral)("worklet"))]));
+      objectExpression.properties.push((0, types_12.objectProperty)((0, types_12.identifier)(`${exports2.contextObjectMarker}Factory`), workletObjectFactory));
+    }
+    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/file.js
+var require_file = __commonJS({
+  "lib/file.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.processIfWorkletFile = processIfWorkletFile;
+    exports2.isImplicitContextObject = isImplicitContextObject;
+    var types_12 = require("@babel/types");
+    var contextObject_12 = require_contextObject();
+    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()) {
+          replaceImplicitReturnWithBlock(nodePath.node);
+        }
+        appendWorkletDirective(nodePath.node.body);
+      } 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()) {
+          appendWorkletDirective(property.node.body);
+        } else if (property.isObjectProperty()) {
+          const valuePath = property.get("value");
+          processWorkletizableEntity(valuePath, state);
+        }
+      });
+    }
+    function replaceImplicitReturnWithBlock(path) {
+      if (!(0, types_12.isBlockStatement)(path.body)) {
+        path.body = (0, types_12.blockStatement)([(0, types_12.returnStatement)(path.body)]);
+      }
+    }
+    function appendWorkletDirective(node) {
+      if (!node.directives.some((functionDirective) => functionDirective.value.value === "worklet")) {
+        node.directives.push((0, types_12.directive)((0, types_12.directiveLiteral)("worklet")));
+      }
+    }
+    function appendWorkletContextObjectMarker(objectExpression) {
+      if (objectExpression.properties.some((value) => (0, types_12.isObjectProperty)(value) && (0, types_12.isIdentifier)(value.key) && value.key.name === contextObject_12.contextObjectMarker)) {
+        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/inlineStylesWarning.js
+var require_inlineStylesWarning = __commonJS({
+  "lib/inlineStylesWarning.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.processInlineStylesWarning = processInlineStylesWarning;
+    var types_12 = require("@babel/types");
+    var assert_1 = require("assert");
+    var 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);
+          }
+        }
+      }
+    }
+    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/webOptimization.js
+var require_webOptimization = __commonJS({
+  "lib/webOptimization.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    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/plugin.js
+Object.defineProperty(exports, "__esModule", { value: true });
+var autoworkletization_1 = require_autoworkletization();
+var bundleMode_1 = require_bundleMode();
+var class_1 = require_class();
+var contextObject_1 = require_contextObject();
+var file_1 = require_file();
+var globals_1 = require_globals();
+var inlineStylesWarning_1 = require_inlineStylesWarning();
+var types_1 = require_types();
+var webOptimization_1 = require_webOptimization();
+var workletSubstitution_1 = require_workletSubstitution();
+module.exports = function WorkletsBabelPlugin() {
+  function runWithTaggedExceptions(state, fun) {
+    if (state.skipFile) {
+      return;
+    }
+    try {
+      fun();
+    } catch (e) {
+      const error = e;
+      error.message = `[Worklets] Babel plugin exception: ${error.message}`;
+      error.name = "WorkletsBabelPluginError";
+      throw error;
+    }
+  }
+  return {
+    name: "worklets",
+    pre() {
+      runWithTaggedExceptions(this, () => {
+        (0, globals_1.initializeState)(this);
+      });
+    },
+    visitor: {
+      CallExpression: {
+        enter(path, state) {
+          runWithTaggedExceptions(state, () => {
+            (0, autoworkletization_1.processCalleesAutoworkletizableCallbacks)(path, state);
+            if (state.opts.substituteWebPlatformChecks) {
+              (0, webOptimization_1.substituteWebCallExpression)(path);
+            }
+          });
+        }
+      },
+      [types_1.WorkletizableFunction]: {
+        enter(path, state) {
+          runWithTaggedExceptions(state, () => (0, workletSubstitution_1.processIfWithWorkletDirective)(path, state) || (0, autoworkletization_1.processIfAutoworkletizableCallback)(path, state));
+        }
+      },
+      ObjectExpression: {
+        enter(path, state) {
+          runWithTaggedExceptions(state, () => {
+            (0, contextObject_1.processIfWorkletContextObject)(path, state);
+          });
+        }
+      },
+      ClassDeclaration: {
+        enter(path, state) {
+          runWithTaggedExceptions(state, () => {
+            if (state.opts.disableWorkletClasses) {
+              return;
+            }
+            (0, class_1.processIfWorkletClass)(path, state);
+          });
+        }
+      },
+      Program: {
+        enter(path, state) {
+          runWithTaggedExceptions(state, () => {
+            (0, file_1.processIfWorkletFile)(path, state);
+          });
+        }
+      },
+      ExpressionStatement: {
+        enter(path, state) {
+          runWithTaggedExceptions(state, () => {
+            (0, bundleMode_1.toggleBundleMode)(path, state);
+          });
+        }
+      },
+      JSXAttribute: {
+        enter(path, state) {
+          runWithTaggedExceptions(state, () => (0, inlineStylesWarning_1.processInlineStylesWarning)(path, state));
+        }
+      }
+    }
+  };
+};
+//# sourceMappingURL=index.js.map