@rootnative/inertia 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/index.js

@@ -1,1388 +1,41 @@
 'use strict';
 
-var reactNative = require('react-native');
+var chunkQ6ZTMLTI_js = require('./chunk-Q6ZTMLTI.js');
+var chunkSCTX5Z7I_js = require('./chunk-SCTX5Z7I.js');
+var chunkWZGMAXKC_js = require('./chunk-WZGMAXKC.js');
+var chunkNDKVHL3N_js = require('./chunk-NDKVHL3N.js');
+var chunkOM5FXU4I_js = require('./chunk-OM5FXU4I.js');
+var chunk5I3G43XA_js = require('./chunk-5I3G43XA.js');
+var chunk6UQ4KA6V_js = require('./chunk-6UQ4KA6V.js');
+var chunk6EP3S2PN_js = require('./chunk-6EP3S2PN.js');
+var chunkSFRNO6AW_js = require('./chunk-SFRNO6AW.js');
 var react = require('react');
-var Animated = require('react-native-reanimated');
-var jsxRuntime = require('react/jsx-runtime');
+var reactNativeReanimated = require('react-native-reanimated');
 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
-
-// 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 DEFAULT_MOTION_CONFIG = {
-  reducedMotion: "user",
-  transitions: {}
-};
-var MotionConfigContext = react.createContext(
-  DEFAULT_MOTION_CONFIG
-);
-function useMotionConfig() {
-  return react.useContext(MotionConfigContext);
-}
-function useNamedTransitions() {
-  return useMotionConfig().transitions;
-}
-function useShouldReduceMotion() {
-  const { reducedMotion } = useMotionConfig();
-  const osReduced = Animated.useReducedMotion();
-  if (reducedMotion === "never") return false;
-  if (reducedMotion === "always") return true;
-  return osReduced;
-}
-function MotionConfig({
-  reducedMotion,
-  transitions,
-  children
-}) {
-  const parent = useMotionConfig();
-  const transitionsSig = stableSig(transitions);
-  const value = react.useMemo(
-    () => ({
-      reducedMotion: reducedMotion ?? parent.reducedMotion,
-      transitions: transitions ? { ...parent.transitions, ...transitions } : parent.transitions
-    }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [reducedMotion, transitionsSig, parent]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(MotionConfigContext.Provider, { value, children });
-}
-
-// 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/config/namedTransitions.ts
-var UNKNOWN_NAME_FALLBACK = { type: "spring" };
-function lookupNamedTransition(name, registry) {
-  const cfg = registry[name];
-  if (cfg) return cfg;
-  if (__DEV__) {
-    console.warn(
-      `[inertia] Unknown transition name "${name}" \u2014 falling back to the default spring. Register it on a provider: <MotionConfig transitions={{ '${name}': { ... } }}>.`
-    );
-  }
-  return UNKNOWN_NAME_FALLBACK;
-}
-function resolveNamedTransition(input, registry) {
-  if (input === void 0) return void 0;
-  if (typeof input === "string") return lookupNamedTransition(input, registry);
-  return input;
-}
-function resolveNamedTransitionProp(transition, registry) {
-  if (transition === void 0) return void 0;
-  if (typeof transition === "string") {
-    return lookupNamedTransition(transition, registry);
-  }
-  if (isTopLevelTransition(transition)) return transition;
-  const map = transition;
-  let out = null;
-  for (const key in map) {
-    const value = map[key];
-    if (typeof value === "string") {
-      if (out === null) out = { ...map };
-      out[key] = lookupNamedTransition(value, registry);
-    }
-  }
-  return out ?? transition;
-}
-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 };
-}
-var CSS_KEYWORDS = {
-  ease: [0.25, 0.1, 0.25, 1],
-  "ease-in": [0.42, 0, 1, 1],
-  "ease-out": [0, 0, 0.58, 1],
-  "ease-in-out": [0.42, 0, 0.58, 1]
-};
-var CSS_FUNCTION = /^cubic-bezier\((.*)\)$/;
-function cubicBezier(first, y1, x2, y2) {
-  if (typeof first === "string") return fromCss(first);
-  return bezier(first, y1, x2, y2, void 0);
-}
-function fromCss(input) {
-  const token = input.trim().toLowerCase();
-  if (token === "linear") return Animated.Easing.linear;
-  const keyword = CSS_KEYWORDS[token];
-  if (keyword) return bezier(...keyword, input);
-  const match = CSS_FUNCTION.exec(token);
-  if (!match) {
-    throw new Error(
-      `[inertia] cubicBezier: unsupported easing token ${JSON.stringify(input)}. Expected four numbers, a 'cubic-bezier(x1, y1, x2, y2)' string, or one of the CSS keywords 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out'.`
-    );
-  }
-  const parts = match[1].split(",").map((p) => Number(p.trim()));
-  if (parts.length !== 4 || parts.some((n) => !Number.isFinite(n))) {
-    throw new Error(
-      `[inertia] cubicBezier: could not parse ${JSON.stringify(input)} \u2014 expected exactly four finite numbers inside cubic-bezier(...).`
-    );
-  }
-  return bezier(parts[0], parts[1], parts[2], parts[3], input);
-}
-function bezier(x1, y1, x2, y2, source) {
-  const describe = () => source !== void 0 ? JSON.stringify(source) : `cubicBezier(${x1}, ${y1}, ${x2}, ${y2})`;
-  for (const n of [x1, y1, x2, y2]) {
-    if (typeof n !== "number" || !Number.isFinite(n)) {
-      throw new Error(
-        `[inertia] cubicBezier: ${describe()} \u2014 every control point must be a finite number.`
-      );
-    }
-  }
-  if (x1 < 0 || x1 > 1 || x2 < 0 || x2 > 1) {
-    throw new Error(
-      `[inertia] cubicBezier: ${describe()} \u2014 x1 and x2 must be within [0, 1] (got x1=${x1}, x2=${x2}).`
-    );
-  }
-  return Animated.Easing.bezier(x1, y1, x2, y2);
-}
-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));
-}
-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 (typeof transition === "string") 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 (typeof transition === "string") 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: transitionProp,
-      variants,
-      controller,
-      gesture,
-      layout: layoutProp,
-      layoutId,
-      onAnimationEnd,
-      style,
-      onLayout: userOnLayout,
-      ...rest
-    } = props;
-    const namedTransitions = useNamedTransitions();
-    const transition = resolveNamedTransitionProp(
-      transitionProp,
-      namedTransitions
-    );
-    const layout = typeof layoutProp === "string" ? lookupNamedTransition(layoutProp, namedTransitions) : layoutProp;
-    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
+  View: chunkSCTX5Z7I_js.MotionView,
+  Text: chunkWZGMAXKC_js.MotionText,
+  Image: chunkNDKVHL3N_js.MotionImage,
+  Pressable: chunkOM5FXU4I_js.MotionPressable,
+  ScrollView: chunk5I3G43XA_js.MotionScrollView
 };
 function useAnimation(target, transition) {
-  const output = Animated.useSharedValue(target);
-  const shouldReduceMotion = useShouldReduceMotion();
-  const resolved = resolveNamedTransition(transition, useNamedTransitions());
-  const cfgSig = stableSig(resolved);
+  const output = reactNativeReanimated.useSharedValue(target);
+  const shouldReduceMotion = chunk6EP3S2PN_js.useShouldReduceMotion();
+  const resolved = chunk6EP3S2PN_js.resolveNamedTransition(transition, chunk6EP3S2PN_js.useNamedTransitions());
+  const cfgSig = chunkSFRNO6AW_js.stableSig(resolved);
   react.useEffect(() => {
     const cfg = shouldReduceMotion ? { type: "no-animation" } : resolved ?? { type: "spring" };
-    output.value = resolveTransition(cfg, target);
+    output.value = chunkSFRNO6AW_js.resolveTransition(cfg, target);
   }, [target, cfgSig, shouldReduceMotion]);
   return output;
 }
 function useSpring(target, config) {
-  const spring = resolveSpringInput(config, useNamedTransitions());
+  const spring = resolveSpringInput(config, chunk6EP3S2PN_js.useNamedTransitions());
   const reanimConfig = react.useMemo(
-    () => springToReanimated(spring ?? {}),
+    () => chunkSFRNO6AW_js.springToReanimated(spring ?? {}),
     // 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
@@ -1399,12 +52,12 @@ function useSpring(target, config) {
   );
   const isSharedTarget = isSharedValue(target);
   const initial = isSharedTarget ? target.value : target;
-  const output = Animated.useSharedValue(initial);
+  const output = reactNativeReanimated.useSharedValue(initial);
   react.useEffect(() => {
     if (isSharedTarget) return;
-    output.value = Animated.withSpring(target, reanimConfig);
+    output.value = reactNativeReanimated.withSpring(target, reanimConfig);
   }, [isSharedTarget, target, reanimConfig]);
-  Animated.useAnimatedReaction(
+  reactNativeReanimated.useAnimatedReaction(
     () => {
       "worklet";
       if (!isSharedTarget) return null;
@@ -1413,7 +66,7 @@ function useSpring(target, config) {
     (next, prev) => {
       "worklet";
       if (next === null || next === prev) return;
-      output.value = Animated.withSpring(next, reanimConfig);
+      output.value = reactNativeReanimated.withSpring(next, reanimConfig);
     },
     [isSharedTarget, reanimConfig]
   );
@@ -1421,7 +74,7 @@ function useSpring(target, config) {
 }
 function resolveSpringInput(config, registry) {
   if (typeof config !== "string") return config;
-  const cfg = lookupNamedTransition(config, registry);
+  const cfg = chunk6EP3S2PN_js.lookupNamedTransition(config, registry);
   if (cfg.type === void 0 || cfg.type === "spring") return cfg;
   if (__DEV__) {
     console.warn(
@@ -1442,58 +95,13 @@ function useColorTransition(progress, range, options) {
   const key = options?.key ?? "backgroundColor";
   const from = range[0];
   const to = range[1];
-  return Animated.useAnimatedStyle(() => {
+  return reactNativeReanimated.useAnimatedStyle(() => {
     "worklet";
-    return { [key]: Animated.interpolateColor(progress.value, [0, 1], [from, to]) };
+    return { [key]: reactNativeReanimated.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 resolved = resolveNamedTransitionProp(transition, useNamedTransitions());
-  const setLayer = react.useCallback(
-    (sv, layer, target) => {
-      const cfg = shouldReduceMotion ? { type: "no-animation" } : layerTransition(layer, resolved) ?? { 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);
+  return reactNativeReanimated.useSharedValue(initial);
 }
 function useTransform(arg1, inputRange, outputRange, options) {
   let producer;
@@ -1512,14 +120,14 @@ function useTransform(arg1, inputRange, outputRange, options) {
     const extrapolateRight = mapExtrapolation(options?.extrapolateRight);
     producer = isColor ? () => {
       "worklet";
-      return Animated.interpolateColor(
+      return reactNativeReanimated.interpolateColor(
         source.value,
         input,
         output
       );
     } : () => {
       "worklet";
-      return Animated.interpolate(
+      return reactNativeReanimated.interpolate(
         source.value,
         input,
         output,
@@ -1527,17 +135,17 @@ function useTransform(arg1, inputRange, outputRange, options) {
       );
     };
   }
-  return Animated.useDerivedValue(producer);
+  return reactNativeReanimated.useDerivedValue(producer);
 }
 function mapExtrapolation(mode) {
-  if (mode === "identity") return Animated.Extrapolation.IDENTITY;
-  if (mode === "extend") return Animated.Extrapolation.EXTEND;
-  return Animated.Extrapolation.CLAMP;
+  if (mode === "identity") return reactNativeReanimated.Extrapolation.IDENTITY;
+  if (mode === "extend") return reactNativeReanimated.Extrapolation.EXTEND;
+  return reactNativeReanimated.Extrapolation.CLAMP;
 }
 function useScroll() {
-  const scrollX = Animated.useSharedValue(0);
-  const scrollY = Animated.useSharedValue(0);
-  const handler = Animated.useAnimatedScrollHandler({
+  const scrollX = reactNativeReanimated.useSharedValue(0);
+  const scrollY = reactNativeReanimated.useSharedValue(0);
+  const handler = reactNativeReanimated.useAnimatedScrollHandler({
     onScroll: (event) => {
       "worklet";
       scrollX.value = event.contentOffset.x;
@@ -1572,26 +180,26 @@ function useShadow({
   const offsetWTo = to.shadowOffset?.width ?? 0;
   const offsetHFrom = from.shadowOffset?.height ?? 0;
   const offsetHTo = to.shadowOffset?.height ?? 0;
-  return Animated.useAnimatedStyle(() => {
+  return reactNativeReanimated.useAnimatedStyle(() => {
     "worklet";
     const t = progress.value;
     const out = {};
     if (hasOpacity) {
-      out.shadowOpacity = Animated.interpolate(t, [0, 1], [opacityFrom, opacityTo]);
+      out.shadowOpacity = reactNativeReanimated.interpolate(t, [0, 1], [opacityFrom, opacityTo]);
     }
     if (hasRadius) {
-      out.shadowRadius = Animated.interpolate(t, [0, 1], [radiusFrom, radiusTo]);
+      out.shadowRadius = reactNativeReanimated.interpolate(t, [0, 1], [radiusFrom, radiusTo]);
     }
     if (hasElevation) {
-      out.elevation = Animated.interpolate(t, [0, 1], [elevationFrom, elevationTo]);
+      out.elevation = reactNativeReanimated.interpolate(t, [0, 1], [elevationFrom, elevationTo]);
     }
     if (hasColor) {
-      out.shadowColor = Animated.interpolateColor(t, [0, 1], [colorFrom, colorTo]);
+      out.shadowColor = reactNativeReanimated.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])
+        width: reactNativeReanimated.interpolate(t, [0, 1], [offsetWFrom, offsetWTo]),
+        height: reactNativeReanimated.interpolate(t, [0, 1], [offsetHFrom, offsetHTo])
       };
     }
     return out;
@@ -1630,32 +238,89 @@ function useVariants(variants, initial) {
   }, []);
 }
 
+Object.defineProperty(exports, "useGesture", {
+  enumerable: true,
+  get: function () { return chunkQ6ZTMLTI_js.useGesture; }
+});
+Object.defineProperty(exports, "MotionView", {
+  enumerable: true,
+  get: function () { return chunkSCTX5Z7I_js.MotionView; }
+});
+Object.defineProperty(exports, "MotionText", {
+  enumerable: true,
+  get: function () { return chunkWZGMAXKC_js.MotionText; }
+});
+Object.defineProperty(exports, "MotionImage", {
+  enumerable: true,
+  get: function () { return chunkNDKVHL3N_js.MotionImage; }
+});
+Object.defineProperty(exports, "MotionPressable", {
+  enumerable: true,
+  get: function () { return chunkOM5FXU4I_js.MotionPressable; }
+});
+Object.defineProperty(exports, "MotionScrollView", {
+  enumerable: true,
+  get: function () { return chunk5I3G43XA_js.MotionScrollView; }
+});
+Object.defineProperty(exports, "Presence", {
+  enumerable: true,
+  get: function () { return chunk6UQ4KA6V_js.Presence; }
+});
+Object.defineProperty(exports, "createMotionComponent", {
+  enumerable: true,
+  get: function () { return chunk6UQ4KA6V_js.createMotionComponent; }
+});
+Object.defineProperty(exports, "usePresence", {
+  enumerable: true,
+  get: function () { return chunk6UQ4KA6V_js.usePresence; }
+});
+Object.defineProperty(exports, "MotionConfig", {
+  enumerable: true,
+  get: function () { return chunk6EP3S2PN_js.MotionConfig; }
+});
+Object.defineProperty(exports, "resolveNamedTransition", {
+  enumerable: true,
+  get: function () { return chunk6EP3S2PN_js.resolveNamedTransition; }
+});
+Object.defineProperty(exports, "useMotionConfig", {
+  enumerable: true,
+  get: function () { return chunk6EP3S2PN_js.useMotionConfig; }
+});
+Object.defineProperty(exports, "useNamedTransitions", {
+  enumerable: true,
+  get: function () { return chunk6EP3S2PN_js.useNamedTransitions; }
+});
+Object.defineProperty(exports, "useShouldReduceMotion", {
+  enumerable: true,
+  get: function () { return chunk6EP3S2PN_js.useShouldReduceMotion; }
+});
+Object.defineProperty(exports, "buildReleaseAnimation", {
+  enumerable: true,
+  get: function () { return chunkSFRNO6AW_js.buildReleaseAnimation; }
+});
+Object.defineProperty(exports, "cubicBezier", {
+  enumerable: true,
+  get: function () { return chunkSFRNO6AW_js.cubicBezier; }
+});
+Object.defineProperty(exports, "ensureWorkletEasing", {
+  enumerable: true,
+  get: function () { return chunkSFRNO6AW_js.ensureWorkletEasing; }
+});
+Object.defineProperty(exports, "resolveAnimatableValue", {
+  enumerable: true,
+  get: function () { return chunkSFRNO6AW_js.resolveAnimatableValue; }
+});
+Object.defineProperty(exports, "resolveTransition", {
+  enumerable: true,
+  get: function () { return chunkSFRNO6AW_js.resolveTransition; }
+});
 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.cubicBezier = cubicBezier;
-exports.ensureWorkletEasing = ensureWorkletEasing;
-exports.resolveAnimatableValue = resolveAnimatableValue;
-exports.resolveNamedTransition = resolveNamedTransition;
-exports.resolveTransition = resolveTransition;
 exports.useAnimation = useAnimation;
 exports.useBooleanSpring = useBooleanSpring;
 exports.useColorTransition = useColorTransition;
-exports.useGesture = useGesture;
-exports.useMotionConfig = useMotionConfig;
 exports.useMotionValue = useMotionValue;
-exports.useNamedTransitions = useNamedTransitions;
-exports.usePresence = usePresence;
 exports.useScroll = useScroll;
 exports.useShadow = useShadow;
-exports.useShouldReduceMotion = useShouldReduceMotion;
 exports.useSpring = useSpring;
 exports.useTransform = useTransform;
 exports.useVariants = useVariants;