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

package/dist/index.d.ts

@@ -250,15 +250,15 @@ declare function cubicBezier(css: string): EasingInput;
 /**
  * Reanimated 3.9+ validates that easing functions used in nested-transition
  * contexts (variants, sequences, per-property maps) are worklets, and crashes
- * with `[Reanimated] The easing function is not a worklet` otherwise. The
- * library accepts plain functions on the public surface; this helper wraps
- * them so consumers don't have to think about the worklet boundary.
+ * with `[Reanimated] The easing function is not a worklet` otherwise.
  *
- * If the input is already a worklet (has been processed by the worklets babel
- * plugin), it's returned as-is. Otherwise it's wrapped in a function whose
- * body declares the `'worklet'` directive — when our source is processed by
- * the consumer's worklets babel plugin (the default Expo/RN setup), the
- * wrapper becomes a real worklet that captures the user fn via closure.
+ * Custom easing functions MUST therefore be worklets — put the `'worklet'`
+ * directive as the function's first statement (Reanimated's built-in
+ * `Easing.*` helpers and inertia's `cubicBezier()` already are). A plain
+ * function warns in dev and falls back to a directive-wrapped call-through;
+ * that wrapper works on web (single-threaded) but its closure holds the
+ * opaque plain function, which native builds reject when the transition's
+ * config is serialized to the UI thread.
  *
  * Reanimated 4 changed `Easing.bezier(...)` to return an
  * `EasingFunctionFactory` (`{ factory: () => EasingFunction }`) rather than
@@ -479,9 +479,17 @@ interface UseTransformOptions {
  * const distance = useTransform(() => Math.sqrt(x.value ** 2 + y.value ** 2))
  * ```
  *
- * The transformer must be a worklet (or a plain function we auto-wrap —
- * see the easing wrapper for the rationale). It runs on the UI thread on
- * every frame where any read shared value changes.
+ * The transformer MUST be a worklet — put the `'worklet'` directive as its
+ * first statement so the consumer's Babel plugin captures the shared values
+ * it reads as its closure. It runs on the UI thread on every frame where
+ * any read shared value changes.
+ *
+ * A plain function cannot work here, and the hook warns in dev when it gets
+ * one: the best-effort wrapper it falls back to closes over the opaque
+ * function reference, not the shared values read inside it, so Reanimated
+ * can't track them as dependencies — the derived value only refreshes on
+ * React re-renders, and native builds reject the plain function when the
+ * closure crosses to the UI thread.
  */
 declare function useTransform<T>(transformer: () => T): SharedValue<T>;
 /**
@@ -547,11 +555,42 @@ interface UseScrollResult {
  */
 declare function useScroll(): UseScrollResult;
 
