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

package/dist/index.js

@@ -9,7 +9,19 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var Animated__default = /*#__PURE__*/_interopDefault(Animated);
 
-// src/motion/Image.tsx
+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"
 };
@@ -36,28 +48,1464 @@ function MotionConfig({
   );
   return /* @__PURE__ */ jsxRuntime.jsx(MotionConfigContext.Provider, { value, children });
 }
-var modality = "keyboard";
-var installed = false;
-function setKeyboard() {
-  modality = "keyboard";
+var modality = "keyboard";
+var installed = false;
+function setKeyboard() {
+  modality = "keyboard";
+}
+function setPointer() {
+  modality = "pointer";
+}
+function ensureInstalled() {
+  if (installed) return;
+  if (reactNative.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 (reactNative.Platform.OS !== "web") return true;
+  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 setPointer() {
-  modality = "pointer";
+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();
+  })();
 }
-function ensureInstalled() {
-  if (installed) return;
-  if (reactNative.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;
+
+// ../../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");
+  }
 }
-function isFocusVisible() {
-  if (reactNative.Platform.OS !== "web") return true;
-  ensureInstalled();
-  return modality === "keyboard";
+bundleModeInit();
+
+// ../../node_modules/react-native-worklets/lib/module/featureFlags/index.js
+var DynamicFlags = {
+  EXAMPLE_DYNAMIC_FLAG: true,
+  init() {
+    Object.keys(DynamicFlags).forEach((key) => {
+      if (key !== "init" && key !== "setFlag") {
+        WorkletsModule.setDynamicFeatureFlag(key, DynamicFlags[key]);
+      }
+    });
+  },
+  setFlag(name, value) {
+    if (name in DynamicFlags) {
+      DynamicFlags[name] = value;
+      WorkletsModule.setDynamicFeatureFlag(name, value);
+    } else {
+      logger.warn(`The feature flag: '${name}' no longer exists, you can safely remove invocation of \`setDynamicFeatureFlag('${name}')\` from your code.`);
+    }
+  }
+};
+DynamicFlags.init();
+
+// ../../node_modules/react-native-worklets/lib/module/index.js
+init();
+if (globalThis._ALWAYS_FALSE) {
+  bundleModeInit();
+}
+
+// src/transitions/easing.ts
+function ensureWorkletEasing(easing) {
+  if (!easing) return void 0;
+  if (isWorkletFunction(easing)) return easing;
+  const wrapped = (t) => {
+    "worklet";
+    return easing(t);
+  };
+  return wrapped;
+}
+
+// src/transitions/spring.ts
+var DEFAULT_SPRING = {
+  tension: 170,
+  friction: 26,
+  mass: 1
+};
+function springToReanimated(t) {
+  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/layout/resolveLayout.ts
+function resolveLayoutTransition(layout) {
+  if (!layout) return void 0;
+  const cfg = layout === true ? { type: "spring" } : layout;
+  if (cfg.type === "no-animation") return void 0;
+  if (cfg.type === "timing") {
+    let builder2 = Animated.LinearTransition.duration(cfg.duration ?? 300);
+    const easing = ensureWorkletEasing(cfg.easing);
+    if (easing) builder2 = builder2.easing(easing);
+    if (cfg.delay) builder2 = builder2.delay(cfg.delay);
+    return builder2;
+  }
+  const spring = cfg.type === "decay" ? { type: "spring" } : cfg;
+  const { stiffness, damping, mass } = springToReanimated({
+    ...DEFAULT_SPRING,
+    ...spring
+  });
+  let builder = Animated.LinearTransition.springify().stiffness(stiffness).damping(damping).mass(mass);
+  if ("delay" in spring && spring.delay) builder = builder.delay(spring.delay);
+  return builder;
 }
 var PresenceContext = react.createContext(null);
 function usePresence() {
@@ -154,33 +1602,7 @@ function PresenceItem({
   );
   return /* @__PURE__ */ jsxRuntime.jsx(PresenceContext.Provider, { value, children });
 }
-function ensureWorkletEasing(easing) {
-  if (!easing) return void 0;
-  if (Animated.isWorkletFunction(easing)) return easing;
-  const wrapped = (t) => {
-    "worklet";
-    return easing(t);
-  };
-  return wrapped;
-}
-
-// src/transitions/resolve.ts
-var DEFAULT_SPRING = {
-  tension: 170,
-  friction: 26,
-  mass: 1
-};
 var DEFAULT_TIMING_DURATION = 250;
-function springToReanimated(t) {
-  return {
-    stiffness: t.tension ?? DEFAULT_SPRING.tension,
-    damping: t.friction ?? DEFAULT_SPRING.friction,
-    mass: t.mass ?? DEFAULT_SPRING.mass,
-    velocity: t.velocity,
-    restSpeedThreshold: t.restSpeedThreshold,
-    restDisplacementThreshold: t.restDisplacementThreshold
-  };
-}
 function buildSpring(cfg, toValue, cb) {
   return Animated.withSpring(toValue, springToReanimated(cfg), cb);
 }
@@ -285,14 +1707,96 @@ function mergeTransition(base, override) {
   }
   return { ...base ?? { type: "spring" }, ...override };
 }
+
+// src/transitions/keys.ts
+var TRANSITION_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "tension",
+  "friction",
+  "mass",
+  "velocity",
+  "restSpeedThreshold",
+  "restDisplacementThreshold",
+  "duration",
+  "easing",
+  "delay",
+  "repeat",
+  "deceleration",
+  "clamp"
+]);
+function isTopLevelTransition(t) {
+  if (t === null || typeof t !== "object") return false;
+  const keys = Object.keys(t);
+  if (keys.length === 0) return false;
+  return keys.every((k) => TRANSITION_CONFIG_KEYS.has(k));
+}
+
+// src/transitions/sig.ts
+function stableSig(value) {
+  if (value === void 0) return "";
+  try {
+    return stableStringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function stableStringify(v) {
+  if (v === null || typeof v !== "object") {
+    if (typeof v === "function" || v === void 0) return "null";
+    return JSON.stringify(v);
+  }
+  if (Array.isArray(v)) {
+    return "[" + v.map(stableStringify).join(",") + "]";
+  }
+  const obj = v;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+}
+
+// src/motion/installCheck.ts
+var alreadyChecked = false;
+function ensureReanimatedInstalled() {
+  if (!__DEV__ || alreadyChecked) return;
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "test") {
+    return;
+  }
+  alreadyChecked = true;
+  let version;
+  try {
+    const pkg = __require("react-native-reanimated/package.json");
+    version = pkg.version;
+  } catch {
+  }
+  if (version) {
+    const major = parseInt(version.split(".")[0] ?? "0", 10);
+    if (major < 4) {
+      console.error(
+        `[inertia] react-native-reanimated v${version} is installed, but @onlynative/inertia requires v4.0.0 or later. Upgrade with \`pnpm add react-native-reanimated@^4\` (or your package manager's equivalent).`
+      );
+      return;
+    }
+  }
+  const probe = function probe2() {
+    "worklet";
+    return 0;
+  };
+  if (typeof probe.__workletHash !== "number") {
+    console.error(
+      `[inertia] The Reanimated worklets babel plugin is not configured. Add \`'react-native-worklets/plugin'\` as the LAST entry in the \`plugins\` array of your \`babel.config.js\`, then restart Metro with a fresh cache: \`npx expo start -c\` or \`npx react-native start --reset-cache\`.`
+    );
+  }
+}
 var TRANSFORM_KEYS = [
   "translateX",
   "translateY",
   "scale",
   "scaleX",
   "scaleY",
-  "rotate"
+  "rotate",
+  "rotateX",
+  "rotateY"
 ];
+var ROTATION_KEYS = /* @__PURE__ */ new Set(["rotate", "rotateX", "rotateY"]);
 var NUMERIC_TOP_LEVEL_KEYS = [
   "opacity",
   "width",
@@ -311,6 +1815,14 @@ var ALL_KEYS = [
   ...COLOR_KEYS
 ];
 var TRANSFORM_KEY_SET = new Set(TRANSFORM_KEYS);
+var COLOR_KEY_SET = new Set(COLOR_KEYS);
+var GESTURE_LAYER_NAMES = [
+  "hovered",
+  "focused",
+  "focusVisible",
+  "pressed"
+];
+var GESTURE_LAYER_NAME_SET = new Set(GESTURE_LAYER_NAMES);
 var EXITING_POINTER_EVENTS_STYLE = { pointerEvents: "none" };
 var DEFAULT_RESTING = {
   translateX: 0,
@@ -319,6 +1831,8 @@ var DEFAULT_RESTING = {
   scaleX: 1,
   scaleY: 1,
   rotate: 0,
+  rotateX: 0,
+  rotateY: 0,
   opacity: 1,
   width: 0,
   height: 0,
@@ -332,34 +1846,21 @@ var DEFAULT_RESTING = {
   color: "transparent",
   tintColor: "transparent"
 };
-var TRANSITION_KEYS = /* @__PURE__ */ new Set([
-  "type",
-  "tension",
-  "friction",
-  "mass",
-  "velocity",
-  "restSpeedThreshold",
-  "restDisplacementThreshold",
-  "duration",
-  "easing",
-  "delay",
-  "repeat",
-  "deceleration",
-  "clamp"
-]);
-function isTopLevelTransition(t) {
-  if (t === null || typeof t !== "object") return false;
-  const keys = Object.keys(t);
-  if (keys.length === 0) return false;
-  return keys.every((k) => TRANSITION_KEYS.has(k));
-}
 function transitionFor(prop, transition) {
   if (!transition) return void 0;
   if (isTopLevelTransition(transition)) return transition;
+  if (GESTURE_LAYER_NAME_SET.has(prop)) return void 0;
   return transition[prop];
 }
+function gestureLayerTransitionFor(layer, transition) {
+  if (!transition) return void 0;
+  if (isTopLevelTransition(transition)) return transition;
+  return transition[layer];
+}
 function createMotionComponent(Component) {
+  ensureReanimatedInstalled();
   const AnimatedComponent = Animated__default.default.createAnimatedComponent(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     Component
   );
   const Motion2 = react.forwardRef(function Motion3(props, ref) {
@@ -371,6 +1872,7 @@ function createMotionComponent(Component) {
       variants,
       controller,
       gesture,
+      layout,
       onAnimationEnd,
       style,
       ...rest
@@ -438,13 +1940,19 @@ function createMotionComponent(Component) {
       }
       return initialRecord?.[key] ?? restValue(animateRecord[key]) ?? DEFAULT_RESTING[key];
     });
-    const mergedRecord = isExiting && exitRecord ? { ...animateRecord, ...exitRecord } : mergeGestureTargets(animateRecord, gesture, {
-      pressed,
-      focused,
-      focusVisible,
-      hovered
-    });
-    const mergedSig = stableSig(mergedRecord) + (isExiting ? "|exit" : "") + (shouldReduceMotion ? "|rm" : "");
+    const pressedProgress = Animated.useSharedValue(0);
+    const focusedProgress = Animated.useSharedValue(0);
+    const focusVisibleProgress = Animated.useSharedValue(0);
+    const hoveredProgress = Animated.useSharedValue(0);
+    const gestureSV = Animated.useSharedValue(
+      resolveGestureLayers(gesture)
+    );
+    const gestureTargetsSig = stableSig(gesture);
+    react.useEffect(() => {
+      gestureSV.value = resolveGestureLayers(gesture);
+    }, [gestureTargetsSig]);
+    const baseRecord = isExiting && exitRecord ? { ...animateRecord, ...exitRecord } : animateRecord;
+    const baseSig = stableSig(baseRecord) + (isExiting ? "|exit" : "") + (shouldReduceMotion ? "|rm" : "");
     const transitionSig = stableSig(transition);
     const safeToRemoveRef = react.useRef(void 0);
     safeToRemoveRef.current = presence?.safeToRemove;
@@ -465,13 +1973,13 @@ function createMotionComponent(Component) {
       };
       let transformPending = 0;
       for (const k of ALL_KEYS) {
-        if (TRANSFORM_KEY_SET.has(k) && mergedRecord[k] !== void 0) {
+        if (TRANSFORM_KEY_SET.has(k) && baseRecord[k] !== void 0) {
           transformPending++;
         }
       }
       const transformGroup = transformPending > 0 ? { remaining: transformPending } : void 0;
       for (const key of ALL_KEYS) {
-        const target = mergedRecord[key];
+        const target = baseRecord[key];
         if (target === void 0) continue;
         const cfg = shouldReduceMotion ? { type: "no-animation" } : transitionFor(key, transition);
         if (isExiting) pending++;
@@ -496,17 +2004,79 @@ function createMotionComponent(Component) {
       if (isExiting && pending === 0) {
         safeToRemoveRef.current?.();
       }
-    }, [mergedSig, transitionSig]);
+    }, [baseSig, transitionSig]);
+    useGestureLayerProgress(
+      pressedProgress,
+      pressed,
+      gesture?.pressed != null,
+      "pressed",
+      transition,
+      isExiting,
+      shouldReduceMotion
+    );
+    useGestureLayerProgress(
+      focusedProgress,
+      focused,
+      gesture?.focused != null,
+      "focused",
+      transition,
+      isExiting,
+      shouldReduceMotion
+    );
+    useGestureLayerProgress(
+      focusVisibleProgress,
+      focusVisible,
+      gesture?.focusVisible != null,
+      "focusVisible",
+      transition,
+      isExiting,
+      shouldReduceMotion
+    );
+    useGestureLayerProgress(
+      hoveredProgress,
+      hovered,
+      gesture?.hovered != null,
+      "hovered",
+      transition,
+      isExiting,
+      shouldReduceMotion
+    );
     const animatedStyle = Animated.useAnimatedStyle(() => {
       const activeKeys = activeKeysRef.current;
       const hasTransform = hasTransformRef.current;
       const out = {};
       const transform = [];
+      const ph = hoveredProgress.value;
+      const pf = focusedProgress.value;
+      const pfv = focusVisibleProgress.value;
+      const pp = pressedProgress.value;
+      const layers = gestureSV.value;
+      const hoveredLayer = layers ? layers.hovered : null;
+      const focusedLayer = layers ? layers.focused : null;
+      const focusVisibleLayer = layers ? layers.focusVisible : null;
+      const pressedLayer = layers ? layers.pressed : null;
       for (const key of activeKeys) {
-        const v = sharedValues[key].value;
+        let v = sharedValues[key].value;
+        const isColor = COLOR_KEY_SET.has(key);
+        if (hoveredLayer && ph > 0 && hoveredLayer[key] !== void 0) {
+          const t = hoveredLayer[key];
+          v = isColor ? Animated.interpolateColor(ph, [0, 1], [v, t]) : v + (t - v) * ph;
+        }
+        if (focusedLayer && pf > 0 && focusedLayer[key] !== void 0) {
+          const t = focusedLayer[key];
+          v = isColor ? Animated.interpolateColor(pf, [0, 1], [v, t]) : v + (t - v) * pf;
+        }
+        if (focusVisibleLayer && pfv > 0 && focusVisibleLayer[key] !== void 0) {
+          const t = focusVisibleLayer[key];
+          v = isColor ? Animated.interpolateColor(pfv, [0, 1], [v, t]) : v + (t - v) * pfv;
+        }
+        if (pressedLayer && pp > 0 && pressedLayer[key] !== void 0) {
+          const t = pressedLayer[key];
+          v = isColor ? Animated.interpolateColor(pp, [0, 1], [v, t]) : v + (t - v) * pp;
+        }
         if (TRANSFORM_KEY_SET.has(key)) {
           transform.push(
-            key === "rotate" ? { rotate: `${v}deg` } : { [key]: v }
+            ROTATION_KEYS.has(key) ? { [key]: `${v}deg` } : { [key]: v }
           );
         } else {
           out[key] = v;
@@ -527,12 +2097,19 @@ function createMotionComponent(Component) {
       setFocusVisible,
       setHovered
     );
+    const layoutSig = stableSig(layout);
+    const layoutTransition = react.useMemo(
+      () => shouldReduceMotion ? void 0 : resolveLayoutTransition(layout),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [layoutSig, shouldReduceMotion]
+    );
     return /* @__PURE__ */ jsxRuntime.jsx(
       AnimatedComponent,
       {
         ref,
         ...rest,
         ...gestureHandlers,
+        layout: layoutTransition,
         style: mergedStyle
       }
     );
@@ -540,23 +2117,25 @@ function createMotionComponent(Component) {
   Motion2.displayName = `Motion(${Component.displayName ?? Component.name ?? "Component"})`;
   return Motion2;
 }
-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 opacity = Animated.useSharedValue(init("opacity"));
-  const width = Animated.useSharedValue(init("width"));
-  const height = Animated.useSharedValue(init("height"));
-  const borderRadius = Animated.useSharedValue(init("borderRadius"));
+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 backgroundColor = Animated.useSharedValue(
-    init("backgroundColor")
+    init2("backgroundColor")
   );
-  const borderColor = Animated.useSharedValue(init("borderColor"));
-  const color = Animated.useSharedValue(init("color"));
-  const tintColor = Animated.useSharedValue(init("tintColor"));
+  const borderColor = Animated.useSharedValue(init2("borderColor"));
+  const color = Animated.useSharedValue(init2("color"));
+  const tintColor = Animated.useSharedValue(init2("tintColor"));
   const ref = react.useRef(null);
   if (ref.current === null) {
     ref.current = {
@@ -566,6 +2145,8 @@ function useAnimatableSharedValues(init) {
       scaleX,
       scaleY,
       rotate,
+      rotateX,
+      rotateY,
       opacity,
       width,
       height,
@@ -702,72 +2283,41 @@ function restValue(v) {
   }
   return void 0;
 }
-function stableSig(value) {
-  if (value === void 0) return "";
-  try {
-    return stableStringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function stableStringify(v) {
-  if (v === null || typeof v !== "object") {
-    if (typeof v === "function" || v === void 0) return "null";
-    return JSON.stringify(v);
-  }
-  if (Array.isArray(v)) {
-    return "[" + v.map(stableStringify).join(",") + "]";
+function resolveGestureLayers(gesture) {
+  if (!gesture) return null;
+  const out = {};
+  for (const layer of GESTURE_LAYER_NAMES) {
+    const subState = gesture[layer];
+    if (!subState) continue;
+    const resolved = {};
+    for (const key of ALL_KEYS) {
+      const raw = subState[key];
+      if (raw === void 0) continue;
+      const t = targetEndValue(raw);
+      if (t !== void 0) resolved[key] = t;
+    }
+    out[layer] = resolved;
   }
-  const obj = v;
-  const keys = Object.keys(obj).sort();
-  return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
+  return out;
 }
-function mergeGestureTargets(base, gesture, active) {
-  if (!gesture) return base;
-  const merged = {
-    ...base
-  };
-  const subStates = [
-    gesture.hovered,
-    gesture.focused,
-    gesture.focusVisible,
-    gesture.pressed
-  ];
-  for (const sub of subStates) {
-    if (!sub) continue;
-    for (const k of ALL_KEYS) {
-      if (k in sub && !(k in merged)) {
-        merged[k] = DEFAULT_RESTING[k];
-      }
-    }
-  }
-  if (active.hovered && gesture.hovered) {
-    Object.assign(
-      merged,
-      gesture.hovered
-    );
-  }
-  if (active.focused && gesture.focused) {
-    Object.assign(
-      merged,
-      gesture.focused
-    );
-  }
-  if (active.focusVisible && gesture.focusVisible) {
-    Object.assign(
-      merged,
-      gesture.focusVisible
-    );
-  }
-  if (active.pressed && gesture.pressed) {
-    Object.assign(
-      merged,
-      gesture.pressed
-    );
-  }
-  return merged;
+function useGestureLayerProgress(progress, active, declared, layer, transition, isExiting, shouldReduceMotion) {
+  const layerCfgSig = stableSig(gestureLayerTransitionFor(layer, transition));
+  react.useEffect(() => {
+    if (!declared) return;
+    if (isExiting) {
+      progress.value = 0;
+      return;
+    }
+    const target = active ? 1 : 0;
+    const cfg = shouldReduceMotion ? { type: "no-animation" } : gestureLayerTransitionFor(layer, transition) ?? { type: "spring" };
+    progress.value = resolveTransition(cfg, target);
+  }, [active, declared, isExiting, shouldReduceMotion, layerCfgSig]);
 }
 function useGestureHandlers(gesture, rest, setPressed, setFocused, setFocusVisible, setHovered) {
+  const hasPressed = gesture?.pressed ? 1 : 0;
+  const hasFocused = gesture?.focused ? 1 : 0;
+  const hasFocusVisible = gesture?.focusVisible ? 1 : 0;
+  const hasHovered = gesture?.hovered ? 1 : 0;
   return react.useMemo(() => {
     if (!gesture) return {};
     const handlers = {};
@@ -800,10 +2350,10 @@ function useGestureHandlers(gesture, rest, setPressed, setFocused, setFocusVisib
     }
     return handlers;
   }, [
-    gesture?.pressed ? 1 : 0,
-    gesture?.focused ? 1 : 0,
-    gesture?.focusVisible ? 1 : 0,
-    gesture?.hovered ? 1 : 0,
+    hasPressed,
+    hasFocused,
+    hasFocusVisible,
+    hasHovered,
     rest.onTouchStart,
     rest.onTouchEnd,
     rest.onTouchCancel,
@@ -838,6 +2388,155 @@ var Motion = {
   Pressable: MotionPressable,
   ScrollView: MotionScrollView
 };
+function useAnimation(target, transition) {
+  const output = Animated.useSharedValue(target);
+  const shouldReduceMotion = useShouldReduceMotion();
+  const cfgSig = stableSig(transition);
+  react.useEffect(() => {
+    const cfg = shouldReduceMotion ? { type: "no-animation" } : transition ?? { type: "spring" };
+    output.value = resolveTransition(cfg, target);
+  }, [target, cfgSig, shouldReduceMotion]);
+  return output;
+}
+function useGesture(transition) {
+  const pressed = Animated.useSharedValue(0);
+  const focused = Animated.useSharedValue(0);
+  const focusVisible = Animated.useSharedValue(0);
+  const hovered = Animated.useSharedValue(0);
+  const shouldReduceMotion = useShouldReduceMotion();
+  const setLayer = react.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 = react.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];
+}
+function useMotionValue(initial) {
+  return Animated.useSharedValue(initial);
+}
+function useSpring(target, config) {
+  const reanimConfig = react.useMemo(
+    () => springToReanimated(config ?? {}),
+    [
+      config?.tension,
+      config?.friction,
+      config?.mass,
+      config?.velocity,
+      config?.restSpeedThreshold,
+      config?.restDisplacementThreshold
+    ]
+  );
+  const isSharedTarget = isSharedValue(target);
+  const initial = isSharedTarget ? target.value : target;
+  const output = Animated.useSharedValue(initial);
+  react.useEffect(() => {
+    if (isSharedTarget) return;
+    output.value = Animated.withSpring(target, reanimConfig);
+  }, [isSharedTarget, target, reanimConfig]);
+  Animated.useAnimatedReaction(
+    () => {
+      "worklet";
+      if (!isSharedTarget) return null;
+      return target.value;
+    },
+    (next, prev) => {
+      "worklet";
+      if (next === null || next === prev) return;
+      output.value = Animated.withSpring(next, reanimConfig);
+    },
+    [isSharedTarget, reanimConfig]
+  );
+  return output;
+}
+function isSharedValue(v) {
+  return typeof v === "object" && v !== null && "value" in v;
+}
+function useTransform(arg1, inputRange, outputRange, options) {
+  let producer;
+  if (typeof arg1 === "function") {
+    const userFn = arg1;
+    producer = isWorkletFunction(userFn) ? userFn : () => {
+      "worklet";
+      return userFn();
+    };
+  } else {
+    const source = arg1;
+    const input = inputRange;
+    const output = outputRange;
+    const isColor = output.length > 0 && typeof output[0] === "string";
+    const extrapolateLeft = mapExtrapolation(options?.extrapolateLeft);
+    const extrapolateRight = mapExtrapolation(options?.extrapolateRight);
+    producer = isColor ? () => {
+      "worklet";
+      return Animated.interpolateColor(
+        source.value,
+        input,
+        output
+      );
+    } : () => {
+      "worklet";
+      return Animated.interpolate(
+        source.value,
+        input,
+        output,
+        { extrapolateLeft, extrapolateRight }
+      );
+    };
+  }
+  return Animated.useDerivedValue(producer);
+}
+function mapExtrapolation(mode) {
+  if (mode === "identity") return Animated.Extrapolation.IDENTITY;
+  if (mode === "extend") return Animated.Extrapolation.EXTEND;
+  return Animated.Extrapolation.CLAMP;
+}
+function useScroll() {
+  const scrollX = Animated.useSharedValue(0);
+  const scrollY = Animated.useSharedValue(0);
+  const handler = Animated.useAnimatedScrollHandler({
+    onScroll: (event) => {
+      "worklet";
+      scrollX.value = event.contentOffset.x;
+      scrollY.value = event.contentOffset.y;
+    }
+  });
+  return {
+    scrollX,
+    scrollY,
+    onScroll: handler
+  };
+}
 function useVariants(variants, initial) {
   const variantsRef = react.useRef(variants);
   return react.useMemo(() => {
@@ -883,9 +2582,15 @@ exports.createMotionComponent = createMotionComponent;
 exports.ensureWorkletEasing = ensureWorkletEasing;
 exports.resolveAnimatableValue = resolveAnimatableValue;
 exports.resolveTransition = resolveTransition;
+exports.useAnimation = useAnimation;
+exports.useGesture = useGesture;
 exports.useMotionConfig = useMotionConfig;
+exports.useMotionValue = useMotionValue;
 exports.usePresence = usePresence;
+exports.useScroll = useScroll;
 exports.useShouldReduceMotion = useShouldReduceMotion;
+exports.useSpring = useSpring;
+exports.useTransform = useTransform;
 exports.useVariants = useVariants;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map