@onlynative/inertia 0.0.1-alpha.7 → 0.0.1-alpha.9

package/dist/motion/View.js

@@ -3,25 +3,14 @@
 var reactNative = require('react-native');
 var react = require('react');
 var Animated = require('react-native-reanimated');
+var reactNativeWorklets = require('react-native-worklets');
 var jsxRuntime = require('react/jsx-runtime');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var Animated__default = /*#__PURE__*/_interopDefault(Animated);
 
-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);
+// src/motion/View.tsx
 var DEFAULT_MOTION_CONFIG = {
   reducedMotion: "user"
 };
@@ -61,1398 +50,10 @@ function isFocusVisible() {
   ensureInstalled();
   return modality === "keyboard";
 }
-
-// ../../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 = reactNative.Platform.OS === "web";
-var IS_WINDOWS = reactNative.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 = reactNative.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;
   const fn = isEasingFactory(easing) ? easing.factory() : easing;
-  if (isWorkletFunction(fn)) return fn;
+  if (reactNativeWorklets.isWorkletFunction(fn)) return fn;
   const wrapped = (t) => {
     "worklet";
     return fn(t);
@@ -1502,6 +103,157 @@ function resolveLayoutTransition(layout) {
   if ("delay" in spring && spring.delay) builder = builder.delay(spring.delay);
   return builder;
 }
+
+// src/layout/sharedRegistry.ts
+var REGISTRY = /* @__PURE__ */ new Map();
+var SHARED_LAYOUT_TTL_MS = 1e3;
+var now = () => Date.now();
+function registerLayout(id, rect) {
+  REGISTRY.set(id, { rect, expiresAt: now() + SHARED_LAYOUT_TTL_MS });
+}
+function releaseLayout(id, rect) {
+  REGISTRY.set(id, { rect, expiresAt: now() + SHARED_LAYOUT_TTL_MS });
+}
+function consumeLayout(id) {
+  const entry = REGISTRY.get(id);
+  if (!entry) return void 0;
+  REGISTRY.delete(id);
+  if (entry.expiresAt < now()) return void 0;
+  return entry.rect;
+}
+function useSharedLayout(options) {
+  const { layoutId, userRef, transition, shouldReduceMotion, userOnLayout } = options;
+  const dx = Animated.useSharedValue(0);
+  const dy = Animated.useSharedValue(0);
+  const sx = Animated.useSharedValue(1);
+  const sy = Animated.useSharedValue(1);
+  const lastRectRef = react.useRef(null);
+  const consumedRef = react.useRef(false);
+  const transitionRef = react.useRef(transition);
+  transitionRef.current = transition;
+  const reducedMotionRef = react.useRef(shouldReduceMotion);
+  reducedMotionRef.current = shouldReduceMotion;
+  const setRef = react.useCallback(
+    (node) => {
+      if (typeof userRef === "function") userRef(node);
+      else if (userRef) userRef.current = node;
+    },
+    [userRef]
+  );
+  const onLayout = react.useCallback(
+    (event) => {
+      userOnLayout?.(event);
+      if (!layoutId) return;
+      const { x, y, width, height } = event.nativeEvent.layout;
+      const rect = { x, y, width, height };
+      lastRectRef.current = rect;
+      let source;
+      if (!consumedRef.current) {
+        consumedRef.current = true;
+        source = consumeLayout(layoutId);
+      }
+      registerLayout(layoutId, rect);
+      if (source) {
+        applyFlip({
+          source,
+          target: rect,
+          dx,
+          dy,
+          sx,
+          sy,
+          transition: transitionRef.current,
+          shouldReduceMotion: reducedMotionRef.current
+        });
+      }
+    },
+    // dx/dy/sx/sy are stable refs from useSharedValue, but eslint's
+    // exhaustive-deps would flag them — including them is harmless and
+    // silences the warning.
+    [layoutId, userOnLayout, dx, dy, sx, sy]
+  );
+  react.useEffect(() => {
+    consumedRef.current = false;
+  }, [layoutId]);
+  react.useEffect(() => {
+    return () => {
+      if (!layoutId) return;
+      const rect = lastRectRef.current;
+      if (!rect) return;
+      releaseLayout(layoutId, rect);
+    };
+  }, [layoutId]);
+  return react.useMemo(
+    () => ({
+      flip: { dx, dy, sx, sy },
+      setRef,
+      onLayout
+    }),
+    [dx, dy, sx, sy, setRef, onLayout]
+  );
+}
+function applyFlip(args) {
+  const { source, target, dx, dy, sx, sy, transition, shouldReduceMotion } = args;
+  const sourceCenterX = source.x + source.width / 2;
+  const sourceCenterY = source.y + source.height / 2;
+  const targetCenterX = target.x + target.width / 2;
+  const targetCenterY = target.y + target.height / 2;
+  const deltaX = sourceCenterX - targetCenterX;
+  const deltaY = sourceCenterY - targetCenterY;
+  const scaleX = target.width > 0 ? source.width / target.width : 1;
+  const scaleY = target.height > 0 ? source.height / target.height : 1;
+  if (shouldReduceMotion) {
+    dx.value = 0;
+    dy.value = 0;
+    sx.value = 1;
+    sy.value = 1;
+    return;
+  }
+  if (transition?.type === "no-animation") {
+    dx.value = 0;
+    dy.value = 0;
+    sx.value = 1;
+    sy.value = 1;
+    return;
+  }
+  if (transition?.type === "timing") {
+    const duration = transition.duration ?? 300;
+    dx.value = Animated.withSequence(
+      Animated.withTiming(deltaX, { duration: 0 }),
+      Animated.withTiming(0, { duration })
+    );
+    dy.value = Animated.withSequence(
+      Animated.withTiming(deltaY, { duration: 0 }),
+      Animated.withTiming(0, { duration })
+    );
+    sx.value = Animated.withSequence(
+      Animated.withTiming(scaleX, { duration: 0 }),
+      Animated.withTiming(1, { duration })
+    );
+    sy.value = Animated.withSequence(
+      Animated.withTiming(scaleY, { duration: 0 }),
+      Animated.withTiming(1, { duration })
+    );
+    return;
+  }
+  const springCfg = transition?.type === "spring" ? { ...DEFAULT_SPRING, ...transition } : { ...DEFAULT_SPRING };
+  const springParams = springToReanimated(springCfg);
+  dx.value = Animated.withSequence(
+    Animated.withTiming(deltaX, { duration: 0 }),
+    Animated.withSpring(0, springParams)
+  );
+  dy.value = Animated.withSequence(
+    Animated.withTiming(deltaY, { duration: 0 }),
+    Animated.withSpring(0, springParams)
+  );
+  sx.value = Animated.withSequence(
+    Animated.withTiming(scaleX, { duration: 0 }),
+    Animated.withSpring(1, springParams)
+  );
+  sy.value = Animated.withSequence(
+    Animated.withTiming(scaleY, { duration: 0 }),
+    Animated.withSpring(1, springParams)
+  );
+}
 var PresenceContext = react.createContext(null);
 function usePresence() {
   return react.useContext(PresenceContext);
@@ -1656,8 +408,6 @@ function stableStringify(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() {
   if (!__DEV__ || alreadyChecked) return;
@@ -1665,12 +415,7 @@ function ensureReanimatedInstalled() {
     return;
   }
   alreadyChecked = true;
-  let version;
-  try {
-    const pkg = __require("react-native-reanimated/package.json");
-    version = pkg.version;
-  } catch {
-  }
+  const version = Animated.reanimatedVersion;
   if (version) {
     const major = parseInt(version.split(".")[0] ?? "0", 10);
     if (major < 4) {
@@ -1790,10 +535,17 @@ function createMotionComponent(Component) {
       controller,
       gesture,
       layout,
+      layoutId,
       onAnimationEnd,
       style,
+      onLayout: userOnLayout,
       ...rest
     } = props;
+    if (__DEV__ && typeof style === "function") {
+      throw new Error(
+        "[inertia] `style` must be a style object or array of style objects, not a function. The function-form `style={(state) => ...}` Pressable API is not supported \u2014 use `gesture.pressed` (or `gesture.focused`, etc.) to drive state-dependent styling instead."
+      );
+    }
     const presence = usePresence();
     const isExiting = presence !== null && presence.isPresent === false;
     const shouldReduceMotion = useShouldReduceMotion();
@@ -1812,37 +564,51 @@ function createMotionComponent(Component) {
     const [focused, setFocused] = react.useState(false);
     const [focusVisible, setFocusVisible] = react.useState(false);
     const [hovered, setHovered] = react.useState(false);
-    const activeKeysRef = react.useRef(null);
-    if (activeKeysRef.current === null) {
-      const touched = /* @__PURE__ */ new Set();
-      collectTouchedKeys(touched, animateRecord);
-      if (initialRecord) collectTouchedKeys(touched, initialRecord);
-      if (variants) {
-        for (const variant of Object.values(variants)) {
-          if (!variant) continue;
-          collectTouchedKeys(touched, variant);
-        }
+    const touched = /* @__PURE__ */ new Set();
+    collectTouchedKeys(touched, animateRecord);
+    if (initialRecord) collectTouchedKeys(touched, initialRecord);
+    if (variants) {
+      for (const variant of Object.values(variants)) {
+        if (!variant) continue;
+        collectTouchedKeys(touched, variant);
       }
-      if (gesture) {
-        for (const subState of [
-          gesture.pressed,
-          gesture.focused,
-          gesture.focusVisible,
-          gesture.hovered
-        ]) {
-          if (!subState) continue;
-          collectTouchedKeys(touched, subState);
+    }
+    if (gesture) {
+      for (const subState of [
+        gesture.pressed,
+        gesture.focused,
+        gesture.focusVisible,
+        gesture.hovered
+      ]) {
+        if (!subState) continue;
+        collectTouchedKeys(touched, subState);
+      }
+    }
+    if (exitRecord) collectTouchedKeys(touched, exitRecord);
+    const activeKeysRef = react.useRef(null);
+    const hasTransformRef = react.useRef(false);
+    const hasShadowOffsetRef = react.useRef(false);
+    const prevActive = activeKeysRef.current;
+    let grew = prevActive === null;
+    if (!grew && prevActive) {
+      for (const k of touched) {
+        if (!prevActive.includes(k)) {
+          grew = true;
+          break;
         }
       }
-      if (exitRecord) collectTouchedKeys(touched, exitRecord);
-      activeKeysRef.current = ALL_KEYS.filter((k) => touched.has(k));
     }
-    const hasTransformRef = react.useRef(
-      activeKeysRef.current.some((k) => TRANSFORM_KEY_SET.has(k))
-    );
-    const hasShadowOffsetRef = react.useRef(
-      activeKeysRef.current.some((k) => SHADOW_OFFSET_KEY_SET.has(k))
-    );
+    if (grew) {
+      const merged = new Set(prevActive ?? []);
+      for (const k of touched) merged.add(k);
+      activeKeysRef.current = ALL_KEYS.filter((k) => merged.has(k));
+      hasTransformRef.current = activeKeysRef.current.some(
+        (k) => TRANSFORM_KEY_SET.has(k)
+      );
+      hasShadowOffsetRef.current = activeKeysRef.current.some(
+        (k) => SHADOW_OFFSET_KEY_SET.has(k)
+      );
+    }
     const sharedValues = useAnimatableSharedValues((key) => {
       if (SHADOW_OFFSET_KEY_SET.has(key)) {
         const axis = shadowOffsetAxisFor(key);
@@ -1967,6 +733,15 @@ function createMotionComponent(Component) {
       isExiting,
       shouldReduceMotion
     );
+    const sharedLayout = useSharedLayout({
+      layoutId,
+      userRef: ref,
+      transition: isTopLevelTransition(transition) ? transition : void 0,
+      shouldReduceMotion,
+      userOnLayout
+    });
+    const flip = sharedLayout.flip;
+    const hasLayoutId = layoutId !== void 0;
     const animatedStyle = Animated.useAnimatedStyle(() => {
       const activeKeys = activeKeysRef.current;
       const hasTransform = hasTransformRef.current;
@@ -2015,7 +790,13 @@ function createMotionComponent(Component) {
           out[key] = v;
         }
       }
-      if (hasTransform) out.transform = transform;
+      if (hasLayoutId) {
+        transform.push({ translateX: flip.dx.value });
+        transform.push({ translateY: flip.dy.value });
+        transform.push({ scaleX: flip.sx.value });
+        transform.push({ scaleY: flip.sy.value });
+      }
+      if (hasTransform || hasLayoutId) out.transform = transform;
       if (hasShadowOffset) {
         out.shadowOffset = { width: shadowOffsetW, height: shadowOffsetH };
       }
@@ -2042,9 +823,10 @@ function createMotionComponent(Component) {
     return /* @__PURE__ */ jsxRuntime.jsx(
       AnimatedComponent,
       {
-        ref,
+        ref: sharedLayout.setRef,
         ...rest,
         ...gestureHandlers,
+        onLayout: sharedLayout.onLayout,
         layout: layoutTransition,
         style: mergedStyle
       }
@@ -2053,34 +835,34 @@ function createMotionComponent(Component) {
   Motion.displayName = `Motion(${Component.displayName ?? Component.name ?? "Component"})`;
   return Motion;
 }
-function useAnimatableSharedValues(init2) {
-  const translateX = Animated.useSharedValue(init2("translateX"));
-  const translateY = Animated.useSharedValue(init2("translateY"));
-  const scale = Animated.useSharedValue(init2("scale"));
-  const scaleX = Animated.useSharedValue(init2("scaleX"));
-  const scaleY = Animated.useSharedValue(init2("scaleY"));
-  const rotate = Animated.useSharedValue(init2("rotate"));
-  const rotateX = Animated.useSharedValue(init2("rotateX"));
-  const rotateY = Animated.useSharedValue(init2("rotateY"));
-  const opacity = Animated.useSharedValue(init2("opacity"));
-  const width = Animated.useSharedValue(init2("width"));
-  const height = Animated.useSharedValue(init2("height"));
-  const borderRadius = Animated.useSharedValue(init2("borderRadius"));
-  const shadowOpacity = Animated.useSharedValue(init2("shadowOpacity"));
-  const shadowRadius = Animated.useSharedValue(init2("shadowRadius"));
-  const elevation = Animated.useSharedValue(init2("elevation"));
+function useAnimatableSharedValues(init) {
+  const translateX = Animated.useSharedValue(init("translateX"));
+  const translateY = Animated.useSharedValue(init("translateY"));
+  const scale = Animated.useSharedValue(init("scale"));
+  const scaleX = Animated.useSharedValue(init("scaleX"));
+  const scaleY = Animated.useSharedValue(init("scaleY"));
+  const rotate = Animated.useSharedValue(init("rotate"));
+  const rotateX = Animated.useSharedValue(init("rotateX"));
+  const rotateY = Animated.useSharedValue(init("rotateY"));
+  const opacity = Animated.useSharedValue(init("opacity"));
+  const width = Animated.useSharedValue(init("width"));
+  const height = Animated.useSharedValue(init("height"));
+  const borderRadius = Animated.useSharedValue(init("borderRadius"));
+  const shadowOpacity = Animated.useSharedValue(init("shadowOpacity"));
+  const shadowRadius = Animated.useSharedValue(init("shadowRadius"));
+  const elevation = Animated.useSharedValue(init("elevation"));
   const backgroundColor = Animated.useSharedValue(
-    init2("backgroundColor")
+    init("backgroundColor")
   );
-  const borderColor = Animated.useSharedValue(init2("borderColor"));
-  const color = Animated.useSharedValue(init2("color"));
-  const tintColor = Animated.useSharedValue(init2("tintColor"));
-  const shadowColor = Animated.useSharedValue(init2("shadowColor"));
+  const borderColor = Animated.useSharedValue(init("borderColor"));
+  const color = Animated.useSharedValue(init("color"));
+  const tintColor = Animated.useSharedValue(init("tintColor"));
+  const shadowColor = Animated.useSharedValue(init("shadowColor"));
   const shadowOffsetWidth = Animated.useSharedValue(
-    init2("shadowOffsetWidth")
+    init("shadowOffsetWidth")
   );
   const shadowOffsetHeight = Animated.useSharedValue(
-    init2("shadowOffsetHeight")
+    init("shadowOffsetHeight")
   );
   const ref = react.useRef(null);
   if (ref.current === null) {