+/**
+ * CSS `box-shadow` parsing + pairing for `useShadow`.
+ *
+ * Design systems store web elevation tokens as CSS `box-shadow` strings
+ * (`'0px 1px 2px rgba(0,0,0,0.3), 0px 1px 3px 1px rgba(0,0,0,0.15)'`).
+ * Like `cubicBezier`, this module makes those tokens directly consumable:
+ * strings are parsed once on the JS thread into flat layer records the
+ * `useShadow` worklet can interpolate without any frame-time string work.
+ *
+ * Invalid input **throws** rather than warning — shadow tokens are
+ * constructed at theme/module setup, and a malformed token should fail
+ * loudly there, not silently render the wrong elevation.
+ */
+/**
+ * One layer of a `box-shadow`, structurally mirroring React Native's
+ * `BoxShadowValue` (RN 0.76+ `boxShadow` style). Lengths are px numbers.
+ */
+interface BoxShadowLayer {
+    offsetX: number;
+    offsetY: number;
+    /** Must be >= 0, per CSS. @default 0 */
+    blurRadius?: number;
+    /** @default 0 */
+    spreadDistance?: number;
+    /** Any color string Reanimated's `interpolateColor` accepts. @default 'black' */
+    color?: string;
+    /** @default false */
+    inset?: boolean;
+}
+
 /**
  * Shape accepted on either end of a `useShadow` tween. Every field is
  * optional — only keys present on at least one side participate in the
  * output style. Mirrors the flat shadow keys on `Motion.View`'s `animate`
- * surface, plus the nested `shadowOffset` source.
+ * surface, plus the nested `shadowOffset` source and the CSS `boxShadow`
+ * surface.
  */
 interface ShadowConfig {
     shadowOpacity?: number;
@@ -563,6 +602,19 @@ interface ShadowConfig {
     /** Android elevation. iOS shadow consumers can leave this off. */
     elevation?: number;
     shadowColor?: string;
+    /**
+     * CSS `box-shadow` — the shadow surface on web (react-native-web passes
+     * it through as CSS) and on React Native 0.76+ new-architecture native.
+     * Accepts the CSS string form design systems store elevation tokens in
+     * (`'0px 1px 2px rgba(0,0,0,0.3), 0px 1px 3px 1px rgba(0,0,0,0.15)'`;
+     * px lengths only) or structured layers. Multi-layer shadows interpolate
+     * per layer; when one side has fewer layers, it is padded with invisible
+     * layers, CSS-transition style. A malformed string **throws** at render
+     * (like `cubicBezier` — token mistakes should fail loudly at setup).
+     * The classic `shadow*`/`elevation` keys don't reach the web renderer —
+     * provide `boxShadow` alongside them when the tween must show up there.
+     */
+    boxShadow?: string | readonly BoxShadowLayer[];
 }
 interface UseShadowOptions {
     /** Shadow state at `progress === 0`. */
@@ -599,6 +651,19 @@ interface UseShadowOptions {
  * `shadowColor`, `{ width: 0, height: 0 }` for `shadowOffset`). This is a
  * pure interpolator — to "animate" the shadow, drive `progress` with a
  * spring, timing, or gesture upstream.
+ *
+ * The classic `shadow*`/`elevation` keys don't render on web. When the
+ * tween must show up there (or on RN 0.76+ new-arch native via the CSS
+ * shadow model), provide `boxShadow` on both ends — CSS string tokens or
+ * structured layers; multi-layer shadows interpolate per layer:
+ *
+ * ```tsx
+ * const shadowStyle = useShadow({
+ *   from: { boxShadow: theme.elevation.level1 }, // '0px 1px 2px rgba(0,0,0,0.3), 0px 1px 3px 1px rgba(0,0,0,0.15)'
+ *   to:   { boxShadow: theme.elevation.level2 },
+ *   progress,
+ * })
+ * ```
  */
 declare function useShadow({ from, to, progress, }: UseShadowOptions): ReturnType<typeof useAnimatedStyle>;
 
@@ -615,4 +680,4 @@ declare function useShadow({ from, to, progress, }: UseShadowOptions): ReturnTyp
  */
 declare function useVariants<V extends Readonly<Record<string, object>>>(variants: V, initial?: keyof V & string): VariantController<keyof V & string>;
 
-export { AnimatableValue, type ColorStyleKey, EasingInput, type ExtrapolationMode, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, NamedTransitions, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, TransitionConfig, TransitionInput, TransitionName, type UseColorTransitionOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useBooleanSpring, useColorTransition, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useTransform, useVariants };
+export { AnimatableValue, type BoxShadowLayer, type ColorStyleKey, EasingInput, type ExtrapolationMode, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, NamedTransitions, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, TransitionConfig, TransitionInput, TransitionName, type UseColorTransitionOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useBooleanSpring, useColorTransition, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useTransform, useVariants };

package/dist/index.js

@@ -1,41 +1,41 @@
 'use strict';
 
-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 chunk4PEHWDAZ_js = require('./chunk-4PEHWDAZ.js');
+var chunk4QGXK6TF_js = require('./chunk-4QGXK6TF.js');
+var chunkZ7HIOFKQ_js = require('./chunk-Z7HIOFKQ.js');
+var chunk3UTJJ4A3_js = require('./chunk-3UTJJ4A3.js');
+var chunkTDSO63CJ_js = require('./chunk-TDSO63CJ.js');
+var chunk2HYD2ZBK_js = require('./chunk-2HYD2ZBK.js');
+var chunk7UDYEFBU_js = require('./chunk-7UDYEFBU.js');
+var chunk7AOERN53_js = require('./chunk-7AOERN53.js');
+var chunkPTRF47DA_js = require('./chunk-PTRF47DA.js');
 var react = require('react');
 var reactNativeReanimated = require('react-native-reanimated');
 var reactNativeWorklets = require('react-native-worklets');
 
 // src/motion/index.ts
 var Motion = {
-  View: chunkSCTX5Z7I_js.MotionView,
-  Text: chunkWZGMAXKC_js.MotionText,
-  Image: chunkNDKVHL3N_js.MotionImage,
-  Pressable: chunkOM5FXU4I_js.MotionPressable,
-  ScrollView: chunk5I3G43XA_js.MotionScrollView
+  View: chunk4QGXK6TF_js.MotionView,
+  Text: chunkZ7HIOFKQ_js.MotionText,
+  Image: chunk3UTJJ4A3_js.MotionImage,
+  Pressable: chunkTDSO63CJ_js.MotionPressable,
+  ScrollView: chunk2HYD2ZBK_js.MotionScrollView
 };
 function useAnimation(target, transition) {
   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);
+  const shouldReduceMotion = chunk7AOERN53_js.useShouldReduceMotion();
+  const resolved = chunk7AOERN53_js.resolveNamedTransition(transition, chunk7AOERN53_js.useNamedTransitions());
+  const cfgSig = chunkPTRF47DA_js.stableSig(resolved);
   react.useEffect(() => {
     const cfg = shouldReduceMotion ? { type: "no-animation" } : resolved ?? { type: "spring" };
-    output.value = chunkSFRNO6AW_js.resolveTransition(cfg, target);
+    output.value = chunkPTRF47DA_js.resolveTransition(cfg, target);
   }, [target, cfgSig, shouldReduceMotion]);
   return output;
 }
 function useSpring(target, config) {
-  const spring = resolveSpringInput(config, chunk6EP3S2PN_js.useNamedTransitions());
+  const spring = resolveSpringInput(config, chunk7AOERN53_js.useNamedTransitions());
   const reanimConfig = react.useMemo(
-    () => chunkSFRNO6AW_js.springToReanimated(spring ?? {}),
+    () => chunkPTRF47DA_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
@@ -74,7 +74,7 @@ function useSpring(target, config) {
 }
 function resolveSpringInput(config, registry) {
   if (typeof config !== "string") return config;
-  const cfg = chunk6EP3S2PN_js.lookupNamedTransition(config, registry);
+  const cfg = chunk7AOERN53_js.lookupNamedTransition(config, registry);
   if (cfg.type === void 0 || cfg.type === "spring") return cfg;
   if (__DEV__) {
     console.warn(
@@ -107,10 +107,18 @@ function useTransform(arg1, inputRange, outputRange, options) {
   let producer;
   if (typeof arg1 === "function") {
     const userFn = arg1;
-    producer = reactNativeWorklets.isWorkletFunction(userFn) ? userFn : () => {
-      "worklet";
-      return userFn();
-    };
+    if (reactNativeWorklets.isWorkletFunction(userFn)) {
+      producer = userFn;
+    } else {
+      chunkPTRF47DA_js.warnNonWorkletOnce(
+        "useTransform-transformer",
+        "[inertia] useTransform: the transformer is not a worklet, so the shared values it reads can't be tracked as dependencies \u2014 the derived value will only refresh on React re-renders, and native builds reject plain functions on the UI thread. Add the 'worklet' directive as the first statement of the transformer."
+      );
+      producer = () => {
+        "worklet";
+        return userFn();
+      };
+    }
   } else {
     const source = arg1;
     const input = inputRange;
@@ -158,6 +166,127 @@ function useScroll() {
     onScroll: handler
   };
 }
+
+// src/internal/boxShadow.ts
+var LENGTH = /^[+-]?(\d+\.?\d*|\.\d+)(px)?$/i;
+var UNIT_LIKE = /^[+-]?(\d+\.?\d*|\.\d+)[a-z%]+$/i;
+function invalid(input, reason) {
+  return new Error(
+    `[inertia] parseBoxShadow: ${reason} in ${JSON.stringify(input)}. Expected CSS box-shadow syntax with px lengths: '[inset] <offset-x> <offset-y> [blur] [spread] [color], ...'`
+  );
+}
+function splitLayers(input) {
+  const layers = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "," && depth === 0) {
+      layers.push(input.slice(start, i));
+      start = i + 1;
+    }
+  }
+  layers.push(input.slice(start));
+  return layers;
+}
+function tokenize(layer) {
+  const tokens = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of layer) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (depth === 0 && /\s/.test(ch)) {
+      if (current) tokens.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+function parseBoxShadow(input) {
+  const trimmed = input.trim();
+  if (trimmed === "") throw invalid(input, "empty string");
+  if (trimmed.toLowerCase() === "none") return [];
+  return splitLayers(trimmed).map((layerString) => {
+    const tokens = tokenize(layerString.trim());
+    if (tokens.length === 0) throw invalid(input, "empty layer");
+    const lengths = [];
+    let color;
+    let inset = false;
+    for (const token of tokens) {
+      if (token.toLowerCase() === "inset") {
+        if (inset) throw invalid(input, "duplicate 'inset'");
+        inset = true;
+      } else if (LENGTH.test(token)) {
+        lengths.push(parseFloat(token));
+      } else if (UNIT_LIKE.test(token)) {
+        throw invalid(input, `unsupported unit in ${JSON.stringify(token)}`);
+      } else {
+        if (color !== void 0) throw invalid(input, "multiple colors");
+        color = token;
+      }
+    }
+    if (lengths.length < 2 || lengths.length > 4) {
+      throw invalid(input, `expected 2-4 lengths, got ${lengths.length}`);
+    }
+    const [offsetX = 0, offsetY = 0, blurRadius = 0, spreadDistance = 0] = lengths;
+    if (blurRadius < 0) throw invalid(input, "negative blur radius");
+    return {
+      offsetX,
+      offsetY,
+      blurRadius,
+      spreadDistance,
+      color: color ?? "black",
+      inset
+    };
+  });
+}
+function resolveBoxShadowInput(input) {
+  if (input === void 0) return [];
+  if (typeof input === "string") return parseBoxShadow(input);
+  return input.map((layer) => ({
+    offsetX: layer.offsetX,
+    offsetY: layer.offsetY,
+    blurRadius: layer.blurRadius ?? 0,
+    spreadDistance: layer.spreadDistance ?? 0,
+    color: layer.color ?? "black",
+    inset: layer.inset ?? false
+  }));
+}
+function pairBoxShadowLayers(from, to) {
+  const count = Math.max(from.length, to.length);
+  const pairs = [];
+  for (let i = 0; i < count; i++) {
+    const a = from[i];
+    const b = to[i];
+    const fromLayer = a ?? invisibleLayer(b.inset);
+    const toLayer = b ?? invisibleLayer(a.inset);
+    if (fromLayer.inset !== toLayer.inset) {
+      throw new Error(
+        `[inertia] useShadow: boxShadow layer ${i} is 'inset' on one side but not the other \u2014 inset cannot be interpolated. Give both sides the same inset-ness (pad with a transparent layer if needed).`
+      );
+    }
+    pairs.push({ from: fromLayer, to: toLayer });
+  }
+  return pairs;
+}
+function invisibleLayer(inset) {
+  return {
+    offsetX: 0,
+    offsetY: 0,
+    blurRadius: 0,
+    spreadDistance: 0,
+    color: "transparent",
+    inset
+  };
+}
+
+// src/values/useShadow.ts
 function useShadow({
   from,
   to,
@@ -168,6 +297,10 @@ function useShadow({
   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 boxShadowPairs = from.boxShadow !== void 0 || to.boxShadow !== void 0 ? pairBoxShadowLayers(
+    resolveBoxShadowInput(from.boxShadow),
+    resolveBoxShadowInput(to.boxShadow)
+  ) : [];
   const opacityFrom = from.shadowOpacity ?? 0;
   const opacityTo = to.shadowOpacity ?? 0;
   const radiusFrom = from.shadowRadius ?? 0;
@@ -202,6 +335,31 @@ function useShadow({
         height: reactNativeReanimated.interpolate(t, [0, 1], [offsetHFrom, offsetHTo])
       };
     }
+    if (boxShadowPairs.length > 0) {
+      let css = "";
+      let first = true;
+      for (const pair of boxShadowPairs) {
+        const x = reactNativeReanimated.interpolate(t, [0, 1], [pair.from.offsetX, pair.to.offsetX]);
+        const y = reactNativeReanimated.interpolate(t, [0, 1], [pair.from.offsetY, pair.to.offsetY]);
+        const blur = Math.max(
+          0,
+          reactNativeReanimated.interpolate(t, [0, 1], [pair.from.blurRadius, pair.to.blurRadius])
+        );
+        const spread = reactNativeReanimated.interpolate(
+          t,
+          [0, 1],
+          [pair.from.spreadDistance, pair.to.spreadDistance]
+        );
+        const color = reactNativeReanimated.interpolateColor(
+          t,
+          [0, 1],
+          [pair.from.color, pair.to.color]
+        );
+        css += (first ? "" : ", ") + (pair.from.inset ? "inset " : "") + `${x}px ${y}px ${blur}px ${spread}px ${color}`;
+        first = false;
+      }
+      out.boxShadow = css;
+    }
     return out;
   });
 }
@@ -240,79 +398,79 @@ function useVariants(variants, initial) {
 
 Object.defineProperty(exports, "useGesture", {
   enumerable: true,
-  get: function () { return chunkQ6ZTMLTI_js.useGesture; }
+  get: function () { return chunk4PEHWDAZ_js.useGesture; }
 });
 Object.defineProperty(exports, "MotionView", {
   enumerable: true,
-  get: function () { return chunkSCTX5Z7I_js.MotionView; }
+  get: function () { return chunk4QGXK6TF_js.MotionView; }
 });
 Object.defineProperty(exports, "MotionText", {
   enumerable: true,
-  get: function () { return chunkWZGMAXKC_js.MotionText; }
+  get: function () { return chunkZ7HIOFKQ_js.MotionText; }
 });
 Object.defineProperty(exports, "MotionImage", {
   enumerable: true,
-  get: function () { return chunkNDKVHL3N_js.MotionImage; }
+  get: function () { return chunk3UTJJ4A3_js.MotionImage; }
 });
 Object.defineProperty(exports, "MotionPressable", {
   enumerable: true,
-  get: function () { return chunkOM5FXU4I_js.MotionPressable; }
+  get: function () { return chunkTDSO63CJ_js.MotionPressable; }
 });
 Object.defineProperty(exports, "MotionScrollView", {
   enumerable: true,
-  get: function () { return chunk5I3G43XA_js.MotionScrollView; }
+  get: function () { return chunk2HYD2ZBK_js.MotionScrollView; }
 });
 Object.defineProperty(exports, "Presence", {
   enumerable: true,
-  get: function () { return chunk6UQ4KA6V_js.Presence; }
+  get: function () { return chunk7UDYEFBU_js.Presence; }
 });
 Object.defineProperty(exports, "createMotionComponent", {
   enumerable: true,
-  get: function () { return chunk6UQ4KA6V_js.createMotionComponent; }
+  get: function () { return chunk7UDYEFBU_js.createMotionComponent; }
 });
 Object.defineProperty(exports, "usePresence", {
   enumerable: true,
-  get: function () { return chunk6UQ4KA6V_js.usePresence; }
+  get: function () { return chunk7UDYEFBU_js.usePresence; }
 });
 Object.defineProperty(exports, "MotionConfig", {
   enumerable: true,
-  get: function () { return chunk6EP3S2PN_js.MotionConfig; }
+  get: function () { return chunk7AOERN53_js.MotionConfig; }
 });
 Object.defineProperty(exports, "resolveNamedTransition", {
   enumerable: true,
-  get: function () { return chunk6EP3S2PN_js.resolveNamedTransition; }
+  get: function () { return chunk7AOERN53_js.resolveNamedTransition; }
 });
 Object.defineProperty(exports, "useMotionConfig", {
   enumerable: true,
-  get: function () { return chunk6EP3S2PN_js.useMotionConfig; }
+  get: function () { return chunk7AOERN53_js.useMotionConfig; }
 });
 Object.defineProperty(exports, "useNamedTransitions", {
   enumerable: true,
-  get: function () { return chunk6EP3S2PN_js.useNamedTransitions; }
+  get: function () { return chunk7AOERN53_js.useNamedTransitions; }
 });
 Object.defineProperty(exports, "useShouldReduceMotion", {
   enumerable: true,
-  get: function () { return chunk6EP3S2PN_js.useShouldReduceMotion; }
+  get: function () { return chunk7AOERN53_js.useShouldReduceMotion; }
 });
 Object.defineProperty(exports, "buildReleaseAnimation", {
   enumerable: true,
-  get: function () { return chunkSFRNO6AW_js.buildReleaseAnimation; }
+  get: function () { return chunkPTRF47DA_js.buildReleaseAnimation; }
 });
 Object.defineProperty(exports, "cubicBezier", {
   enumerable: true,
-  get: function () { return chunkSFRNO6AW_js.cubicBezier; }
+  get: function () { return chunkPTRF47DA_js.cubicBezier; }
 });
 Object.defineProperty(exports, "ensureWorkletEasing", {
   enumerable: true,
-  get: function () { return chunkSFRNO6AW_js.ensureWorkletEasing; }
+  get: function () { return chunkPTRF47DA_js.ensureWorkletEasing; }
 });
 Object.defineProperty(exports, "resolveAnimatableValue", {
   enumerable: true,
-  get: function () { return chunkSFRNO6AW_js.resolveAnimatableValue; }
+  get: function () { return chunkPTRF47DA_js.resolveAnimatableValue; }
 });
 Object.defineProperty(exports, "resolveTransition", {
   enumerable: true,
-  get: function () { return chunkSFRNO6AW_js.resolveTransition; }
+  get: function () { return chunkPTRF47DA_js.resolveTransition; }
 });
 exports.Motion = Motion;
 exports.useAnimation = useAnimation;