@rootnative/inertia 0.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1546 @@
+'use strict';
+
+var reactNative = require('react-native');
+var react = require('react');
+var Animated = require('react-native-reanimated');
+var jsxRuntime = require('react/jsx-runtime');
+var reactNativeWorklets = require('react-native-worklets');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Animated__default = /*#__PURE__*/_interopDefault(Animated);
+
+// src/motion/Image.tsx
+var DEFAULT_MOTION_CONFIG = {
+  reducedMotion: "user"
+};
+var MotionConfigContext = react.createContext(
+  DEFAULT_MOTION_CONFIG
+);
+function useMotionConfig() {
+  return react.useContext(MotionConfigContext);
+}
+function useShouldReduceMotion() {
+  const { reducedMotion } = useMotionConfig();
+  const osReduced = Animated.useReducedMotion();
+  if (reducedMotion === "never") return false;
+  if (reducedMotion === "always") return true;
+  return osReduced;
+}
+function MotionConfig({
+  reducedMotion = "user",
+  children
+}) {
+  const value = react.useMemo(
+    () => ({ reducedMotion }),
+    [reducedMotion]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(MotionConfigContext.Provider, { value, children });
+}
+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";
+}
+function ensureWorkletEasing(easing) {
+  if (!easing) return void 0;
+  const fn = isEasingFactory(easing) ? easing.factory() : easing;
+  if (reactNativeWorklets.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/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;
+}
+
+// src/layout/sharedRegistry.ts
+var REGISTRY = /* @__PURE__ */ new Map();
+var SHARED_LAYOUT_TTL_MS = 1e3;
+var now = () => Date.now();
+function registerLayout(id, rect) {
+  REGISTRY.set(id, { rect, expiresAt: now() + SHARED_LAYOUT_TTL_MS });
+}
+function releaseLayout(id, rect) {
+  REGISTRY.set(id, { rect, expiresAt: now() + SHARED_LAYOUT_TTL_MS });
+}
+function consumeLayout(id) {
+  const entry = REGISTRY.get(id);
+  if (!entry) return void 0;
+  REGISTRY.delete(id);
+  if (entry.expiresAt < now()) return void 0;
+  return entry.rect;
+}
+function useSharedLayout(options) {
+  const { layoutId, userRef, transition, shouldReduceMotion, userOnLayout } = options;
+  const dx = Animated.useSharedValue(0);
+  const dy = Animated.useSharedValue(0);
+  const sx = Animated.useSharedValue(1);
+  const sy = Animated.useSharedValue(1);
+  const lastRectRef = react.useRef(null);
+  const consumedRef = react.useRef(false);
+  const transitionRef = react.useRef(transition);
+  transitionRef.current = transition;
+  const reducedMotionRef = react.useRef(shouldReduceMotion);
+  reducedMotionRef.current = shouldReduceMotion;
+  const setRef = react.useCallback(
+    (node) => {
+      if (typeof userRef === "function") userRef(node);
+      else if (userRef) userRef.current = node;
+    },
+    [userRef]
+  );
+  const onLayout = react.useCallback(
+    (event) => {
+      userOnLayout?.(event);
+      if (!layoutId) return;
+      const { x, y, width, height } = event.nativeEvent.layout;
+      const rect = { x, y, width, height };
+      lastRectRef.current = rect;
+      let source;
+      if (!consumedRef.current) {
+        consumedRef.current = true;
+        source = consumeLayout(layoutId);
+      }
+      registerLayout(layoutId, rect);
+      if (source) {
+        applyFlip({
+          source,
+          target: rect,
+          dx,
+          dy,
+          sx,
+          sy,
+          transition: transitionRef.current,
+          shouldReduceMotion: reducedMotionRef.current
+        });
+      }
+    },
+    // dx/dy/sx/sy are stable refs from useSharedValue, but eslint's
+    // exhaustive-deps would flag them — including them is harmless and
+    // silences the warning.
+    [layoutId, userOnLayout, dx, dy, sx, sy]
+  );
+  react.useEffect(() => {
+    consumedRef.current = false;
+  }, [layoutId]);
+  react.useEffect(() => {
+    return () => {
+      if (!layoutId) return;
+      const rect = lastRectRef.current;
+      if (!rect) return;
+      releaseLayout(layoutId, rect);
+    };
+  }, [layoutId]);
+  return react.useMemo(
+    () => ({
+      flip: { dx, dy, sx, sy },
+      setRef,
+      onLayout
+    }),
+    [dx, dy, sx, sy, setRef, onLayout]
+  );
+}
+function applyFlip(args) {
+  const { source, target, dx, dy, sx, sy, transition, shouldReduceMotion } = args;
+  const sourceCenterX = source.x + source.width / 2;
+  const sourceCenterY = source.y + source.height / 2;
+  const targetCenterX = target.x + target.width / 2;
+  const targetCenterY = target.y + target.height / 2;
+  const deltaX = sourceCenterX - targetCenterX;
+  const deltaY = sourceCenterY - targetCenterY;
+  const scaleX = target.width > 0 ? source.width / target.width : 1;
+  const scaleY = target.height > 0 ? source.height / target.height : 1;
+  if (shouldReduceMotion) {
+    dx.value = 0;
+    dy.value = 0;
+    sx.value = 1;
+    sy.value = 1;
+    return;
+  }
+  if (transition?.type === "no-animation") {
+    dx.value = 0;
+    dy.value = 0;
+    sx.value = 1;
+    sy.value = 1;
+    return;
+  }
+  if (transition?.type === "timing") {
+    const duration = transition.duration ?? 300;
+    dx.value = Animated.withSequence(
+      Animated.withTiming(deltaX, { duration: 0 }),
+      Animated.withTiming(0, { duration })
+    );
+    dy.value = Animated.withSequence(
+      Animated.withTiming(deltaY, { duration: 0 }),
+      Animated.withTiming(0, { duration })
+    );
+    sx.value = Animated.withSequence(
+      Animated.withTiming(scaleX, { duration: 0 }),
+      Animated.withTiming(1, { duration })
+    );
+    sy.value = Animated.withSequence(
+      Animated.withTiming(scaleY, { duration: 0 }),
+      Animated.withTiming(1, { duration })
+    );
+    return;
+  }
+  const springCfg = transition?.type === "spring" ? { ...DEFAULT_SPRING, ...transition } : { ...DEFAULT_SPRING };
+  const springParams = springToReanimated(springCfg);
+  dx.value = Animated.withSequence(
+    Animated.withTiming(deltaX, { duration: 0 }),
+    Animated.withSpring(0, springParams)
+  );
+  dy.value = Animated.withSequence(
+    Animated.withTiming(deltaY, { duration: 0 }),
+    Animated.withSpring(0, springParams)
+  );
+  sx.value = Animated.withSequence(
+    Animated.withTiming(scaleX, { duration: 0 }),
+    Animated.withSpring(1, springParams)
+  );
+  sy.value = Animated.withSequence(
+    Animated.withTiming(scaleY, { duration: 0 }),
+    Animated.withSpring(1, springParams)
+  );
+}
+var PresenceContext = react.createContext(null);
+function usePresence() {
+  return react.useContext(PresenceContext);
+}
+function Presence({ children }) {
+  const incoming = react.useMemo(() => {
+    const out = [];
+    react.Children.forEach(children, (child) => {
+      if (!react.isValidElement(child)) return;
+      if (child.key === null) {
+        if (__DEV__) {
+          console.warn(
+            "[inertia] <Presence> children must have a `key`. Skipping a keyless child."
+          );
+        }
+        return;
+      }
+      out.push(child);
+    });
+    return out;
+  }, [children]);
+  const [exiting, setExiting] = react.useState(
+    () => /* @__PURE__ */ new Map()
+  );
+  const prevIncomingRef = react.useRef(incoming);
+  if (prevIncomingRef.current !== incoming) {
+    const prev = prevIncomingRef.current;
+    prevIncomingRef.current = incoming;
+    const incomingKeys = new Set(incoming.map((el) => el.key));
+    let next = null;
+    const ensureMutable = () => {
+      if (!next) next = new Map(exiting);
+      return next;
+    };
+    for (const oldEl of prev) {
+      const key = oldEl.key;
+      if (!incomingKeys.has(key) && !exiting.has(key)) {
+        ensureMutable().set(key, oldEl);
+      }
+    }
+    for (const el of incoming) {
+      const key = el.key;
+      if (exiting.has(key)) {
+        ensureMutable().delete(key);
+      }
+    }
+    if (next) setExiting(next);
+  }
+  const handleRemove = react.useCallback((key) => {
+    setExiting((prev) => {
+      if (!prev.has(key)) return prev;
+      const next = new Map(prev);
+      next.delete(key);
+      return next;
+    });
+  }, []);
+  const renderList = [];
+  for (const el of incoming) {
+    renderList.push({
+      key: el.key,
+      element: el,
+      isPresent: true
+    });
+  }
+  for (const [key, el] of exiting) {
+    if (!renderList.some((entry) => entry.key === key)) {
+      renderList.push({ key, element: el, isPresent: false });
+    }
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: renderList.map(({ key, element, isPresent }) => /* @__PURE__ */ jsxRuntime.jsx(
+    PresenceItem,
+    {
+      itemKey: key,
+      isPresent,
+      onRemove: handleRemove,
+      children: element
+    },
+    key
+  )) });
+}
+function PresenceItem({
+  itemKey,
+  isPresent,
+  onRemove,
+  children
+}) {
+  const value = react.useMemo(
+    () => ({
+      isPresent,
+      safeToRemove: () => onRemove(itemKey)
+    }),
+    [isPresent, itemKey, onRemove]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(PresenceContext.Provider, { value, children });
+}
+var DEFAULT_TIMING_DURATION = 250;
+function buildSpring(cfg, toValue, cb) {
+  return Animated.withSpring(toValue, springToReanimated(cfg), cb);
+}
+function buildTiming(cfg, toValue, cb) {
+  return Animated.withTiming(
+    toValue,
+    {
+      duration: cfg.duration ?? DEFAULT_TIMING_DURATION,
+      easing: ensureWorkletEasing(cfg.easing) ?? Animated.Easing.inOut(Animated.Easing.ease)
+    },
+    cb
+  );
+}
+function buildDecay(cfg, cb) {
+  return Animated.withDecay(
+    {
+      velocity: cfg.velocity ?? 0,
+      deceleration: cfg.deceleration,
+      clamp: cfg.clamp
+    },
+    cb
+  );
+}
+function buildOne(cfg, toValue, cb) {
+  if (cfg.type === "no-animation") {
+    if (cb) cb(true, toValue);
+    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 Animated.withRepeat(animation, -1, true);
+  }
+  if (typeof repeat === "number") {
+    return Animated.withRepeat(animation, repeat, true);
+  }
+  const count = repeat.count === "infinite" ? -1 : repeat.count;
+  const alternate = repeat.alternate ?? true;
+  return Animated.withRepeat(animation, count, alternate);
+}
+function applyDelay(animation, delay) {
+  if (!delay || delay <= 0) return animation;
+  return Animated.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 stripRepeat(cfg) {
+  if (!cfg) return cfg;
+  if (cfg.type === "no-animation" || cfg.type === "decay") return cfg;
+  if (cfg.repeat === void 0) return cfg;
+  const next = { ...cfg };
+  delete next.repeat;
+  return next;
+}
+function delayOf(cfg) {
+  if (cfg.type === "no-animation") return void 0;
+  return cfg.delay;
+}
+function isStepObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && "to" in v;
+}
+function resolveAnimatableValue(value, base, factory) {
+  if (Array.isArray(value)) {
+    const steps = value;
+    const stepBase = stripRepeat(base);
+    const animations = steps.map(
+      (step2, i) => resolveStep(step2, stepBase, factory?.("step", i))
+    );
+    const seq = Animated.withSequence(...animations);
+    return applyRepeat(seq, base ? repeatOf(base) : void 0);
+  }
+  const step = value;
+  const cb = factory?.("animation", void 0);
+  if (isStepObject(step)) {
+    return resolveStep(step, base, cb);
+  }
+  return resolveTransition(base, step, cb);
+}
+function resolveStep(step, base, cb) {
+  if (isStepObject(step)) {
+    const { to, ...override } = step;
+    const merged = mergeTransition(base, override);
+    return resolveTransition(merged, to, cb);
+  }
+  return resolveTransition(base, step, cb);
+}
+function mergeTransition(base, override) {
+  if (override.type && base && override.type !== base.type) {
+    return 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));
+}
+var DEFAULT_TIMING_DURATION2 = 250;
+function buildReleaseAnimation(transition, toValue) {
+  "worklet";
+  if (transition.type === "no-animation") return toValue;
+  if (transition.type === "decay") {
+    const cfg = { velocity: transition.velocity ?? 0 };
+    if (transition.deceleration !== void 0) {
+      cfg.deceleration = transition.deceleration;
+    }
+    if (transition.clamp !== void 0) cfg.clamp = transition.clamp;
+    return Animated.withDecay(cfg);
+  }
+  if (transition.type === "timing") {
+    const e = transition.easing;
+    const easingFn = e && typeof e === "object" && "factory" in e ? e.factory() : e ?? Animated.Easing.inOut(Animated.Easing.ease);
+    return Animated.withTiming(toValue, {
+      duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
+      easing: easingFn
+    });
+  }
+  return Animated.withSpring(toValue, springToReanimated(transition));
+}
+
+// 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(",") + "}";
+}
+var alreadyChecked = false;
+function ensureReanimatedInstalled() {
+  if (!__DEV__ || alreadyChecked) return;
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "test") {
+    return;
+  }
+  alreadyChecked = true;
+  const version = Animated.reanimatedVersion;
+  if (version) {
+    const major = parseInt(version.split(".")[0] ?? "0", 10);
+    if (major < 4) {
+      console.error(
+        `[inertia] react-native-reanimated v${version} is installed, but @rootnative/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",
+  "rotateX",
+  "rotateY"
+];
+var ROTATION_KEYS = /* @__PURE__ */ new Set(["rotate", "rotateX", "rotateY"]);
+var NUMERIC_TOP_LEVEL_KEYS = [
+  "opacity",
+  "width",
+  "height",
+  "borderRadius",
+  "shadowOpacity",
+  "shadowRadius",
+  "elevation"
+];
+var COLOR_KEYS = [
+  "backgroundColor",
+  "borderColor",
+  "color",
+  "tintColor",
+  "shadowColor"
+];
+var SHADOW_OFFSET_KEYS = ["shadowOffsetWidth", "shadowOffsetHeight"];
+var ALL_KEYS = [
+  ...TRANSFORM_KEYS,
+  ...NUMERIC_TOP_LEVEL_KEYS,
+  ...COLOR_KEYS,
+  ...SHADOW_OFFSET_KEYS
+];
+var TRANSFORM_KEY_SET = new Set(TRANSFORM_KEYS);
+var COLOR_KEY_SET = new Set(COLOR_KEYS);
+var SHADOW_OFFSET_KEY_SET = new Set(SHADOW_OFFSET_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,
+  translateY: 0,
+  scale: 1,
+  scaleX: 1,
+  scaleY: 1,
+  rotate: 0,
+  rotateX: 0,
+  rotateY: 0,
+  opacity: 1,
+  width: 0,
+  height: 0,
+  borderRadius: 0,
+  shadowOpacity: 0,
+  shadowRadius: 0,
+  elevation: 0,
+  // 'transparent' is the only safe universal default for colors: it works as
+  // an initial seed for any color animation (no jarring opaque flash on mount
+  // when `initial` is omitted) and rgba(0,0,0,0) interpolates cleanly into
+  // any opaque target via Reanimated's color util.
+  backgroundColor: "transparent",
+  borderColor: "transparent",
+  color: "transparent",
+  tintColor: "transparent",
+  shadowColor: "transparent",
+  shadowOffsetWidth: 0,
+  shadowOffsetHeight: 0
+};
+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) {
+    const {
+      initial,
+      animate,
+      exit,
+      transition,
+      variants,
+      controller,
+      gesture,
+      layout,
+      layoutId,
+      onAnimationEnd,
+      style,
+      onLayout: userOnLayout,
+      ...rest
+    } = props;
+    if (__DEV__ && typeof style === "function") {
+      throw new Error(
+        "[inertia] `style` must be a style object or array of style objects, not a function. The function-form `style={(state) => ...}` Pressable API is not supported \u2014 use `gesture.pressed` (or `gesture.focused`, etc.) to drive state-dependent styling instead."
+      );
+    }
+    const presence = usePresence();
+    const isExiting = presence !== null && presence.isPresent === false;
+    const shouldReduceMotion = useShouldReduceMotion();
+    const onAnimationEndRef = react.useRef(onAnimationEnd);
+    onAnimationEndRef.current = onAnimationEnd;
+    const variantKey = useControllerKey(controller);
+    const resolvedAnimate = resolveAnimateInput(
+      animate,
+      variants,
+      variantKey
+    );
+    const animateRecord = resolvedAnimate ?? {};
+    const initialRecord = initial && initial !== false ? initial : void 0;
+    const exitRecord = exit ? exit : void 0;
+    const [pressed, setPressed] = react.useState(false);
+    const [focused, setFocused] = react.useState(false);
+    const [focusVisible, setFocusVisible] = react.useState(false);
+    const [hovered, setHovered] = react.useState(false);
+    const touched = /* @__PURE__ */ new Set();
+    collectTouchedKeys(touched, animateRecord);
+    if (initialRecord) collectTouchedKeys(touched, initialRecord);
+    if (variants) {
+      for (const variant of Object.values(variants)) {
+        if (!variant) continue;
+        collectTouchedKeys(touched, variant);
+      }
+    }
+    if (gesture) {
+      for (const subState of [
+        gesture.pressed,
+        gesture.focused,
+        gesture.focusVisible,
+        gesture.hovered
+      ]) {
+        if (!subState) continue;
+        collectTouchedKeys(touched, subState);
+      }
+    }
+    if (exitRecord) collectTouchedKeys(touched, exitRecord);
+    const activeKeysRef = react.useRef(null);
+    const hasTransformRef = react.useRef(false);
+    const hasShadowOffsetRef = react.useRef(false);
+    const prevActive = activeKeysRef.current;
+    let grew = prevActive === null;
+    if (!grew && prevActive) {
+      for (const k of touched) {
+        if (!prevActive.includes(k)) {
+          grew = true;
+          break;
+        }
+      }
+    }
+    if (grew) {
+      const merged = new Set(prevActive ?? []);
+      for (const k of touched) merged.add(k);
+      activeKeysRef.current = ALL_KEYS.filter((k) => merged.has(k));
+      hasTransformRef.current = activeKeysRef.current.some(
+        (k) => TRANSFORM_KEY_SET.has(k)
+      );
+      hasShadowOffsetRef.current = activeKeysRef.current.some(
+        (k) => SHADOW_OFFSET_KEY_SET.has(k)
+      );
+    }
+    const sharedValues = useAnimatableSharedValues((key) => {
+      if (SHADOW_OFFSET_KEY_SET.has(key)) {
+        const axis = shadowOffsetAxisFor(key);
+        if (initial === false) {
+          return shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? DEFAULT_RESTING[key];
+        }
+        return shadowOffsetAxisValue(
+          initialRecord?.shadowOffset,
+          axis
+        ) ?? shadowOffsetAxisValue(animateRecord.shadowOffset, axis) ?? DEFAULT_RESTING[key];
+      }
+      if (initial === false) {
+        const a = animateRecord[key];
+        return restValue(a) ?? DEFAULT_RESTING[key];
+      }
+      return initialRecord?.[key] ?? restValue(animateRecord[key]) ?? DEFAULT_RESTING[key];
+    });
+    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;
+    react.useEffect(() => {
+      if (isExiting && (!exitRecord || Object.keys(exitRecord).length === 0)) {
+        safeToRemoveRef.current?.();
+        return;
+      }
+      let pending = 0;
+      let done = false;
+      const onSettle = () => {
+        if (done) return;
+        pending--;
+        if (pending <= 0) {
+          done = true;
+          if (isExiting) safeToRemoveRef.current?.();
+        }
+      };
+      let transformPending = 0;
+      for (const k of ALL_KEYS) {
+        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 = SHADOW_OFFSET_KEY_SET.has(key) ? shadowOffsetAxisValue(
+          baseRecord.shadowOffset,
+          shadowOffsetAxisFor(key)
+        ) : baseRecord[key];
+        if (target === void 0) continue;
+        const cfg = shouldReduceMotion ? { type: "no-animation" } : transitionFor(
+          SHADOW_OFFSET_KEY_SET.has(key) ? "shadowOffset" : key,
+          transition
+        );
+        if (isExiting) pending++;
+        const factory = makeKeyCallbackFactory(
+          key,
+          sharedValues[key],
+          targetEndValue(target),
+          onAnimationEndRef,
+          {
+            stepCount: stepCountOf(target),
+            totalIterations: totalIterationsOf(cfg)
+          },
+          isExiting ? onSettle : void 0,
+          TRANSFORM_KEY_SET.has(key) ? transformGroup : void 0
+        );
+        sharedValues[key].value = resolveAnimatableValue(
+          target,
+          cfg,
+          factory
+        );
+      }
+      if (isExiting && pending === 0) {
+        safeToRemoveRef.current?.();
+      }
+    }, [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 sharedLayout = useSharedLayout({
+      layoutId,
+      userRef: ref,
+      transition: isTopLevelTransition(transition) ? transition : void 0,
+      shouldReduceMotion,
+      userOnLayout
+    });
+    const flip = sharedLayout.flip;
+    const hasLayoutId = layoutId !== void 0;
+    const animatedStyle = Animated.useAnimatedStyle(() => {
+      const activeKeys = activeKeysRef.current;
+      const hasTransform = hasTransformRef.current;
+      const hasShadowOffset = hasShadowOffsetRef.current;
+      const out = {};
+      const transform = [];
+      let shadowOffsetW = 0;
+      let shadowOffsetH = 0;
+      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) {
+        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(
+            ROTATION_KEYS.has(key) ? { [key]: `${v}deg` } : { [key]: v }
+          );
+        } else if (key === "shadowOffsetWidth") {
+          shadowOffsetW = v;
+        } else if (key === "shadowOffsetHeight") {
+          shadowOffsetH = v;
+        } else {
+          out[key] = v;
+        }
+      }
+      if (hasLayoutId) {
+        transform.push({ translateX: flip.dx.value });
+        transform.push({ translateY: flip.dy.value });
+        transform.push({ scaleX: flip.sx.value });
+        transform.push({ scaleY: flip.sy.value });
+      }
+      if (hasTransform || hasLayoutId) out.transform = transform;
+      if (hasShadowOffset) {
+        out.shadowOffset = { width: shadowOffsetW, height: shadowOffsetH };
+      }
+      return out;
+    });
+    const mergedStyle = react.useMemo(
+      () => isExiting ? [style, animatedStyle, EXITING_POINTER_EVENTS_STYLE] : [style, animatedStyle],
+      [style, animatedStyle, isExiting]
+    );
+    const gestureHandlers = useGestureHandlers(
+      gesture,
+      rest,
+      setPressed,
+      setFocused,
+      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: sharedLayout.setRef,
+        ...rest,
+        ...gestureHandlers,
+        onLayout: sharedLayout.onLayout,
+        layout: layoutTransition,
+        style: mergedStyle
+      }
+    );
+  });
+  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 rotateX = Animated.useSharedValue(init("rotateX"));
+  const rotateY = Animated.useSharedValue(init("rotateY"));
+  const opacity = Animated.useSharedValue(init("opacity"));
+  const width = Animated.useSharedValue(init("width"));
+  const height = Animated.useSharedValue(init("height"));
+  const borderRadius = Animated.useSharedValue(init("borderRadius"));
+  const shadowOpacity = Animated.useSharedValue(init("shadowOpacity"));
+  const shadowRadius = Animated.useSharedValue(init("shadowRadius"));
+  const elevation = Animated.useSharedValue(init("elevation"));
+  const backgroundColor = Animated.useSharedValue(
+    init("backgroundColor")
+  );
+  const borderColor = Animated.useSharedValue(init("borderColor"));
+  const color = Animated.useSharedValue(init("color"));
+  const tintColor = Animated.useSharedValue(init("tintColor"));
+  const shadowColor = Animated.useSharedValue(init("shadowColor"));
+  const shadowOffsetWidth = Animated.useSharedValue(
+    init("shadowOffsetWidth")
+  );
+  const shadowOffsetHeight = Animated.useSharedValue(
+    init("shadowOffsetHeight")
+  );
+  const ref = react.useRef(null);
+  if (ref.current === null) {
+    ref.current = {
+      translateX,
+      translateY,
+      scale,
+      scaleX,
+      scaleY,
+      rotate,
+      rotateX,
+      rotateY,
+      opacity,
+      width,
+      height,
+      borderRadius,
+      shadowOpacity,
+      shadowRadius,
+      elevation,
+      backgroundColor,
+      borderColor,
+      color,
+      tintColor,
+      shadowColor,
+      shadowOffsetWidth,
+      shadowOffsetHeight
+    };
+  }
+  return ref.current;
+}
+function makeKeyCallbackFactory(key, sharedValue, target, onAnimationEndRef, meta, onSettle, transformGroup) {
+  if (!onAnimationEndRef.current && !onSettle) return void 0;
+  const state = { iteration: 0 };
+  const isTransformKey = TRANSFORM_KEY_SET.has(key);
+  const dispatch = (rawPhase, step, finished, value) => {
+    const isLastIteration = state.iteration >= meta.totalIterations - 1;
+    let phase;
+    let isTerminal = false;
+    if (rawPhase === "step") {
+      const isLastInPass = step !== void 0 && step === meta.stepCount - 1;
+      if (!isLastInPass) {
+        phase = "step";
+      } else if (isLastIteration) {
+        phase = "animation";
+        isTerminal = true;
+      } else {
+        phase = "sequence";
+      }
+    } else if (isLastIteration) {
+      phase = "animation";
+      isTerminal = true;
+    } else {
+      phase = "repeat";
+    }
+    const reportedIteration = state.iteration;
+    if (phase === "sequence" || phase === "repeat") state.iteration++;
+    const fn = onAnimationEndRef.current;
+    if (fn) {
+      if (isTransformKey && transformGroup && phase === "animation") {
+        transformGroup.remaining--;
+        if (transformGroup.remaining <= 0) {
+          fn({
+            key: "transform",
+            finished,
+            value,
+            target,
+            phase,
+            step,
+            iteration: reportedIteration
+          });
+        }
+      } else {
+        fn({
+          key,
+          finished,
+          value,
+          target,
+          phase,
+          step,
+          iteration: reportedIteration
+        });
+      }
+    }
+    if (onSettle && isTerminal) onSettle();
+  };
+  return (rawPhase, step) => {
+    const cb = (finished) => {
+      "worklet";
+      Animated.runOnJS(dispatch)(rawPhase, step, !!finished, sharedValue.value);
+    };
+    return cb;
+  };
+}
+function shadowOffsetAxisFor(key) {
+  return key === "shadowOffsetWidth" ? "width" : "height";
+}
+function shadowOffsetAxisValue(source, axis) {
+  return source?.[axis];
+}
+function collectTouchedKeys(touched, record) {
+  for (const k of ALL_KEYS) {
+    if (k in record) touched.add(k);
+  }
+  if ("shadowOffset" in record && record.shadowOffset) {
+    const so = record.shadowOffset;
+    if (so.width !== void 0) touched.add("shadowOffsetWidth");
+    if (so.height !== void 0) touched.add("shadowOffsetHeight");
+  }
+}
+function stepCountOf(v) {
+  if (Array.isArray(v)) return v.length;
+  return 1;
+}
+function totalIterationsOf(cfg) {
+  if (!cfg || cfg.type === "no-animation" || cfg.type === "decay") return 1;
+  const r = cfg.repeat;
+  if (r === void 0) return 1;
+  if (r === "infinite") return Number.POSITIVE_INFINITY;
+  if (typeof r === "number") return r;
+  if (r.count === "infinite") return Number.POSITIVE_INFINITY;
+  return r.count;
+}
+function targetEndValue(v) {
+  if (v === void 0) return void 0;
+  if (typeof v === "number" || typeof v === "string") return v;
+  if (Array.isArray(v)) {
+    return v.length > 0 ? targetEndValue(v[v.length - 1]) : void 0;
+  }
+  if (typeof v === "object" && v !== null && "to" in v) {
+    const to = v.to;
+    return typeof to === "number" || typeof to === "string" ? to : void 0;
+  }
+  return void 0;
+}
+function useControllerKey(controller) {
+  const [, setTick] = react.useState(0);
+  react.useEffect(() => {
+    if (!controller) return;
+    const unsub = controller.subscribe(() => setTick((n) => n + 1));
+    return unsub;
+  }, [controller]);
+  return controller?.current;
+}
+function resolveAnimateInput(animate, variants, controllerKey) {
+  if (controllerKey !== void 0 && variants && controllerKey in variants) {
+    return variants[controllerKey];
+  }
+  if (typeof animate === "string") {
+    if (variants && animate in variants) return variants[animate];
+    if (__DEV__) {
+      console.warn(
+        `[inertia] animate="${animate}" but no matching variant. Did you forget to pass \`variants\`?`
+      );
+    }
+    return void 0;
+  }
+  return animate;
+}
+function restValue(v) {
+  if (v === void 0) return void 0;
+  if (typeof v === "number" || typeof v === "string") return v;
+  if (Array.isArray(v)) {
+    return v.length > 0 ? restValue(v[0]) : void 0;
+  }
+  if (typeof v === "object" && v !== null && "to" in v) {
+    const to = v.to;
+    return typeof to === "number" || typeof to === "string" ? to : void 0;
+  }
+  return void 0;
+}
+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) {
+      if (SHADOW_OFFSET_KEY_SET.has(key)) {
+        const axis = shadowOffsetAxisFor(key);
+        const so = subState.shadowOffset;
+        const v = shadowOffsetAxisValue(so, axis);
+        if (v !== void 0) resolved[key] = v;
+        continue;
+      }
+      const raw = subState[key];
+      if (raw === void 0) continue;
+      const t = targetEndValue(raw);
+      if (t !== void 0) resolved[key] = t;
+    }
+    out[layer] = resolved;
+  }
+  return out;
+}
+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 = {};
+    if (gesture.pressed) {
+      handlers.onTouchStart = compose(rest.onTouchStart, () => setPressed(true));
+      handlers.onTouchEnd = compose(rest.onTouchEnd, () => setPressed(false));
+      handlers.onTouchCancel = compose(
+        rest.onTouchCancel,
+        () => setPressed(false)
+      );
+      handlers.onPressIn = compose(rest.onPressIn, () => setPressed(true));
+      handlers.onPressOut = compose(rest.onPressOut, () => setPressed(false));
+    }
+    if (gesture.focused || gesture.focusVisible) {
+      handlers.onFocus = compose(rest.onFocus, () => {
+        if (gesture.focused) setFocused(true);
+        if (gesture.focusVisible && isFocusVisible()) setFocusVisible(true);
+      });
+      handlers.onBlur = compose(rest.onBlur, () => {
+        if (gesture.focused) setFocused(false);
+        if (gesture.focusVisible) setFocusVisible(false);
+      });
+    }
+    if (gesture.hovered) {
+      handlers.onMouseEnter = compose(rest.onMouseEnter, () => setHovered(true));
+      handlers.onMouseLeave = compose(
+        rest.onMouseLeave,
+        () => setHovered(false)
+      );
+    }
+    return handlers;
+  }, [
+    hasPressed,
+    hasFocused,
+    hasFocusVisible,
+    hasHovered,
+    rest.onTouchStart,
+    rest.onTouchEnd,
+    rest.onTouchCancel,
+    rest.onPressIn,
+    rest.onPressOut,
+    rest.onFocus,
+    rest.onBlur,
+    rest.onMouseEnter,
+    rest.onMouseLeave
+  ]);
+}
+function compose(user, ours) {
+  if (typeof user !== "function") return ours;
+  return (event) => {
+    user(event);
+    ours(event);
+  };
+}
+
+// src/motion/Image.tsx
+var MotionImage = createMotionComponent(reactNative.Image);
+var MotionPressable = createMotionComponent(reactNative.Pressable);
+var MotionScrollView = createMotionComponent(reactNative.ScrollView);
+var MotionText = createMotionComponent(reactNative.Text);
+var MotionView = createMotionComponent(reactNative.View);
+
+// src/motion/index.ts
+var Motion = {
+  View: MotionView,
+  Text: MotionText,
+  Image: MotionImage,
+  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 useSpring(target, config) {
+  const reanimConfig = react.useMemo(
+    () => springToReanimated(config ?? {}),
+    // Keyed on the resolved primitive fields rather than the `config` object
+    // identity: callers routinely pass a fresh object literal each render, so
+    // depending on `config` itself would rebuild the Reanimated config on
+    // every render and defeat the memo.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      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;
+}
+
+// src/values/useBooleanSpring.ts
+function useBooleanSpring(active, springConfig) {
+  return useSpring(active ? 1 : 0, springConfig);
+}
+function useColorTransition(progress, range, options) {
+  const key = options?.key ?? "backgroundColor";
+  const from = range[0];
+  const to = range[1];
+  return Animated.useAnimatedStyle(() => {
+    "worklet";
+    return { [key]: Animated.interpolateColor(progress.value, [0, 1], [from, to]) };
+  });
+}
+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 useTransform(arg1, inputRange, outputRange, options) {
+  let producer;
+  if (typeof arg1 === "function") {
+    const userFn = arg1;
+    producer = reactNativeWorklets.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 useShadow({
+  from,
+  to,
+  progress
+}) {
+  const hasOpacity = from.shadowOpacity !== void 0 || to.shadowOpacity !== void 0;
+  const hasRadius = from.shadowRadius !== void 0 || to.shadowRadius !== void 0;
+  const hasElevation = from.elevation !== void 0 || to.elevation !== void 0;
+  const hasColor = from.shadowColor !== void 0 || to.shadowColor !== void 0;
+  const hasOffset = from.shadowOffset !== void 0 || to.shadowOffset !== void 0;
+  const opacityFrom = from.shadowOpacity ?? 0;
+  const opacityTo = to.shadowOpacity ?? 0;
+  const radiusFrom = from.shadowRadius ?? 0;
+  const radiusTo = to.shadowRadius ?? 0;
+  const elevationFrom = from.elevation ?? 0;
+  const elevationTo = to.elevation ?? 0;
+  const colorFrom = from.shadowColor ?? "transparent";
+  const colorTo = to.shadowColor ?? "transparent";
+  const offsetWFrom = from.shadowOffset?.width ?? 0;
+  const offsetWTo = to.shadowOffset?.width ?? 0;
+  const offsetHFrom = from.shadowOffset?.height ?? 0;
+  const offsetHTo = to.shadowOffset?.height ?? 0;
+  return Animated.useAnimatedStyle(() => {
+    "worklet";
+    const t = progress.value;
+    const out = {};
+    if (hasOpacity) {
+      out.shadowOpacity = Animated.interpolate(t, [0, 1], [opacityFrom, opacityTo]);
+    }
+    if (hasRadius) {
+      out.shadowRadius = Animated.interpolate(t, [0, 1], [radiusFrom, radiusTo]);
+    }
+    if (hasElevation) {
+      out.elevation = Animated.interpolate(t, [0, 1], [elevationFrom, elevationTo]);
+    }
+    if (hasColor) {
+      out.shadowColor = Animated.interpolateColor(t, [0, 1], [colorFrom, colorTo]);
+    }
+    if (hasOffset) {
+      out.shadowOffset = {
+        width: Animated.interpolate(t, [0, 1], [offsetWFrom, offsetWTo]),
+        height: Animated.interpolate(t, [0, 1], [offsetHFrom, offsetHTo])
+      };
+    }
+    return out;
+  });
+}
+function useVariants(variants, initial) {
+  const variantsRef = react.useRef(variants);
+  return react.useMemo(() => {
+    const listeners = /* @__PURE__ */ new Set();
+    let current = initial ?? (Object.keys(variantsRef.current)[0] ?? "");
+    const controller = {
+      get current() {
+        return current;
+      },
+      transitionTo(next) {
+        if (next === current) return;
+        if (!(next in variantsRef.current)) {
+          if (__DEV__) {
+            console.warn(
+              `[inertia] useVariants: unknown variant "${String(next)}". Known keys: ${Object.keys(variantsRef.current).join(", ")}`
+            );
+          }
+          return;
+        }
+        current = next;
+        for (const fn of listeners) fn(next);
+      },
+      subscribe(listener) {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      }
+    };
+    return controller;
+  }, []);
+}
+
+exports.Motion = Motion;
+exports.MotionConfig = MotionConfig;
+exports.MotionImage = MotionImage;
+exports.MotionPressable = MotionPressable;
+exports.MotionScrollView = MotionScrollView;
+exports.MotionText = MotionText;
+exports.MotionView = MotionView;
+exports.Presence = Presence;
+exports.buildReleaseAnimation = buildReleaseAnimation;
+exports.createMotionComponent = createMotionComponent;
+exports.ensureWorkletEasing = ensureWorkletEasing;
+exports.resolveAnimatableValue = resolveAnimatableValue;
+exports.resolveTransition = resolveTransition;
+exports.useAnimation = useAnimation;
+exports.useBooleanSpring = useBooleanSpring;
+exports.useColorTransition = useColorTransition;
+exports.useGesture = useGesture;
+exports.useMotionConfig = useMotionConfig;
+exports.useMotionValue = useMotionValue;
+exports.usePresence = usePresence;
+exports.useScroll = useScroll;
+exports.useShadow = useShadow;
+exports.useShouldReduceMotion = useShouldReduceMotion;
+exports.useSpring = useSpring;
+exports.useTransform = useTransform;
+exports.useVariants = useVariants;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map