@onlynative/inertia 0.0.1-alpha.3 → 0.0.1-alpha.4

package/dist/motion/Image.mjs

@@ -1,14 +1,21 @@
-import { Image, Platform } from 'react-native';
+import { Platform, TurboModuleRegistry, Image } from 'react-native';
 import { createContext, forwardRef, useRef, useState, useEffect, useMemo, useContext } from 'react';
-import Animated, { useSharedValue, useAnimatedStyle, interpolateColor, useReducedMotion, withSequence, runOnJS, withRepeat, withDelay, withDecay, withTiming, Easing, withSpring, isWorkletFunction } from 'react-native-reanimated';
+import Animated, { useSharedValue, useAnimatedStyle, interpolateColor, useReducedMotion, withSequence, LinearTransition, runOnJS as runOnJS$1, withRepeat, withDelay, withDecay, withTiming, Easing, withSpring } from 'react-native-reanimated';
 import { jsx } from 'react/jsx-runtime';
 
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
 var DEFAULT_MOTION_CONFIG = {
   reducedMotion: "user"
 };
@@ -48,10 +55,1394 @@ function isFocusVisible() {
   ensureInstalled();
   return modality === "keyboard";
 }
-var PresenceContext = createContext(null);
-function usePresence() {
-  return useContext(PresenceContext);
+
+// ../../node_modules/react-native-worklets/lib/module/logger.js
+var PREFIX = "[Worklets]";
+function formatMessage(message) {
+  return `${PREFIX} ${message}`;
+}
+var logger = {
+  warn(message) {
+    console.warn(formatMessage(message));
+  },
+  error(message) {
+    console.error(formatMessage(message));
+  }
+};
+
+// ../../node_modules/react-native-worklets/lib/module/runtimeKind.js
+var RuntimeKind = /* @__PURE__ */ (function(RuntimeKind2) {
+  RuntimeKind2[RuntimeKind2["ReactNative"] = 1] = "ReactNative";
+  RuntimeKind2[RuntimeKind2["UI"] = 2] = "UI";
+  RuntimeKind2[RuntimeKind2["Worker"] = 3] = "Worker";
+  return RuntimeKind2;
+})({});
+if (globalThis.__RUNTIME_KIND === void 0) {
+  globalThis.__RUNTIME_KIND = RuntimeKind.ReactNative;
+}
+
+// ../../node_modules/react-native-worklets/lib/module/WorkletsError.js
+function WorkletsErrorConstructor(message) {
+  "worklet";
+  const prefix = "[Worklets]";
+  const errorInstance = new Error(message ? `${prefix} ${message}` : prefix);
+  errorInstance.name = `WorkletsError`;
+  return errorInstance;
+}
+function registerWorkletsError() {
+  "worklet";
+  if (globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative) {
+    globalThis.WorkletsError = WorkletsErrorConstructor;
+  }
+}
+var WorkletsError = WorkletsErrorConstructor;
+
+// ../../node_modules/react-native-worklets/lib/module/bundleUnpacker.js
+var handleCache = /* @__PURE__ */ new WeakMap();
+function bundleValueUnpacker(objectToUnpack, category, remoteFunctionName) {
+  const workletHash = objectToUnpack.__workletHash;
+  if (workletHash !== void 0) {
+    return getWorklet(workletHash, objectToUnpack.__closure);
+  } else if (objectToUnpack.__init !== void 0) {
+    let value = handleCache.get(objectToUnpack);
+    if (value === void 0) {
+      value = objectToUnpack.__init();
+      handleCache.set(objectToUnpack, value);
+    }
+    return value;
+  } else if (category === "RemoteFunction") {
+    const remoteFunctionHolder = () => {
+      const label = remoteFunctionName ? `function \`${remoteFunctionName}\`` : "anonymous function";
+      throw new WorkletsError(`Tried to synchronously call a non-worklet ${label} on the UI thread.
+See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#tried-to-synchronously-call-a-non-worklet-function-on-the-ui-thread for more details.`);
+    };
+    remoteFunctionHolder.__remoteFunction = objectToUnpack;
+    return remoteFunctionHolder;
+  } else {
+    throw new WorkletsError(`Data type in category "${category}" not recognized by value unpacker: "${globalThis._toString(objectToUnpack)}".`);
+  }
+}
+function getWorklet(workletHash, closureVariables) {
+  let worklet;
+  if (__DEV__) {
+    try {
+      worklet = getWorkletFromMetroRequire(workletHash, closureVariables);
+    } catch (_e) {
+      logger.error("Unable to resolve worklet with hash " + workletHash + ". Try reloading the app.");
+    }
+  } else {
+    worklet = getWorkletFromMetroRequire(workletHash, closureVariables);
+  }
+  return worklet;
+}
+var metroRequire = globalThis.__r;
+function getWorkletFromMetroRequire(workletHash, closureVariables) {
+  const factory = metroRequire(workletHash).default;
+  return factory(closureVariables);
+}
+
+// ../../node_modules/react-native-worklets/lib/module/callGuard.js
+function callGuardDEV(fn, ...args) {
+  "worklet";
+  try {
+    return fn(...args);
+  } catch (error) {
+    if (globalThis.__workletsModuleProxy) {
+      const {
+        message,
+        stack,
+        name,
+        jsEngine
+      } = error;
+      globalThis.__workletsModuleProxy.reportFatalErrorOnJS(message, stack ?? "", name ?? "WorkletsError", jsEngine ?? "Worklets");
+    } else {
+      throw error;
+    }
+  }
+}
+function setupCallGuard() {
+  "worklet";
+  if (!globalThis.__callGuardDEV) {
+    globalThis.__callGuardDEV = callGuardDEV;
+  }
+}
+
+// ../../node_modules/react-native-worklets/lib/module/errors.js
+var _workletStackDetails = /* @__PURE__ */ new Map();
+function registerWorkletStackDetails(hash, stackDetails) {
+  _workletStackDetails.set(hash, stackDetails);
+}
+function getBundleOffset(error) {
+  const frame = error.stack?.split("\n")?.[0];
+  if (frame) {
+    const parsedFrame = /@([^@]+):(\d+):(\d+)/.exec(frame);
+    if (parsedFrame) {
+      const [, file, line, col] = parsedFrame;
+      return [file, Number(line), Number(col)];
+    }
+  }
+  return ["unknown", 0, 0];
+}
+function processStack(stack) {
+  if (stack === "" || stack === void 0) {
+    return void 0;
+  }
+  const workletStackEntries = stack.match(/worklet_(\d+):(\d+):(\d+)/g);
+  let result = stack;
+  workletStackEntries?.forEach((match) => {
+    const [, hash, origLine, origCol] = match.split(/:|_/).map(Number);
+    const errorDetails = _workletStackDetails.get(hash);
+    if (!errorDetails) {
+      return;
+    }
+    const [error, lineOffset, colOffset] = errorDetails;
+    const [bundleFile, bundleLine, bundleCol] = getBundleOffset(error);
+    const line = origLine + bundleLine + lineOffset;
+    const col = origCol + bundleCol + colOffset;
+    result = result.replace(match, `${bundleFile}:${line}:${col}`);
+  });
+  return result;
+}
+function reportFatalRemoteError({
+  message,
+  stack,
+  name,
+  jsEngine
+}, force) {
+  const error = new WorkletsError();
+  error.message = message;
+  error.stack = processStack(stack);
+  error.name = name;
+  error.jsEngine = jsEngine;
+  if (force) {
+    throw error;
+  } else {
+    globalThis.ErrorUtils.reportFatalError(error);
+  }
+}
+function registerReportFatalRemoteError() {
+  globalThis.__reportFatalRemoteError = reportFatalRemoteError;
+}
+var IS_JEST = !!process.env.JEST_WORKER_ID;
+var IS_WEB = Platform.OS === "web";
+var IS_WINDOWS = Platform.OS === "windows";
+var SHOULD_BE_USE_WEB = IS_JEST || IS_WEB || IS_WINDOWS;
+
+// ../../node_modules/react-native-worklets/lib/module/PlatformChecker/index.js
+var IS_JEST2 = false;
+var SHOULD_BE_USE_WEB2 = false;
+if (globalThis.__RUNTIME_KIND === RuntimeKind.ReactNative) {
+  IS_JEST2 = IS_JEST;
+  SHOULD_BE_USE_WEB2 = SHOULD_BE_USE_WEB;
+}
+
+// ../../node_modules/react-native-worklets/lib/module/runLoop/common/setImmediatePolyfill.js
+function setupSetImmediate() {
+  "worklet";
+  const setImmediatePolyfill = (callback, ...args) => {
+    return setTimeout(callback, 0, ...args);
+  };
+  const clearImmediatePolyfill = (immediateHandle) => {
+    clearTimeout(immediateHandle);
+  };
+  globalThis.setImmediate = setImmediatePolyfill;
+  globalThis.clearImmediate = clearImmediatePolyfill;
+}
+
+// ../../node_modules/react-native-worklets/lib/module/runLoop/common/setIntervalPolyfill.js
+function setupSetInterval() {
+  "worklet";
+  const intervalHandleToTimeoutHandle = /* @__PURE__ */ new Map();
+  const setIntervalPolyfill = (callback, delay = 0, ...args) => {
+    let intervalHandle = 0;
+    const repeatingCallback = () => {
+      const timeoutHandle = setTimeout(repeatingCallback, delay);
+      intervalHandleToTimeoutHandle.set(intervalHandle, timeoutHandle);
+      callback(...args);
+    };
+    intervalHandle = setTimeout(repeatingCallback, delay);
+    intervalHandleToTimeoutHandle.set(intervalHandle, intervalHandle);
+    return intervalHandle;
+  };
+  const clearIntervalPolyfill = (intervalHandle) => {
+    const timeoutHandle = intervalHandleToTimeoutHandle.get(intervalHandle);
+    clearTimeout(timeoutHandle);
+    intervalHandleToTimeoutHandle.delete(intervalHandle);
+  };
+  globalThis.setInterval = setIntervalPolyfill;
+  globalThis.clearInterval = clearIntervalPolyfill;
+}
+
+// ../../node_modules/react-native-worklets/lib/module/runLoop/uiRuntime/mockedRequestAnimationFrame.js
+function mockedRequestAnimationFrame(callback) {
+  return setTimeout(() => callback(performance.now()), 0);
+}
+
+// ../../node_modules/react-native-worklets/lib/module/isSynchronizable.js
+function isSynchronizable(value) {
+  return typeof value === "object" && value !== null && "__synchronizableRef" in value && value.__synchronizableRef === true;
+}
+
+// ../../node_modules/react-native-worklets/lib/module/serializableMappingCache.js
+var serializableMappingFlag = /* @__PURE__ */ Symbol("serializable flag");
+var cache = SHOULD_BE_USE_WEB2 ? null : /* @__PURE__ */ new WeakMap();
+var serializableMappingCache = SHOULD_BE_USE_WEB2 ? {
+  set() {
+  },
+  get() {
+    return null;
+  }
+} : {
+  set(serializable, serializableRef) {
+    cache.set(serializable, serializableRef || serializableMappingFlag);
+  },
+  get: cache.get.bind(cache)
+};
+
+// ../../node_modules/react-native-worklets/lib/module/utils/jsVersion.js
+var jsVersion = "0.5.1";
+
+// ../../node_modules/react-native-worklets/lib/module/workletFunction.js
+function isWorkletFunction(value) {
+  "worklet";
+  return (
+    // `__workletHash` isn't extracted in Worklet Runtimes.
+    typeof value === "function" && !!value.__workletHash
+  );
+}
+
+// ../../node_modules/react-native-worklets/lib/module/WorkletsModule/JSWorklets.js
+function createJSWorkletsModule() {
+  return new JSWorklets();
+}
+var requestAnimationFrameImpl = IS_JEST2 || !globalThis.requestAnimationFrame ? mockedRequestAnimationFrame : globalThis.requestAnimationFrame;
+var JSWorklets = class {
+  createSerializable() {
+    throw new WorkletsError("createSerializable should never be called in JSWorklets.");
+  }
+  createSerializableString() {
+    throw new WorkletsError("createSerializableString should never be called in JSWorklets.");
+  }
+  createSerializableNumber() {
+    throw new WorkletsError("createSerializableNumber should never be called in JSWorklets.");
+  }
+  createSerializableBoolean() {
+    throw new WorkletsError("createSerializableBoolean should never be called in JSWorklets.");
+  }
+  createSerializableBigInt() {
+    throw new WorkletsError("createSerializableBigInt should never be called in JSWorklets.");
+  }
+  createSerializableUndefined() {
+    throw new WorkletsError("createSerializableUndefined should never be called in JSWorklets.");
+  }
+  createSerializableNull() {
+    throw new WorkletsError("createSerializableNull should never be called in JSWorklets.");
+  }
+  createSerializableTurboModuleLike() {
+    throw new WorkletsError("createSerializableTurboModuleLike should never be called in JSWorklets.");
+  }
+  createSerializableObject() {
+    throw new WorkletsError("createSerializableObject should never be called in JSWorklets.");
+  }
+  createSerializableMap() {
+    throw new WorkletsError("createSerializableMap should never be called in JSWorklets.");
+  }
+  createSerializableSet() {
+    throw new WorkletsError("createSerializableSet should never be called in JSWorklets.");
+  }
+  createSerializableImport() {
+    throw new WorkletsError("createSerializableImport should never be called in JSWorklets.");
+  }
+  createSerializableHostObject() {
+    throw new WorkletsError("createSerializableHostObject should never be called in JSWorklets.");
+  }
+  createSerializableArray() {
+    throw new WorkletsError("createSerializableArray should never be called in JSWorklets.");
+  }
+  createSerializableInitializer() {
+    throw new WorkletsError("createSerializableInitializer should never be called in JSWorklets.");
+  }
+  createSerializableFunction() {
+    throw new WorkletsError("createSerializableFunction should never be called in JSWorklets.");
+  }
+  createSerializableWorklet() {
+    throw new WorkletsError("createSerializableWorklet should never be called in JSWorklets.");
+  }
+  scheduleOnUI(worklet) {
+    requestAnimationFrameImpl(worklet);
+  }
+  executeOnUIRuntimeSync() {
+    throw new WorkletsError("`executeOnUIRuntimeSync` is not available in JSWorklets.");
+  }
+  createWorkletRuntime() {
+    throw new WorkletsError("createWorkletRuntime is not available in JSWorklets.");
+  }
+  scheduleOnRuntime() {
+    throw new WorkletsError("scheduleOnRuntime is not available in JSWorklets.");
+  }
+  createSynchronizable() {
+    throw new WorkletsError("createSynchronizable should never be called in JSWorklets.");
+  }
+  synchronizableGetDirty() {
+    throw new WorkletsError("synchronizableGetDirty should never be called in JSWorklets.");
+  }
+  synchronizableGetBlocking() {
+    throw new WorkletsError("synchronizableGetBlocking should never be called in JSWorklets.");
+  }
+  synchronizableSetBlocking() {
+    throw new WorkletsError("synchronizableSetBlocking should never be called in JSWorklets.");
+  }
+  synchronizableLock() {
+    throw new WorkletsError("synchronizableLock should never be called in JSWorklets.");
+  }
+  synchronizableUnlock() {
+    throw new WorkletsError("synchronizableUnlock should never be called in JSWorklets.");
+  }
+  reportFatalErrorOnJS() {
+    throw new WorkletsError("reportFatalErrorOnJS should never be called in JSWorklets.");
+  }
+  getStaticFeatureFlag() {
+    return false;
+  }
+  setDynamicFeatureFlag() {
+  }
+};
+var NativeWorkletsModule_default = TurboModuleRegistry.get("WorkletsModule");
+
+// ../../node_modules/react-native-worklets/lib/module/specs/index.js
+var WorkletsTurboModule = globalThis.__RUNTIME_KIND === RuntimeKind.ReactNative ? NativeWorkletsModule_default : (
+  // In Bundle Mode, on Worklet Runtimes `RNWorkletsTurboModule` isn't
+  // available and shouldn't be accessed. We return null here
+  // to keep the same codebase for the Bundle Mode and legacy behavior.
+  null
+);
+
+// ../../node_modules/react-native-worklets/lib/module/utils/checkCppVersion.js
+function checkCppVersion() {
+  const cppVersion = global._WORKLETS_VERSION_CPP;
+  if (cppVersion === void 0) {
+    logger.warn(`Couldn't determine the version of the native part of Worklets.
+    See \`https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#couldnt-determine-the-version-of-the-native-part-of-worklets\` for more details.`);
+    return;
+  }
+  const ok = matchVersion(jsVersion, cppVersion);
+  if (!ok) {
+    throw new WorkletsError(`Mismatch between JavaScript part and native part of Worklets (${jsVersion} vs ${cppVersion}).
+    See \`https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#mismatch-between-javascript-part-and-native-part-of-worklets\` for more details.`);
+  }
+}
+function matchVersion(version1, version2) {
+  if (version1.match(/^\d+\.\d+\.\d+$/) && version2.match(/^\d+\.\d+\.\d+$/)) {
+    const [major1, minor1] = version1.split(".");
+    const [major2, minor2] = version2.split(".");
+    return major1 === major2 && minor1 === minor2;
+  } else {
+    return version1 === version2;
+  }
+}
+
+// ../../node_modules/react-native-worklets/lib/module/WorkletsModule/NativeWorklets.js
+function createNativeWorkletsModule() {
+  return new NativeWorklets();
+}
+var _workletsModuleProxy, _serializableUndefined, _serializableNull, _serializableTrue, _serializableFalse;
+var NativeWorklets = class {
+  constructor() {
+    __privateAdd(this, _workletsModuleProxy);
+    __privateAdd(this, _serializableUndefined);
+    __privateAdd(this, _serializableNull);
+    __privateAdd(this, _serializableTrue);
+    __privateAdd(this, _serializableFalse);
+    globalThis._WORKLETS_VERSION_JS = jsVersion;
+    if (global.__workletsModuleProxy === void 0 && globalThis.__RUNTIME_KIND === RuntimeKind.ReactNative) {
+      WorkletsTurboModule?.installTurboModule();
+    }
+    if (global.__workletsModuleProxy === void 0) {
+      throw new WorkletsError(`Native part of Worklets doesn't seem to be initialized.
+See https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#native-part-of-worklets-doesnt-seem-to-be-initialized for more details.`);
+    }
+    if (__DEV__) {
+      checkCppVersion();
+    }
+    __privateSet(this, _workletsModuleProxy, global.__workletsModuleProxy);
+    __privateSet(this, _serializableNull, __privateGet(this, _workletsModuleProxy).createSerializableNull());
+    __privateSet(this, _serializableUndefined, __privateGet(this, _workletsModuleProxy).createSerializableUndefined());
+    __privateSet(this, _serializableTrue, __privateGet(this, _workletsModuleProxy).createSerializableBoolean(true));
+    __privateSet(this, _serializableFalse, __privateGet(this, _workletsModuleProxy).createSerializableBoolean(false));
+  }
+  createSerializable(value, shouldPersistRemote, nativeStateSource) {
+    return __privateGet(this, _workletsModuleProxy).createSerializable(value, shouldPersistRemote, nativeStateSource);
+  }
+  createSerializableImport(from, to) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableImport(from, to);
+  }
+  createSerializableString(str) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableString(str);
+  }
+  createSerializableNumber(num) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableNumber(num);
+  }
+  createSerializableBoolean(bool) {
+    return bool ? __privateGet(this, _serializableTrue) : __privateGet(this, _serializableFalse);
+  }
+  createSerializableBigInt(bigInt) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableBigInt(bigInt);
+  }
+  createSerializableUndefined() {
+    return __privateGet(this, _serializableUndefined);
+  }
+  createSerializableNull() {
+    return __privateGet(this, _serializableNull);
+  }
+  createSerializableTurboModuleLike(props, proto) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableTurboModuleLike(props, proto);
+  }
+  createSerializableObject(obj, shouldRetainRemote, nativeStateSource) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableObject(obj, shouldRetainRemote, nativeStateSource);
+  }
+  createSerializableHostObject(obj) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableHostObject(obj);
+  }
+  createSerializableArray(array, shouldRetainRemote) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableArray(array, shouldRetainRemote);
+  }
+  createSerializableMap(keys, values) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableMap(keys, values);
+  }
+  createSerializableSet(values) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableSet(values);
+  }
+  createSerializableInitializer(obj) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableInitializer(obj);
+  }
+  createSerializableFunction(func) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableFunction(func);
+  }
+  createSerializableWorklet(worklet, shouldPersistRemote) {
+    return __privateGet(this, _workletsModuleProxy).createSerializableWorklet(worklet, shouldPersistRemote);
+  }
+  scheduleOnUI(serializable) {
+    return __privateGet(this, _workletsModuleProxy).scheduleOnUI(serializable);
+  }
+  executeOnUIRuntimeSync(serializable) {
+    return __privateGet(this, _workletsModuleProxy).executeOnUIRuntimeSync(serializable);
+  }
+  createWorkletRuntime(name, initializer, useDefaultQueue, customQueue, enableEventLoop) {
+    return __privateGet(this, _workletsModuleProxy).createWorkletRuntime(name, initializer, useDefaultQueue, customQueue, enableEventLoop);
+  }
+  scheduleOnRuntime(workletRuntime, serializableWorklet) {
+    return __privateGet(this, _workletsModuleProxy).scheduleOnRuntime(workletRuntime, serializableWorklet);
+  }
+  createSynchronizable(value) {
+    return __privateGet(this, _workletsModuleProxy).createSynchronizable(value);
+  }
+  synchronizableGetDirty(synchronizableRef) {
+    return __privateGet(this, _workletsModuleProxy).synchronizableGetDirty(synchronizableRef);
+  }
+  synchronizableGetBlocking(synchronizableRef) {
+    return __privateGet(this, _workletsModuleProxy).synchronizableGetBlocking(synchronizableRef);
+  }
+  synchronizableSetBlocking(synchronizableRef, value) {
+    return __privateGet(this, _workletsModuleProxy).synchronizableSetBlocking(synchronizableRef, value);
+  }
+  synchronizableLock(synchronizableRef) {
+    return __privateGet(this, _workletsModuleProxy).synchronizableLock(synchronizableRef);
+  }
+  synchronizableUnlock(synchronizableRef) {
+    return __privateGet(this, _workletsModuleProxy).synchronizableUnlock(synchronizableRef);
+  }
+  reportFatalErrorOnJS(message, stack, name, jsEngine) {
+    return __privateGet(this, _workletsModuleProxy).reportFatalErrorOnJS(message, stack, name, jsEngine);
+  }
+  getStaticFeatureFlag(name) {
+    return __privateGet(this, _workletsModuleProxy).getStaticFeatureFlag(name);
+  }
+  setDynamicFeatureFlag(name, value) {
+    __privateGet(this, _workletsModuleProxy).setDynamicFeatureFlag(name, value);
+  }
+};
+_workletsModuleProxy = new WeakMap();
+_serializableUndefined = new WeakMap();
+_serializableNull = new WeakMap();
+_serializableTrue = new WeakMap();
+_serializableFalse = new WeakMap();
+
+// ../../node_modules/react-native-worklets/lib/module/WorkletsModule/workletsModuleInstance.js
+var WorkletsModule = SHOULD_BE_USE_WEB2 ? createJSWorkletsModule() : createNativeWorkletsModule();
+
+// ../../node_modules/react-native-worklets/lib/module/serializable.js
+var MAGIC_KEY = "REANIMATED_MAGIC_KEY";
+function isHostObject(value) {
+  "worklet";
+  return MAGIC_KEY in value;
+}
+function isPlainJSObject(object) {
+  "worklet";
+  return Object.getPrototypeOf(object) === Object.prototype;
+}
+function isTurboModuleLike(object) {
+  return isHostObject(Object.getPrototypeOf(object));
+}
+function getFromCache(value) {
+  const cached = serializableMappingCache.get(value);
+  if (cached === serializableMappingFlag) {
+    return value;
+  }
+  return cached;
+}
+var INACCESSIBLE_OBJECT = {
+  __init: () => {
+    "worklet";
+    return new Proxy({}, {
+      get: (_, prop) => {
+        if (prop === "_isReanimatedSharedValue" || prop === "__remoteFunction") {
+          return false;
+        }
+        throw new WorkletsError(`Trying to access property \`${String(prop)}\` of an object which cannot be sent to the UI runtime.`);
+      },
+      set: () => {
+        throw new WorkletsError("Trying to write to an object which cannot be sent to the UI runtime.");
+      }
+    });
+  }
+};
+var VALID_ARRAY_VIEWS_NAMES = ["Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "Float32Array", "Float64Array", "BigInt64Array", "BigUint64Array", "DataView"];
+var DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD = 30;
+var processedObjectAtThresholdDepth;
+function createSerializableWeb(value) {
+  return value;
+}
+function createSerializableNative(value, shouldPersistRemote = false, depth = 0) {
+  detectCyclicObject(value, depth);
+  const isObject = typeof value === "object";
+  const isFunction = typeof value === "function";
+  if (typeof value === "string") {
+    return cloneString(value);
+  }
+  if (typeof value === "number") {
+    return cloneNumber(value);
+  }
+  if (typeof value === "boolean") {
+    return cloneBoolean(value);
+  }
+  if (typeof value === "bigint") {
+    return cloneBigInt(value);
+  }
+  if (value === void 0) {
+    return cloneUndefined();
+  }
+  if (value === null) {
+    return cloneNull();
+  }
+  if (!isObject && !isFunction || value === null) {
+    return clonePrimitive(value, shouldPersistRemote);
+  }
+  const cached = getFromCache(value);
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (Array.isArray(value)) {
+    return cloneArray(value, shouldPersistRemote, depth);
+  }
+  if (globalThis._WORKLETS_BUNDLE_MODE && isFunction && value.__bundleData) {
+    return cloneImport(value);
+  }
+  if (isFunction && !isWorkletFunction(value)) {
+    return cloneRemoteFunction(value);
+  }
+  if (isTurboModuleLike(value)) {
+    return cloneTurboModuleLike(value, shouldPersistRemote, depth);
+  }
+  if (isHostObject(value)) {
+    return cloneHostObject(value);
+  }
+  if (isPlainJSObject(value) && value.__init) {
+    return cloneInitializer(value, shouldPersistRemote, depth);
+  }
+  if (isPlainJSObject(value) && value.__workletContextObjectFactory) {
+    return cloneContextObject(value);
+  }
+  if ((isPlainJSObject(value) || isFunction) && isWorkletFunction(value)) {
+    return cloneWorklet(value, shouldPersistRemote, depth);
+  }
+  if (isSynchronizable(value)) {
+    return cloneSynchronizable(value);
+  }
+  if (isPlainJSObject(value) || isFunction) {
+    return clonePlainJSObject(value, shouldPersistRemote, depth);
+  }
+  if (value instanceof Set) {
+    return cloneSet(value);
+  }
+  if (value instanceof Map) {
+    return cloneMap(value);
+  }
+  if (value instanceof RegExp) {
+    return cloneRegExp(value);
+  }
+  if (value instanceof Error) {
+    return cloneError(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return cloneArrayBuffer(value, shouldPersistRemote);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return cloneArrayBufferView(value);
+  }
+  return inaccessibleObject(value);
+}
+if (globalThis._WORKLETS_BUNDLE_MODE) {
+  createSerializableNative.__bundleData = {
+    imported: "createSerializable",
+    // @ts-expect-error resolveWeak is defined by Metro
+    source: __require.resolveWeak("./index")
+  };
+}
+var createSerializable = SHOULD_BE_USE_WEB2 ? createSerializableWeb : createSerializableNative;
+function detectCyclicObject(value, depth) {
+  if (depth >= DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD) {
+    if (depth === DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD) {
+      processedObjectAtThresholdDepth = value;
+    } else if (value === processedObjectAtThresholdDepth) {
+      throw new WorkletsError("Trying to convert a cyclic object to a serializable. This is not supported.");
+    }
+  } else {
+    processedObjectAtThresholdDepth = void 0;
+  }
 }
+function clonePrimitive(value, shouldPersistRemote) {
+  return WorkletsModule.createSerializable(value, shouldPersistRemote);
+}
+function cloneString(value) {
+  return WorkletsModule.createSerializableString(value);
+}
+function cloneNumber(value) {
+  return WorkletsModule.createSerializableNumber(value);
+}
+function cloneBoolean(value) {
+  return WorkletsModule.createSerializableBoolean(value);
+}
+function cloneBigInt(value) {
+  return WorkletsModule.createSerializableBigInt(value);
+}
+function cloneUndefined() {
+  return WorkletsModule.createSerializableUndefined();
+}
+function cloneNull() {
+  return WorkletsModule.createSerializableNull();
+}
+function cloneObjectProperties(value, shouldPersistRemote, depth) {
+  const clonedProps = {};
+  for (const [key, element] of Object.entries(value)) {
+    if (key === "__initData" && clonedProps.__initData !== void 0) {
+      continue;
+    }
+    clonedProps[key] = createSerializable(element, shouldPersistRemote, depth + 1);
+  }
+  return clonedProps;
+}
+function cloneInitializer(value, shouldPersistRemote = false, depth = 0) {
+  const clonedProps = cloneObjectProperties(value, shouldPersistRemote, depth);
+  return WorkletsModule.createSerializableInitializer(clonedProps);
+}
+function cloneArray(value, shouldPersistRemote, depth) {
+  const clonedElements = value.map((element) => createSerializable(element, shouldPersistRemote, depth + 1));
+  const clone = WorkletsModule.createSerializableArray(clonedElements, shouldPersistRemote);
+  serializableMappingCache.set(value, clone);
+  serializableMappingCache.set(clone);
+  freezeObjectInDev(value);
+  return clone;
+}
+function cloneRemoteFunction(value) {
+  const clone = WorkletsModule.createSerializableFunction(value);
+  serializableMappingCache.set(value, clone);
+  serializableMappingCache.set(clone);
+  freezeObjectInDev(value);
+  return clone;
+}
+function cloneHostObject(value) {
+  const clone = WorkletsModule.createSerializableHostObject(value);
+  serializableMappingCache.set(value, clone);
+  serializableMappingCache.set(clone);
+  return clone;
+}
+function cloneWorklet(value, shouldPersistRemote, depth) {
+  if (__DEV__) {
+    const babelVersion = value.__pluginVersion;
+    if (babelVersion !== void 0 && babelVersion !== jsVersion) {
+      throw new WorkletsError(`Mismatch between JavaScript code version and Worklets Babel plugin version (${jsVersion} vs. ${babelVersion}).
+    See \`https://docs.swmansion.com/react-native-worklets/docs/guides/troubleshooting#mismatch-between-javascript-code-version-and-worklets-babel-plugin-version\` for more details.
+    Offending code was: \`${getWorkletCode(value)}\``);
+    }
+    registerWorkletStackDetails(value.__workletHash, value.__stackDetails);
+  }
+  if (value.__stackDetails) {
+    delete value.__stackDetails;
+  }
+  const clonedProps = cloneObjectProperties(value, true, depth);
+  clonedProps.__initData = createSerializable(value.__initData, true, depth + 1);
+  const clone = WorkletsModule.createSerializableWorklet(
+    clonedProps,
+    // TODO: Check after refactor if we can remove shouldPersistRemote parameter (imho it's redundant here since worklets are always persistent)
+    // retain all worklets
+    true
+  );
+  serializableMappingCache.set(value, clone);
+  serializableMappingCache.set(clone);
+  freezeObjectInDev(value);
+  return clone;
+}
+function cloneTurboModuleLike(value, shouldPersistRemote, depth) {
+  const proto = Object.getPrototypeOf(value);
+  const clonedProps = cloneObjectProperties(value, shouldPersistRemote, depth);
+  const clone = WorkletsModule.createSerializableTurboModuleLike(clonedProps, proto);
+  return clone;
+}
+function cloneContextObject(value) {
+  const workletContextObjectFactory = value.__workletContextObjectFactory;
+  const handle = cloneInitializer({
+    __init: () => {
+      "worklet";
+      return workletContextObjectFactory();
+    }
+  });
+  serializableMappingCache.set(value, handle);
+  return handle;
+}
+function clonePlainJSObject(value, shouldPersistRemote, depth) {
+  const clonedProps = cloneObjectProperties(value, shouldPersistRemote, depth);
+  const clone = WorkletsModule.createSerializableObject(clonedProps, shouldPersistRemote, value);
+  serializableMappingCache.set(value, clone);
+  serializableMappingCache.set(clone);
+  freezeObjectInDev(value);
+  return clone;
+}
+function cloneMap(value) {
+  const clonedKeys = [];
+  const clonedValues = [];
+  for (const [key, element] of value.entries()) {
+    clonedKeys.push(createSerializable(key));
+    clonedValues.push(createSerializable(element));
+  }
+  const clone = WorkletsModule.createSerializableMap(clonedKeys, clonedValues);
+  serializableMappingCache.set(value, clone);
+  serializableMappingCache.set(clone);
+  freezeObjectInDev(value);
+  return clone;
+}
+function cloneSet(value) {
+  const clonedElements = [];
+  for (const element of value) {
+    clonedElements.push(createSerializable(element));
+  }
+  const clone = WorkletsModule.createSerializableSet(clonedElements);
+  serializableMappingCache.set(value, clone);
+  serializableMappingCache.set(clone);
+  freezeObjectInDev(value);
+  return clone;
+}
+function cloneRegExp(value) {
+  const pattern = value.source;
+  const flags = value.flags;
+  const handle = cloneInitializer({
+    __init: () => {
+      "worklet";
+      return new RegExp(pattern, flags);
+    }
+  });
+  serializableMappingCache.set(value, handle);
+  return handle;
+}
+function cloneError(value) {
+  const {
+    name,
+    message,
+    stack
+  } = value;
+  const handle = cloneInitializer({
+    __init: () => {
+      "worklet";
+      const error = new Error();
+      error.name = name;
+      error.message = message;
+      error.stack = stack;
+      return error;
+    }
+  });
+  serializableMappingCache.set(value, handle);
+  return handle;
+}
+function cloneArrayBuffer(value, shouldPersistRemote) {
+  const clone = WorkletsModule.createSerializable(value, shouldPersistRemote, value);
+  serializableMappingCache.set(value, clone);
+  serializableMappingCache.set(clone);
+  return clone;
+}
+function cloneArrayBufferView(value) {
+  const buffer = value.buffer;
+  const typeName = value.constructor.name;
+  const handle = cloneInitializer({
+    __init: () => {
+      "worklet";
+      if (!VALID_ARRAY_VIEWS_NAMES.includes(typeName)) {
+        throw new WorkletsError(`Invalid array view name \`${typeName}\`.`);
+      }
+      const constructor = global[typeName];
+      if (constructor === void 0) {
+        throw new WorkletsError(`Constructor for \`${typeName}\` not found.`);
+      }
+      return new constructor(buffer);
+    }
+  });
+  serializableMappingCache.set(value, handle);
+  return handle;
+}
+function cloneSynchronizable(value) {
+  serializableMappingCache.set(value);
+  return value;
+}
+function cloneImport(value) {
+  const {
+    source,
+    imported
+  } = value.__bundleData;
+  const clone = WorkletsModule.createSerializableImport(source, imported);
+  serializableMappingCache.set(value, clone);
+  serializableMappingCache.set(clone);
+  return clone;
+}
+function inaccessibleObject(value) {
+  const clone = createSerializable(INACCESSIBLE_OBJECT);
+  serializableMappingCache.set(value, clone);
+  return clone;
+}
+var WORKLET_CODE_THRESHOLD = 255;
+function getWorkletCode(value) {
+  const code = value?.__initData?.code;
+  if (!code) {
+    return "unknown";
+  }
+  if (code.length > WORKLET_CODE_THRESHOLD) {
+    return `${code.substring(0, WORKLET_CODE_THRESHOLD)}...`;
+  }
+  return code;
+}
+function isRemoteFunction(value) {
+  "worklet";
+  return !!value.__remoteFunction;
+}
+function freezeObjectInDev(value) {
+  if (!__DEV__) {
+    return;
+  }
+  Object.entries(value).forEach(([key, element]) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor.configurable) {
+      return;
+    }
+    Object.defineProperty(value, key, {
+      get() {
+        return element;
+      },
+      set() {
+        logger.warn(`Tried to modify key \`${key}\` of an object which has been already passed to a worklet. See
+        https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#tried-to-modify-key-of-an-object-which-has-been-converted-to-a-serializable
+        for more details.`);
+      }
+    });
+  });
+  Object.preventExtensions(value);
+}
+function makeShareableCloneOnUIRecursiveLEGACY(value) {
+  "worklet";
+  if (SHOULD_BE_USE_WEB2) {
+    return value;
+  }
+  function cloneRecursive(value2) {
+    if (typeof value2 === "object" && value2 !== null || typeof value2 === "function") {
+      if (isHostObject(value2)) {
+        return global._createSerializableHostObject(value2);
+      }
+      if (isRemoteFunction(value2)) {
+        return value2.__remoteFunction;
+      }
+      if (Array.isArray(value2)) {
+        return global._createSerializableArray(value2.map(cloneRecursive));
+      }
+      if (value2.__synchronizableRef) {
+        return global._createSerializableSynchronizable(value2);
+      }
+      const toAdapt = {};
+      for (const [key, element] of Object.entries(value2)) {
+        toAdapt[key] = cloneRecursive(element);
+      }
+      return global._createSerializable(toAdapt, value2);
+    }
+    if (typeof value2 === "string") {
+      return global._createSerializableString(value2);
+    }
+    if (typeof value2 === "number") {
+      return global._createSerializableNumber(value2);
+    }
+    if (typeof value2 === "boolean") {
+      return global._createSerializableBoolean(value2);
+    }
+    if (typeof value2 === "bigint") {
+      return global._createSerializableBigInt(value2);
+    }
+    if (value2 === void 0) {
+      return global._createSerializableUndefined();
+    }
+    if (value2 === null) {
+      return global._createSerializableNull();
+    }
+    return global._createSerializable(value2, void 0);
+  }
+  return cloneRecursive(value);
+}
+var makeShareableCloneOnUIRecursive = globalThis._WORKLETS_BUNDLE_MODE ? createSerializable : makeShareableCloneOnUIRecursiveLEGACY;
+
+// ../../node_modules/react-native-worklets/lib/module/threads.js
+var runOnUIQueue = [];
+function setupMicrotasks() {
+  "worklet";
+  let microtasksQueue = [];
+  let isExecutingMicrotasksQueue = false;
+  global.queueMicrotask = (callback) => {
+    microtasksQueue.push(callback);
+  };
+  global._microtaskQueueFinalizers = [];
+  global.__callMicrotasks = () => {
+    if (isExecutingMicrotasksQueue) {
+      return;
+    }
+    try {
+      isExecutingMicrotasksQueue = true;
+      for (let index = 0; index < microtasksQueue.length; index += 1) {
+        microtasksQueue[index]();
+      }
+      microtasksQueue = [];
+      global._microtaskQueueFinalizers.forEach((finalizer) => finalizer());
+    } finally {
+      isExecutingMicrotasksQueue = false;
+    }
+  };
+}
+function callMicrotasksOnUIThread() {
+  "worklet";
+  global.__callMicrotasks();
+}
+var callMicrotasks = SHOULD_BE_USE_WEB2 ? () => {
+} : callMicrotasksOnUIThread;
+function runOnUI(worklet) {
+  if (__DEV__ && !SHOULD_BE_USE_WEB2 && !isWorkletFunction(worklet) && !worklet.__bundleData) {
+    throw new WorkletsError("`runOnUI` can only be used with worklets.");
+  }
+  return (...args) => {
+    if (IS_JEST2) {
+      WorkletsModule.scheduleOnUI(createSerializable(() => {
+        "worklet";
+        worklet(...args);
+      }));
+      return;
+    }
+    if (__DEV__) {
+      createSerializable(worklet);
+      createSerializable(args);
+    }
+    enqueueUI(worklet, args);
+  };
+}
+if (__DEV__) {
+  let runOnUIWorklet = function() {
+    "worklet";
+    throw new WorkletsError("`runOnUI` cannot be called on the UI runtime. Please call the function synchronously or use `queueMicrotask` or `requestAnimationFrame` instead.");
+  };
+  const serializableRunOnUIWorklet = createSerializable(runOnUIWorklet);
+  serializableMappingCache.set(runOnUI, serializableRunOnUIWorklet);
+}
+function executeOnUIRuntimeSync(worklet) {
+  return (...args) => {
+    return WorkletsModule.executeOnUIRuntimeSync(createSerializable(() => {
+      "worklet";
+      const result = worklet(...args);
+      return makeShareableCloneOnUIRecursive(result);
+    }));
+  };
+}
+function runWorkletOnJS(worklet, ...args) {
+  worklet(...args);
+}
+function runOnJS(fun) {
+  "worklet";
+  if (SHOULD_BE_USE_WEB2 || globalThis.__RUNTIME_KIND === RuntimeKind.ReactNative) {
+    return (...args) => queueMicrotask(args.length ? () => fun(...args) : fun);
+  }
+  if (isWorkletFunction(fun)) {
+    return (...args) => runOnJS(runWorkletOnJS)(fun, ...args);
+  }
+  if (fun.__remoteFunction) {
+    fun = fun.__remoteFunction;
+  }
+  const scheduleOnJS = typeof fun === "function" ? global._scheduleHostFunctionOnJS : global._scheduleRemoteFunctionOnJS;
+  return (...args) => {
+    scheduleOnJS(fun, args.length > 0 ? makeShareableCloneOnUIRecursive(args) : void 0);
+  };
+}
+function runOnUIAsync(worklet) {
+  if (__DEV__ && !SHOULD_BE_USE_WEB2 && !isWorkletFunction(worklet)) {
+    throw new WorkletsError("`runOnUIAsync` can only be used with worklets.");
+  }
+  return (...args) => {
+    return new Promise((resolve) => {
+      if (IS_JEST2) {
+        WorkletsModule.scheduleOnUI(createSerializable(() => {
+          "worklet";
+          worklet(...args);
+        }));
+        return;
+      }
+      if (__DEV__) {
+        createSerializable(worklet);
+        createSerializable(args);
+      }
+      enqueueUI(worklet, args, resolve);
+    });
+  };
+}
+if (__DEV__) {
+  let runOnUIAsyncWorklet = function() {
+    "worklet";
+    throw new WorkletsError("`runOnUIAsync` cannot be called on the UI runtime. Please call the function synchronously or use `queueMicrotask` or `requestAnimationFrame` instead.");
+  };
+  const serializableRunOnUIAsyncWorklet = createSerializable(runOnUIAsyncWorklet);
+  serializableMappingCache.set(runOnUIAsync, serializableRunOnUIAsyncWorklet);
+}
+function enqueueUI(worklet, args, resolve) {
+  const job = [worklet, args, resolve];
+  runOnUIQueue.push(job);
+  if (runOnUIQueue.length === 1) {
+    flushUIQueue();
+  }
+}
+function flushUIQueue() {
+  queueMicrotask(() => {
+    const queue = runOnUIQueue;
+    runOnUIQueue = [];
+    WorkletsModule.scheduleOnUI(createSerializable(() => {
+      "worklet";
+      queue.forEach(([workletFunction, workletArgs, jobResolve]) => {
+        const result = workletFunction(...workletArgs);
+        if (jobResolve) {
+          runOnJS(jobResolve)(result);
+        }
+      });
+      callMicrotasks();
+    }));
+  });
+}
+
+// ../../node_modules/react-native-worklets/lib/module/runLoop/uiRuntime/requestAnimationFrame.js
+function setupRequestAnimationFrame() {
+  "worklet";
+  const nativeRequestAnimationFrame = globalThis.requestAnimationFrame;
+  let queuedCallbacks = [];
+  let queuedCallbacksBegin = 0;
+  let queuedCallbacksEnd = 0;
+  let flushedCallbacks = queuedCallbacks;
+  let flushedCallbacksBegin = 0;
+  let flushedCallbacksEnd = 0;
+  let flushRequested = false;
+  globalThis.__flushAnimationFrame = (timestamp) => {
+    flushedCallbacks = queuedCallbacks;
+    queuedCallbacks = [];
+    flushedCallbacksBegin = queuedCallbacksBegin;
+    flushedCallbacksEnd = queuedCallbacksEnd;
+    queuedCallbacksBegin = queuedCallbacksEnd;
+    for (const callback of flushedCallbacks) {
+      callback(timestamp);
+    }
+    flushedCallbacksBegin = flushedCallbacksEnd;
+    callMicrotasks();
+  };
+  globalThis.requestAnimationFrame = (callback) => {
+    const handle = queuedCallbacksEnd++;
+    queuedCallbacks.push(callback);
+    if (!flushRequested) {
+      flushRequested = true;
+      nativeRequestAnimationFrame((timestamp) => {
+        flushRequested = false;
+        globalThis.__frameTimestamp = timestamp;
+        globalThis.__flushAnimationFrame(timestamp);
+        globalThis.__frameTimestamp = void 0;
+      });
+    }
+    return handle;
+  };
+  globalThis.cancelAnimationFrame = (handle) => {
+    if (handle < flushedCallbacksBegin || handle >= queuedCallbacksEnd) {
+      return;
+    }
+    if (handle < flushedCallbacksEnd) {
+      flushedCallbacks[handle - flushedCallbacksBegin] = () => {
+      };
+    } else {
+      queuedCallbacks[handle - queuedCallbacksBegin] = () => {
+      };
+    }
+  };
+}
+
+// ../../node_modules/react-native-worklets/lib/module/runLoop/uiRuntime/setTimeoutPolyfill.js
+function setupSetTimeout() {
+  "worklet";
+  const timeoutHandleToRafHandle = /* @__PURE__ */ new Map();
+  const setTimeoutPolyfill = (callback, delay = 0, ...args) => {
+    const start = performance.now();
+    let timeoutHandle = 0;
+    const rafCallback = () => {
+      const now = performance.now();
+      if (now - start >= delay) {
+        callback(...args);
+        timeoutHandleToRafHandle.delete(timeoutHandle);
+      } else {
+        const rafHandle = requestAnimationFrame(rafCallback);
+        timeoutHandleToRafHandle.set(timeoutHandle, rafHandle);
+      }
+    };
+    timeoutHandle = requestAnimationFrame(rafCallback);
+    timeoutHandleToRafHandle.set(timeoutHandle, timeoutHandle);
+    return timeoutHandle;
+  };
+  const clearTimeoutPolyfill = (timeoutHandle) => {
+    const rafHandle = timeoutHandleToRafHandle.get(timeoutHandle);
+    timeoutHandleToRafHandle.delete(timeoutHandle);
+    cancelAnimationFrame(rafHandle);
+  };
+  globalThis.setTimeout = setTimeoutPolyfill;
+  globalThis.clearTimeout = clearTimeoutPolyfill;
+}
+
+// ../../node_modules/react-native-worklets/lib/module/synchronizableUnpacker.js
+function __installUnpacker() {
+  const serializer = !globalThis._WORKLET || globalThis._WORKLETS_BUNDLE_MODE ? (value, _) => createSerializable(value) : globalThis._createSerializable;
+  function synchronizableUnpacker(synchronizableRef) {
+    const synchronizable = synchronizableRef;
+    const proxy = globalThis.__workletsModuleProxy;
+    synchronizable.__synchronizableRef = true;
+    synchronizable.getDirty = () => {
+      return proxy.synchronizableGetDirty(synchronizable);
+    };
+    synchronizable.getBlocking = () => {
+      return proxy.synchronizableGetBlocking(synchronizable);
+    };
+    synchronizable.setBlocking = (valueOrFunction) => {
+      let newValue;
+      if (typeof valueOrFunction === "function") {
+        const func = valueOrFunction;
+        synchronizable.lock();
+        const prev = synchronizable.getBlocking();
+        newValue = func(prev);
+        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue, void 0));
+        synchronizable.unlock();
+      } else {
+        const value = valueOrFunction;
+        newValue = value;
+        proxy.synchronizableSetBlocking(synchronizable, serializer(newValue, void 0));
+      }
+    };
+    synchronizable.lock = () => {
+      proxy.synchronizableLock(synchronizable);
+    };
+    synchronizable.unlock = () => {
+      proxy.synchronizableUnlock(synchronizable);
+    };
+    return synchronizable;
+  }
+  globalThis.__synchronizableUnpacker = synchronizableUnpacker;
+}
+
+// ../../node_modules/react-native-worklets/lib/module/initializers.js
+var capturableConsole;
+function getMemorySafeCapturableConsole() {
+  if (capturableConsole) {
+    return capturableConsole;
+  }
+  const consoleCopy = Object.fromEntries(Object.entries(console).map(([methodName, method]) => {
+    const methodWrapper = function methodWrapper2(...args) {
+      return method(...args);
+    };
+    if (method.name) {
+      Object.defineProperty(methodWrapper, "name", {
+        value: method.name,
+        writable: false
+      });
+    }
+    return [methodName, methodWrapper];
+  }));
+  capturableConsole = consoleCopy;
+  return consoleCopy;
+}
+function setupConsole(boundCapturableConsole) {
+  "worklet";
+  globalThis.console = {
+    assert: runOnJS(boundCapturableConsole.assert),
+    debug: runOnJS(boundCapturableConsole.debug),
+    log: runOnJS(boundCapturableConsole.log),
+    warn: runOnJS(boundCapturableConsole.warn),
+    error: runOnJS(boundCapturableConsole.error),
+    info: runOnJS(boundCapturableConsole.info)
+  };
+}
+var initialized = false;
+function init() {
+  if (initialized) {
+    return;
+  }
+  initialized = true;
+  if (globalThis.__RUNTIME_KIND === void 0) {
+    globalThis.__RUNTIME_KIND = RuntimeKind.ReactNative;
+  }
+  initializeRuntime();
+  if (SHOULD_BE_USE_WEB2) {
+    initializeRuntimeOnWeb();
+  }
+  if (globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative) {
+    initializeWorkletRuntime();
+  } else {
+    initializeRNRuntime();
+    if (!SHOULD_BE_USE_WEB2) {
+      installRNBindingsOnUIRuntime();
+    }
+  }
+}
+function initializeRuntime() {
+  if (globalThis._WORKLETS_BUNDLE_MODE) {
+    globalThis.__valueUnpacker = bundleValueUnpacker;
+  }
+  __installUnpacker();
+}
+function initializeRNRuntime() {
+  if (__DEV__) {
+    const testWorklet = () => {
+      "worklet";
+    };
+    if (!isWorkletFunction(testWorklet)) {
+      throw new WorkletsError(`Failed to create a worklet. See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#failed-to-create-a-worklet for more details.`);
+    }
+  }
+  registerReportFatalRemoteError();
+}
+function initializeWorkletRuntime() {
+  if (globalThis._WORKLETS_BUNDLE_MODE) {
+    setupCallGuard();
+    if (__DEV__) {
+      const Refresh = new Proxy({}, {
+        get() {
+          return () => {
+          };
+        }
+      });
+      globalThis.__r.Refresh = Refresh;
+      const modules = __require.getModules();
+      const ReactNativeModuleId = __require.resolveWeak("react-native");
+      const factory = function(_global, _require, _importDefault, _importAll, module, _exports, _dependencyMap) {
+        module.exports = new Proxy({}, {
+          get: function get(_target, prop) {
+            globalThis.console.warn(`You tried to import '${String(prop)}' from 'react-native' module on a Worklet Runtime. Using 'react-native' module on a Worklet Runtime is not allowed.`);
+            return {
+              get() {
+                return void 0;
+              }
+            };
+          }
+        });
+      };
+      const mod = {
+        dependencyMap: [],
+        factory,
+        hasError: false,
+        importedAll: {},
+        importedDefault: {},
+        isInitialized: false,
+        publicModule: {
+          exports: {}
+        }
+      };
+      modules.set(ReactNativeModuleId, mod);
+    }
+  }
+}
+function initializeRuntimeOnWeb() {
+  globalThis._WORKLET = false;
+  globalThis._log = console.log;
+  globalThis._getAnimationTimestamp = () => performance.now();
+  if (IS_JEST2) {
+    globalThis.requestAnimationFrame = mockedRequestAnimationFrame;
+  }
+}
+function installRNBindingsOnUIRuntime() {
+  if (!WorkletsModule) {
+    throw new WorkletsError("Worklets are trying to initialize the UI runtime without a valid WorkletsModule");
+  }
+  const runtimeBoundCapturableConsole = getMemorySafeCapturableConsole();
+  if (!globalThis._WORKLETS_BUNDLE_MODE) {
+    executeOnUIRuntimeSync(setupCallGuard)();
+    executeOnUIRuntimeSync(registerWorkletsError)();
+  }
+  executeOnUIRuntimeSync(() => {
+    "worklet";
+    setupConsole(runtimeBoundCapturableConsole);
+    setupMicrotasks();
+    setupRequestAnimationFrame();
+    setupSetTimeout();
+    setupSetImmediate();
+    setupSetInterval();
+  })();
+}
+
+// ../../node_modules/react-native-worklets/lib/module/workletRuntimeEntry.js
+function bundleModeInit() {
+  if (SHOULD_BE_USE_WEB2) {
+    return;
+  }
+  globalThis._WORKLETS_BUNDLE_MODE = true;
+  const runtimeKind = globalThis.__RUNTIME_KIND;
+  if (runtimeKind && runtimeKind !== RuntimeKind.ReactNative) {
+    init();
+    throw new WorkletsError("Worklets initialized successfully");
+  }
+}
+bundleModeInit();
+
+// ../../node_modules/react-native-worklets/lib/module/featureFlags/index.js
+var DynamicFlags = {
+  EXAMPLE_DYNAMIC_FLAG: true,
+  init() {
+    Object.keys(DynamicFlags).forEach((key) => {
+      if (key !== "init" && key !== "setFlag") {
+        WorkletsModule.setDynamicFeatureFlag(key, DynamicFlags[key]);
+      }
+    });
+  },
+  setFlag(name, value) {
+    if (name in DynamicFlags) {
+      DynamicFlags[name] = value;
+      WorkletsModule.setDynamicFeatureFlag(name, value);
+    } else {
+      logger.warn(`The feature flag: '${name}' no longer exists, you can safely remove invocation of \`setDynamicFeatureFlag('${name}')\` from your code.`);
+    }
+  }
+};
+DynamicFlags.init();
+
+// ../../node_modules/react-native-worklets/lib/module/index.js
+init();
+if (globalThis._ALWAYS_FALSE) {
+  bundleModeInit();
+}
+
+// src/transitions/easing.ts
 function ensureWorkletEasing(easing) {
   if (!easing) return void 0;
   if (isWorkletFunction(easing)) return easing;
@@ -62,13 +1453,12 @@ function ensureWorkletEasing(easing) {
   return wrapped;
 }
 
-// src/transitions/resolve.ts
+// src/transitions/spring.ts
 var DEFAULT_SPRING = {
   tension: 170,
   friction: 26,
   mass: 1
 };
-var DEFAULT_TIMING_DURATION = 250;
 function springToReanimated(t) {
   return {
     stiffness: t.tension ?? DEFAULT_SPRING.tension,
@@ -79,6 +1469,33 @@ function springToReanimated(t) {
     restDisplacementThreshold: t.restDisplacementThreshold
   };
 }
+
+// src/layout/resolveLayout.ts
+function resolveLayoutTransition(layout) {
+  if (!layout) return void 0;
+  const cfg = layout === true ? { type: "spring" } : layout;
+  if (cfg.type === "no-animation") return void 0;
+  if (cfg.type === "timing") {
+    let builder2 = LinearTransition.duration(cfg.duration ?? 300);
+    const easing = ensureWorkletEasing(cfg.easing);
+    if (easing) builder2 = builder2.easing(easing);
+    if (cfg.delay) builder2 = builder2.delay(cfg.delay);
+    return builder2;
+  }
+  const spring = cfg.type === "decay" ? { type: "spring" } : cfg;
+  const { stiffness, damping, mass } = springToReanimated({
+    ...DEFAULT_SPRING,
+    ...spring
+  });
+  let builder = LinearTransition.springify().stiffness(stiffness).damping(damping).mass(mass);
+  if ("delay" in spring && spring.delay) builder = builder.delay(spring.delay);
+  return builder;
+}
+var PresenceContext = createContext(null);
+function usePresence() {
+  return useContext(PresenceContext);
+}
+var DEFAULT_TIMING_DURATION = 250;
 function buildSpring(cfg, toValue, cb) {
   return withSpring(toValue, springToReanimated(cfg), cb);
 }
@@ -184,6 +1601,51 @@ function mergeTransition(base, override) {
   return { ...base ?? { type: "spring" }, ...override };
 }
 
+// src/transitions/keys.ts
+var TRANSITION_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "tension",
+  "friction",
+  "mass",
+  "velocity",
+  "restSpeedThreshold",
+  "restDisplacementThreshold",
+  "duration",
+  "easing",
+  "delay",
+  "repeat",
+  "deceleration",
+  "clamp"
+]);
+function isTopLevelTransition(t) {
+  if (t === null || typeof t !== "object") return false;
+  const keys = Object.keys(t);
+  if (keys.length === 0) return false;
+  return keys.every((k) => TRANSITION_CONFIG_KEYS.has(k));
+}
+
+// src/transitions/sig.ts
+function stableSig(value) {
+  if (value === void 0) return "";
+  try {
+    return stableStringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function stableStringify(v) {
+  if (v === null || typeof v !== "object") {
+    if (typeof v === "function" || v === void 0) return "null";
+    return JSON.stringify(v);
+  }
+  if (Array.isArray(v)) {
+    return "[" + v.map(stableStringify).join(",") + "]";
+  }
+  const obj = v;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+
 // src/motion/installCheck.ts
 var alreadyChecked = false;
 function ensureReanimatedInstalled() {
@@ -223,8 +1685,11 @@ var TRANSFORM_KEYS = [
   "scale",
   "scaleX",
   "scaleY",
-  "rotate"
+  "rotate",
+  "rotateX",
+  "rotateY"
 ];
+var ROTATION_KEYS = /* @__PURE__ */ new Set(["rotate", "rotateX", "rotateY"]);
 var NUMERIC_TOP_LEVEL_KEYS = [
   "opacity",
   "width",
@@ -259,6 +1724,8 @@ var DEFAULT_RESTING = {
   scaleX: 1,
   scaleY: 1,
   rotate: 0,
+  rotateX: 0,
+  rotateY: 0,
   opacity: 1,
   width: 0,
   height: 0,
@@ -272,27 +1739,6 @@ var DEFAULT_RESTING = {
   color: "transparent",
   tintColor: "transparent"
 };
-var TRANSITION_KEYS = /* @__PURE__ */ new Set([
-  "type",
-  "tension",
-  "friction",
-  "mass",
-  "velocity",
-  "restSpeedThreshold",
-  "restDisplacementThreshold",
-  "duration",
-  "easing",
-  "delay",
-  "repeat",
-  "deceleration",
-  "clamp"
-]);
-function isTopLevelTransition(t) {
-  if (t === null || typeof t !== "object") return false;
-  const keys = Object.keys(t);
-  if (keys.length === 0) return false;
-  return keys.every((k) => TRANSITION_KEYS.has(k));
-}
 function transitionFor(prop, transition) {
   if (!transition) return void 0;
   if (isTopLevelTransition(transition)) return transition;
@@ -319,6 +1765,7 @@ function createMotionComponent(Component) {
       variants,
       controller,
       gesture,
+      layout,
       onAnimationEnd,
       style,
       ...rest
@@ -522,7 +1969,7 @@ function createMotionComponent(Component) {
         }
         if (TRANSFORM_KEY_SET.has(key)) {
           transform.push(
-            key === "rotate" ? { rotate: `${v}deg` } : { [key]: v }
+            ROTATION_KEYS.has(key) ? { [key]: `${v}deg` } : { [key]: v }
           );
         } else {
           out[key] = v;
@@ -543,12 +1990,19 @@ function createMotionComponent(Component) {
       setFocusVisible,
       setHovered
     );
+    const layoutSig = stableSig(layout);
+    const layoutTransition = useMemo(
+      () => shouldReduceMotion ? void 0 : resolveLayoutTransition(layout),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [layoutSig, shouldReduceMotion]
+    );
     return /* @__PURE__ */ jsx(
       AnimatedComponent,
       {
         ref,
         ...rest,
         ...gestureHandlers,
+        layout: layoutTransition,
         style: mergedStyle
       }
     );
@@ -556,23 +2010,25 @@ function createMotionComponent(Component) {
   Motion.displayName = `Motion(${Component.displayName ?? Component.name ?? "Component"})`;
   return Motion;
 }
-function useAnimatableSharedValues(init) {
-  const translateX = useSharedValue(init("translateX"));
-  const translateY = useSharedValue(init("translateY"));
-  const scale = useSharedValue(init("scale"));
-  const scaleX = useSharedValue(init("scaleX"));
-  const scaleY = useSharedValue(init("scaleY"));
-  const rotate = useSharedValue(init("rotate"));
-  const opacity = useSharedValue(init("opacity"));
-  const width = useSharedValue(init("width"));
-  const height = useSharedValue(init("height"));
-  const borderRadius = useSharedValue(init("borderRadius"));
+function useAnimatableSharedValues(init2) {
+  const translateX = useSharedValue(init2("translateX"));
+  const translateY = useSharedValue(init2("translateY"));
+  const scale = useSharedValue(init2("scale"));
+  const scaleX = useSharedValue(init2("scaleX"));
+  const scaleY = useSharedValue(init2("scaleY"));
+  const rotate = useSharedValue(init2("rotate"));
+  const rotateX = useSharedValue(init2("rotateX"));
+  const rotateY = useSharedValue(init2("rotateY"));
+  const opacity = useSharedValue(init2("opacity"));
+  const width = useSharedValue(init2("width"));
+  const height = useSharedValue(init2("height"));
+  const borderRadius = useSharedValue(init2("borderRadius"));
   const backgroundColor = useSharedValue(
-    init("backgroundColor")
+    init2("backgroundColor")
   );
-  const borderColor = useSharedValue(init("borderColor"));
-  const color = useSharedValue(init("color"));
-  const tintColor = useSharedValue(init("tintColor"));
+  const borderColor = useSharedValue(init2("borderColor"));
+  const color = useSharedValue(init2("color"));
+  const tintColor = useSharedValue(init2("tintColor"));
   const ref = useRef(null);
   if (ref.current === null) {
     ref.current = {
@@ -582,6 +2038,8 @@ function useAnimatableSharedValues(init) {
       scaleX,
       scaleY,
       rotate,
+      rotateX,
+      rotateY,
       opacity,
       width,
       height,
@@ -652,7 +2110,7 @@ function makeKeyCallbackFactory(key, sharedValue, target, onAnimationEndRef, met
   return (rawPhase, step) => {
     const cb = (finished) => {
       "worklet";
-      runOnJS(dispatch)(rawPhase, step, !!finished, sharedValue.value);
+      runOnJS$1(dispatch)(rawPhase, step, !!finished, sharedValue.value);
     };
     return cb;
   };
@@ -718,26 +2176,6 @@ function restValue(v) {
   }
   return void 0;
 }
-function stableSig(value) {
-  if (value === void 0) return "";
-  try {
-    return stableStringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function stableStringify(v) {
-  if (v === null || typeof v !== "object") {
-    if (typeof v === "function" || v === void 0) return "null";
-    return JSON.stringify(v);
-  }
-  if (Array.isArray(v)) {
-    return "[" + v.map(stableStringify).join(",") + "]";
-  }
-  const obj = v;
-  const keys = Object.keys(obj).sort();
-  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
-}
 function resolveGestureLayers(gesture) {
   if (!gesture) return null;
   const out = {};