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

package/dist/gestureLayer/index.mjs

@@ -0,0 +1,1743 @@
+import { createContext, useEffect, useMemo, useCallback, useContext } from 'react';
+import { useSharedValue, useAnimatedStyle, interpolateColor, useReducedMotion, withRepeat, withDelay, withDecay, withTiming, Easing, withSpring } from 'react-native-reanimated';
+import { Platform, TurboModuleRegistry } from 'react-native';
+
+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"
+};
+var MotionConfigContext = createContext(
+  DEFAULT_MOTION_CONFIG
+);
+function useMotionConfig() {
+  return useContext(MotionConfigContext);
+}
+function useShouldReduceMotion() {
+  const { reducedMotion } = useMotionConfig();
+  const osReduced = useReducedMotion();
+  if (reducedMotion === "never") return false;
+  if (reducedMotion === "always") return true;
+  return osReduced;
+}
+
+// ../../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;
+  const fn = isEasingFactory(easing) ? easing.factory() : easing;
+  if (isWorkletFunction(fn)) return fn;
+  const wrapped = (t) => {
+    "worklet";
+    return fn(t);
+  };
+  return wrapped;
+}
+function isEasingFactory(value) {
+  return typeof value === "object" && value !== null && "factory" in value && typeof value.factory === "function";
+}
+
+// src/transitions/spring.ts
+var DEFAULT_SPRING = {
+  tension: 170,
+  friction: 26,
+  mass: 1
+};
+function springToReanimated(t) {
+  "worklet";
+  return {
+    stiffness: t.tension ?? DEFAULT_SPRING.tension,
+    damping: t.friction ?? DEFAULT_SPRING.friction,
+    mass: t.mass ?? DEFAULT_SPRING.mass,
+    velocity: t.velocity,
+    restSpeedThreshold: t.restSpeedThreshold,
+    restDisplacementThreshold: t.restDisplacementThreshold
+  };
+}
+
+// src/transitions/resolve.ts
+var DEFAULT_TIMING_DURATION = 250;
+function buildSpring(cfg, toValue, cb) {
+  return withSpring(toValue, springToReanimated(cfg), cb);
+}
+function buildTiming(cfg, toValue, cb) {
+  return withTiming(
+    toValue,
+    {
+      duration: cfg.duration ?? DEFAULT_TIMING_DURATION,
+      easing: ensureWorkletEasing(cfg.easing) ?? Easing.inOut(Easing.ease)
+    },
+    cb
+  );
+}
+function buildDecay(cfg, cb) {
+  return withDecay(
+    {
+      velocity: cfg.velocity ?? 0,
+      deceleration: cfg.deceleration,
+      clamp: cfg.clamp
+    },
+    cb
+  );
+}
+function buildOne(cfg, toValue, cb) {
+  if (cfg.type === "no-animation") {
+    return toValue;
+  }
+  if (cfg.type === "decay") return buildDecay(cfg, cb);
+  if (cfg.type === "timing") return buildTiming(cfg, toValue, cb);
+  return buildSpring(cfg, toValue, cb);
+}
+function applyRepeat(animation, repeat) {
+  if (repeat === void 0) return animation;
+  if (repeat === "infinite") {
+    return withRepeat(animation, -1, true);
+  }
+  if (typeof repeat === "number") {
+    return withRepeat(animation, repeat, true);
+  }
+  const count = repeat.count === "infinite" ? -1 : repeat.count;
+  const alternate = repeat.alternate ?? true;
+  return withRepeat(animation, count, alternate);
+}
+function applyDelay(animation, delay) {
+  if (!delay || delay <= 0) return animation;
+  return withDelay(delay, animation);
+}
+function resolveTransition(config, toValue, callback) {
+  const cfg = config ?? { type: "spring" };
+  const base = buildOne(cfg, toValue, callback);
+  const repeated = applyRepeat(base, repeatOf(cfg));
+  return applyDelay(repeated, delayOf(cfg));
+}
+function repeatOf(cfg) {
+  if (cfg.type === "no-animation" || cfg.type === "decay") return void 0;
+  return cfg.repeat;
+}
+function delayOf(cfg) {
+  if (cfg.type === "no-animation") return void 0;
+  return cfg.delay;
+}
+
+// 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));
+}
+var modality = "keyboard";
+var installed = false;
+function setKeyboard() {
+  modality = "keyboard";
+}
+function setPointer() {
+  modality = "pointer";
+}
+function ensureInstalled() {
+  if (installed) return;
+  if (Platform.OS !== "web") return;
+  if (typeof document === "undefined") return;
+  document.addEventListener("keydown", setKeyboard, true);
+  document.addEventListener("mousedown", setPointer, true);
+  document.addEventListener("pointerdown", setPointer, true);
+  document.addEventListener("touchstart", setPointer, true);
+  installed = true;
+}
+function isFocusVisible() {
+  if (Platform.OS !== "web") return true;
+  ensureInstalled();
+  return modality === "keyboard";
+}
+
+// src/values/useGesture.ts
+function useGesture(transition) {
+  const pressed = useSharedValue(0);
+  const focused = useSharedValue(0);
+  const focusVisible = useSharedValue(0);
+  const hovered = useSharedValue(0);
+  const shouldReduceMotion = useShouldReduceMotion();
+  const setLayer = useCallback(
+    (sv, layer, target) => {
+      const cfg = shouldReduceMotion ? { type: "no-animation" } : layerTransition(layer, transition) ?? { type: "spring" };
+      sv.value = resolveTransition(cfg, target);
+    },
+    // The transition is intentionally read on every call rather than cooked
+    // into the dep array — a fresh literal each render would otherwise
+    // rebuild the handler bag and break composing consumers that key off
+    // handler identity. `transition` is read inside the callback closure;
+    // shared values are stable so the only dep that matters is the reduce-
+    // motion flag.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [shouldReduceMotion]
+  );
+  const handlers = useMemo(
+    () => ({
+      onPressIn: () => setLayer(pressed, "pressed", 1),
+      onPressOut: () => setLayer(pressed, "pressed", 0),
+      onHoverIn: () => setLayer(hovered, "hovered", 1),
+      onHoverOut: () => setLayer(hovered, "hovered", 0),
+      onFocus: () => {
+        setLayer(focused, "focused", 1);
+        if (isFocusVisible()) setLayer(focusVisible, "focusVisible", 1);
+      },
+      onBlur: () => {
+        setLayer(focused, "focused", 0);
+        setLayer(focusVisible, "focusVisible", 0);
+      }
+    }),
+    [setLayer, pressed, focused, focusVisible, hovered]
+  );
+  return { pressed, focused, focusVisible, hovered, handlers };
+}
+function layerTransition(layer, transition) {
+  if (!transition) return void 0;
+  if (isTopLevelTransition(transition)) return transition;
+  return transition[layer];
+}
+
+// src/gestureLayer/useGestureLayer.ts
+function useGestureLayer(states, options = {}) {
+  const { disabled: isDisabled = false, transition } = options;
+  const shouldReduceMotion = useShouldReduceMotion();
+  const gesture = useGesture(transition);
+  const disabledProgress = useSharedValue(0);
+  useEffect(() => {
+    const target = isDisabled ? 1 : 0;
+    const cfg = shouldReduceMotion ? { type: "no-animation" } : disabledTransition(transition) ?? { type: "spring" };
+    disabledProgress.value = resolveTransition(cfg, target);
+  }, [isDisabled, shouldReduceMotion, transition, disabledProgress]);
+  const meta = useMemo(() => {
+    const layers = {
+      rest: states.rest,
+      hovered: states.hovered,
+      focused: states.focused,
+      focusVisible: states.focusVisible,
+      pressed: states.pressed,
+      disabled: states.disabled
+    };
+    const sources = [
+      layers.rest,
+      layers.hovered,
+      layers.focused,
+      layers.focusVisible,
+      layers.pressed,
+      layers.disabled
+    ];
+    const keySet = /* @__PURE__ */ new Set();
+    for (const src of sources) {
+      if (!src) continue;
+      for (const k in src) if (src[k] !== void 0) keySet.add(k);
+    }
+    const keys = Array.from(keySet);
+    const types = {};
+    const restValues = {};
+    for (const k of keys) {
+      let firstDefined;
+      for (const src of sources) {
+        if (src && src[k] !== void 0) {
+          firstDefined = src[k];
+          break;
+        }
+      }
+      const isColor = typeof firstDefined === "string";
+      types[k] = isColor ? "color" : "number";
+      const restRaw = layers.rest ? layers.rest[k] : void 0;
+      restValues[k] = restRaw !== void 0 ? restRaw : isColor ? "transparent" : 0;
+    }
+    return { layers, keys, types, restValues };
+  }, [
+    states.rest,
+    states.hovered,
+    states.focused,
+    states.focusVisible,
+    states.pressed,
+    states.disabled
+  ]);
+  const style = useAnimatedStyle(() => {
+    const { layers, keys, types, restValues } = meta;
+    const ph = gesture.hovered.value;
+    const pf = gesture.focused.value;
+    const pfv = gesture.focusVisible.value;
+    const pp = gesture.pressed.value;
+    const pd = disabledProgress.value;
+    const hoveredLayer = layers.hovered;
+    const focusedLayer = layers.focused;
+    const focusVisibleLayer = layers.focusVisible;
+    const pressedLayer = layers.pressed;
+    const disabledLayer = layers.disabled;
+    const out = {};
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      const isColor = types[k] === "color";
+      const rest = restValues[k];
+      if (isColor) {
+        let v = rest;
+        if (hoveredLayer && ph > 0 && hoveredLayer[k] !== void 0) {
+          v = interpolateColor(ph, [0, 1], [v, hoveredLayer[k]]);
+        }
+        if (focusedLayer && pf > 0 && focusedLayer[k] !== void 0) {
+          v = interpolateColor(pf, [0, 1], [v, focusedLayer[k]]);
+        }
+        if (focusVisibleLayer && pfv > 0 && focusVisibleLayer[k] !== void 0) {
+          v = interpolateColor(pfv, [0, 1], [v, focusVisibleLayer[k]]);
+        }
+        if (pressedLayer && pp > 0 && pressedLayer[k] !== void 0) {
+          v = interpolateColor(pp, [0, 1], [v, pressedLayer[k]]);
+        }
+        if (disabledLayer && pd > 0 && disabledLayer[k] !== void 0) {
+          v = interpolateColor(pd, [0, 1], [v, disabledLayer[k]]);
+        }
+        out[k] = v;
+      } else {
+        const base = rest;
+        let m = base;
+        if (hoveredLayer && ph > 0 && hoveredLayer[k] !== void 0) {
+          const c = base + (hoveredLayer[k] - base) * ph;
+          if (c > m) m = c;
+        }
+        if (focusedLayer && pf > 0 && focusedLayer[k] !== void 0) {
+          const c = base + (focusedLayer[k] - base) * pf;
+          if (c > m) m = c;
+        }
+        if (focusVisibleLayer && pfv > 0 && focusVisibleLayer[k] !== void 0) {
+          const c = base + (focusVisibleLayer[k] - base) * pfv;
+          if (c > m) m = c;
+        }
+        if (pressedLayer && pp > 0 && pressedLayer[k] !== void 0) {
+          const c = base + (pressedLayer[k] - base) * pp;
+          if (c > m) m = c;
+        }
+        if (disabledLayer && pd > 0 && disabledLayer[k] !== void 0) {
+          m = m + (disabledLayer[k] - m) * pd;
+        }
+        out[k] = m;
+      }
+    }
+    return out;
+  });
+  return {
+    style,
+    handlers: gesture.handlers
+  };
+}
+function disabledTransition(transition) {
+  if (!transition) return void 0;
+  if (isTopLevelTransition(transition)) return transition;
+  return void 0;
+}
+
+export { useGestureLayer };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map