motion-v 0.3.0 → 0.4.0

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs

@@ -1,30 +1,37 @@
-import { easeInOut as c } from "../../easing/ease.mjs";
-import { isEasingArray as p } from "../../easing/utils/is-easing-array.mjs";
-import { easingDefinitionToFunction as m } from "../../easing/utils/map.mjs";
-import { interpolate as u } from "../../utils/interpolate.mjs";
-import { defaultOffset as l } from "../../utils/offsets/default.mjs";
-import { convertOffsetToTimes as g } from "../../utils/offsets/time.mjs";
-function T(n, t) {
-  return n.map(() => t || c).splice(0, n.length - 1);
+import { easeInOut } from "../../easing/ease.mjs";
+import { isEasingArray } from "../../easing/utils/is-easing-array.mjs";
+import { easingDefinitionToFunction } from "../../easing/utils/map.mjs";
+import { interpolate } from "../../utils/interpolate.mjs";
+import { defaultOffset } from "../../utils/offsets/default.mjs";
+import { convertOffsetToTimes } from "../../utils/offsets/time.mjs";
+function defaultEasing(values, easing) {
+  return values.map(() => easing || easeInOut).splice(0, values.length - 1);
 }
-function y({ duration: n = 300, keyframes: t, times: o, ease: r = "easeInOut" }) {
-  const e = p(r) ? r.map(m) : m(r), i = {
-    done: !1,
-    value: t[0]
-  }, s = g(
+function keyframes({ duration = 300, keyframes: keyframeValues, times, ease = "easeInOut" }) {
+  const easingFunctions = isEasingArray(ease) ? ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(ease);
+  const state = {
+    done: false,
+    value: keyframeValues[0]
+  };
+  const absoluteTimes = convertOffsetToTimes(
     // Only use the provided offsets if they're the correct length
     // TODO Maybe we should warn here if there's a length mismatch
-    o && o.length === t.length ? o : l(t),
-    n
-  ), a = u(s, t, {
-    ease: Array.isArray(e) ? e : T(t, e)
+    times && times.length === keyframeValues.length ? times : defaultOffset(keyframeValues),
+    duration
+  );
+  const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {
+    ease: Array.isArray(easingFunctions) ? easingFunctions : defaultEasing(keyframeValues, easingFunctions)
   });
   return {
-    calculatedDuration: n,
-    next: (f) => (i.value = a(f), i.done = f >= n, i)
+    calculatedDuration: duration,
+    next: (t) => {
+      state.value = mapTimeToKeyframe(t);
+      state.done = t >= duration;
+      return state;
+    }
   };
 }
 export {
-  T as defaultEasing,
-  y as keyframes
+  defaultEasing,
+  keyframes
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs

@@ -1,55 +1,83 @@
-import { warning as N } from "../../../utils/errors.mjs";
-import { clamp as h } from "../../../utils/clamp.mjs";
-import { secondsToMilliseconds as g, millisecondsToSeconds as T } from "../../../utils/time-conversion.mjs";
-const M = 1e-3, A = 0.01, D = 10, G = 0.05, I = 1;
-function E({ duration: t = 800, bounce: i = 0.25, velocity: c = 0, mass: o = 1 }) {
-  let a, p;
-  N(t <= g(D), "Spring duration must be 10 seconds or less");
-  let s = 1 - i;
-  s = h(G, I, s), t = h(A, D, T(t)), s < 1 ? (a = (n) => {
-    const r = n * s, e = r * t, l = r - c, f = w(n, s), m = Math.exp(-e);
-    return M - l / f * m;
-  }, p = (n) => {
-    const e = n * s * t, l = e * c + c, f = Math.pow(s, 2) * Math.pow(n, 2) * t, m = Math.exp(-e), S = w(Math.pow(n, 2), s);
-    return (-a(n) + M > 0 ? -1 : 1) * ((l - f) * m) / S;
-  }) : (a = (n) => {
-    const r = Math.exp(-n * t), e = (n - c) * t + 1;
-    return -M + r * e;
-  }, p = (n) => {
-    const r = Math.exp(-n * t), e = (c - n) * (t * t);
-    return r * e;
-  });
-  const b = 5 / t, x = j(a, p, b);
-  if (t = g(t), isNaN(x))
+import { warning } from "../../../utils/errors.mjs";
+import { clamp } from "../../../utils/clamp.mjs";
+import { secondsToMilliseconds, millisecondsToSeconds } from "../../../utils/time-conversion.mjs";
+const safeMin = 1e-3;
+const minDuration = 0.01;
+const maxDuration = 10;
+const minDamping = 0.05;
+const maxDamping = 1;
+function findSpring({ duration = 800, bounce = 0.25, velocity = 0, mass = 1 }) {
+  let envelope;
+  let derivative;
+  warning(duration <= secondsToMilliseconds(maxDuration), "Spring duration must be 10 seconds or less");
+  let dampingRatio = 1 - bounce;
+  dampingRatio = clamp(minDamping, maxDamping, dampingRatio);
+  duration = clamp(minDuration, maxDuration, millisecondsToSeconds(duration));
+  if (dampingRatio < 1) {
+    envelope = (undampedFreq2) => {
+      const exponentialDecay = undampedFreq2 * dampingRatio;
+      const delta = exponentialDecay * duration;
+      const a = exponentialDecay - velocity;
+      const b = calcAngularFreq(undampedFreq2, dampingRatio);
+      const c = Math.exp(-delta);
+      return safeMin - a / b * c;
+    };
+    derivative = (undampedFreq2) => {
+      const exponentialDecay = undampedFreq2 * dampingRatio;
+      const delta = exponentialDecay * duration;
+      const d = delta * velocity + velocity;
+      const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq2, 2) * duration;
+      const f = Math.exp(-delta);
+      const g = calcAngularFreq(Math.pow(undampedFreq2, 2), dampingRatio);
+      const factor = -envelope(undampedFreq2) + safeMin > 0 ? -1 : 1;
+      return factor * ((d - e) * f) / g;
+    };
+  } else {
+    envelope = (undampedFreq2) => {
+      const a = Math.exp(-undampedFreq2 * duration);
+      const b = (undampedFreq2 - velocity) * duration + 1;
+      return -safeMin + a * b;
+    };
+    derivative = (undampedFreq2) => {
+      const a = Math.exp(-undampedFreq2 * duration);
+      const b = (velocity - undampedFreq2) * (duration * duration);
+      return a * b;
+    };
+  }
+  const initialGuess = 5 / duration;
+  const undampedFreq = approximateRoot(envelope, derivative, initialGuess);
+  duration = secondsToMilliseconds(duration);
+  if (isNaN(undampedFreq)) {
     return {
       stiffness: 100,
       damping: 10,
-      duration: t
+      duration
     };
-  {
-    const n = Math.pow(x, 2) * o;
+  } else {
+    const stiffness = Math.pow(undampedFreq, 2) * mass;
     return {
-      stiffness: n,
-      damping: s * 2 * Math.sqrt(o * n),
-      duration: t
+      stiffness,
+      damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),
+      duration
     };
   }
 }
-const R = 12;
-function j(t, i, c) {
-  let o = c;
-  for (let a = 1; a < R; a++)
-    o = o - t(o) / i(o);
-  return o;
+const rootIterations = 12;
+function approximateRoot(envelope, derivative, initialGuess) {
+  let result = initialGuess;
+  for (let i = 1; i < rootIterations; i++) {
+    result = result - envelope(result) / derivative(result);
+  }
+  return result;
 }
-function w(t, i) {
-  return t * Math.sqrt(1 - i * i);
+function calcAngularFreq(undampedFreq, dampingRatio) {
+  return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
 }
 export {
-  w as calcAngularFreq,
-  E as findSpring,
-  I as maxDamping,
-  D as maxDuration,
-  G as minDamping,
-  A as minDuration
+  calcAngularFreq,
+  findSpring,
+  maxDamping,
+  maxDuration,
+  minDamping,
+  minDuration
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs

@@ -1,67 +1,83 @@
-import { millisecondsToSeconds as F, secondsToMilliseconds as R } from "../../../utils/time-conversion.mjs";
-import { calcGeneratorVelocity as S } from "../utils/velocity.mjs";
-import { findSpring as V, calcAngularFreq as A } from "./find.mjs";
-const w = ["duration", "bounce"], B = ["stiffness", "damping", "mass"];
-function T(e, s) {
-  return s.some((r) => e[r] !== void 0);
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../../utils/time-conversion.mjs";
+import { calcGeneratorVelocity } from "../utils/velocity.mjs";
+import { findSpring, calcAngularFreq } from "./find.mjs";
+const durationKeys = ["duration", "bounce"];
+const physicsKeys = ["stiffness", "damping", "mass"];
+function isSpringType(options, keys) {
+  return keys.some((key) => options[key] !== void 0);
 }
-function G(e) {
-  let s = {
+function getSpringOptions(options) {
+  let springOptions = {
     velocity: 0,
     stiffness: 100,
     damping: 10,
     mass: 1,
-    isResolvedFromDuration: !1,
-    ...e
+    isResolvedFromDuration: false,
+    ...options
   };
-  if (!T(e, B) && T(e, w)) {
-    const r = V(e);
-    s = {
-      ...s,
-      ...r,
+  if (!isSpringType(options, physicsKeys) && isSpringType(options, durationKeys)) {
+    const derived = findSpring(options);
+    springOptions = {
+      ...springOptions,
+      ...derived,
       mass: 1
-    }, s.isResolvedFromDuration = !0;
+    };
+    springOptions.isResolvedFromDuration = true;
   }
-  return s;
+  return springOptions;
 }
-function z({ keyframes: e, restDelta: s, restSpeed: r, ...f }) {
-  const p = e[0], c = e[e.length - 1], u = { done: !1, value: p }, { stiffness: g, damping: x, mass: M, duration: v, velocity: b, isResolvedFromDuration: y } = G({
-    ...f,
-    velocity: -F(f.velocity || 0)
-  }), h = b || 0, t = x / (2 * Math.sqrt(g * M)), a = c - p, i = F(Math.sqrt(g / M)), q = Math.abs(a) < 5;
-  r || (r = q ? 0.01 : 2), s || (s = q ? 5e-3 : 0.5);
-  let d;
-  if (t < 1) {
-    const n = A(i, t);
-    d = (o) => {
-      const l = Math.exp(-t * i * o);
-      return c - l * ((h + t * i * a) / n * Math.sin(n * o) + a * Math.cos(n * o));
+function spring({ keyframes, restDelta, restSpeed, ...options }) {
+  const origin = keyframes[0];
+  const target = keyframes[keyframes.length - 1];
+  const state = { done: false, value: origin };
+  const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration } = getSpringOptions({
+    ...options,
+    velocity: -millisecondsToSeconds(options.velocity || 0)
+  });
+  const initialVelocity = velocity || 0;
+  const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
+  const initialDelta = target - origin;
+  const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));
+  const isGranularScale = Math.abs(initialDelta) < 5;
+  restSpeed || (restSpeed = isGranularScale ? 0.01 : 2);
+  restDelta || (restDelta = isGranularScale ? 5e-3 : 0.5);
+  let resolveSpring;
+  if (dampingRatio < 1) {
+    const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
+    resolveSpring = (t) => {
+      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+      return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq * Math.sin(angularFreq * t) + initialDelta * Math.cos(angularFreq * t));
     };
-  } else if (t === 1)
-    d = (n) => c - Math.exp(-i * n) * (a + (h + i * a) * n);
-  else {
-    const n = i * Math.sqrt(t * t - 1);
-    d = (o) => {
-      const l = Math.exp(-t * i * o), m = Math.min(n * o, 300);
-      return c - l * ((h + t * i * a) * Math.sinh(m) + n * a * Math.cosh(m)) / n;
+  } else if (dampingRatio === 1) {
+    resolveSpring = (t) => target - Math.exp(-undampedAngularFreq * t) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t);
+  } else {
+    const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
+    resolveSpring = (t) => {
+      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+      const freqForT = Math.min(dampedAngularFreq * t, 300);
+      return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq;
     };
   }
   return {
-    calculatedDuration: y && v || null,
-    next: (n) => {
-      const o = d(n);
-      if (y)
-        u.done = n >= v;
-      else {
-        let l = 0;
-        t < 1 && (l = n === 0 ? R(h) : S(d, n, o));
-        const m = Math.abs(l) <= r, D = Math.abs(c - o) <= s;
-        u.done = m && D;
+    calculatedDuration: isResolvedFromDuration ? duration || null : null,
+    next: (t) => {
+      const current = resolveSpring(t);
+      if (!isResolvedFromDuration) {
+        let currentVelocity = 0;
+        if (dampingRatio < 1) {
+          currentVelocity = t === 0 ? secondsToMilliseconds(initialVelocity) : calcGeneratorVelocity(resolveSpring, t, current);
+        }
+        const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;
+        const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;
+        state.done = isBelowVelocityThreshold && isBelowDisplacementThreshold;
+      } else {
+        state.done = t >= duration;
       }
-      return u.value = u.done ? c : o, u;
+      state.value = state.done ? target : current;
+      return state;
     }
   };
 }
 export {
-  z as spring
+  spring
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/generators/utils/calc-duration.mjs

@@ -1,13 +1,15 @@
-const a = 2e4;
-function o(n) {
-  let t = 0;
-  const r = 50;
-  let e = n.next(t);
-  for (; !e.done && t < 2e4; )
-    t += r, e = n.next(t);
-  return t >= 2e4 ? 1 / 0 : t;
+const maxGeneratorDuration = 2e4;
+function calcGeneratorDuration(generator) {
+  let duration = 0;
+  const timeStep = 50;
+  let state = generator.next(duration);
+  while (!state.done && duration < maxGeneratorDuration) {
+    duration += timeStep;
+    state = generator.next(duration);
+  }
+  return duration >= maxGeneratorDuration ? Infinity : duration;
 }
 export {
-  o as calcGeneratorDuration,
-  a as maxGeneratorDuration
+  calcGeneratorDuration,
+  maxGeneratorDuration
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/generators/utils/is-generator.mjs

@@ -1,6 +1,6 @@
-function t(n) {
-  return typeof n == "function";
+function isGenerator(type) {
+  return typeof type === "function";
 }
 export {
-  t as isGenerator
+  isGenerator
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs

@@ -1,9 +1,9 @@
-import { velocityPerSecond as c } from "../../../utils/velocity-per-second.mjs";
-const n = 5;
-function i(t, o, r) {
-  const e = Math.max(o - n, 0);
-  return c(r - t(e), o - e);
+import { velocityPerSecond } from "../../../utils/velocity-per-second.mjs";
+const velocitySampleDuration = 5;
+function calcGeneratorVelocity(resolveValue, t, current) {
+  const prevT = Math.max(t - velocitySampleDuration, 0);
+  return velocityPerSecond(current - resolveValue(prevT), t - prevT);
 }
 export {
-  i as calcGeneratorVelocity
+  calcGeneratorVelocity
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs

@@ -1,46 +1,73 @@
-import { secondsToMilliseconds as f } from "../../utils/time-conversion.mjs";
-import { getDefaultTransition as c } from "../utils/default-transitions.mjs";
-import { getValueTransition as D } from "../utils/get-value-transition.mjs";
-import { getFinalKeyframe as T } from "../animators/waapi/utils/get-final-keyframe.mjs";
-import { frame as k } from "../../frameloop/frame.mjs";
-import { AcceleratedAnimation as d } from "../animators/AcceleratedAnimation.mjs";
-import { MainThreadAnimation as A } from "../animators/MainThreadAnimation.mjs";
-import { GroupPlaybackControls as C } from "../GroupPlaybackControls.mjs";
-import { isTransitionDefined as U } from "../utils/is-transition-defined.mjs";
-const G = (i, r, n, a = {}, s, l) => (u) => {
-  const o = D(a, i) || {}, y = o.delay || a.delay || 0;
-  let { elapsed: m = 0 } = a;
-  m = m - f(y);
-  let e = {
-    keyframes: Array.isArray(n) ? n : [null, n],
+import { secondsToMilliseconds } from "../../utils/time-conversion.mjs";
+import { getDefaultTransition } from "../utils/default-transitions.mjs";
+import { getValueTransition } from "../utils/get-value-transition.mjs";
+import { getFinalKeyframe } from "../animators/waapi/utils/get-final-keyframe.mjs";
+import { frame } from "../../frameloop/frame.mjs";
+import { AcceleratedAnimation } from "../animators/AcceleratedAnimation.mjs";
+import { MainThreadAnimation } from "../animators/MainThreadAnimation.mjs";
+import { GroupPlaybackControls } from "../GroupPlaybackControls.mjs";
+import { isTransitionDefined } from "../utils/is-transition-defined.mjs";
+const animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {
+  const valueTransition = getValueTransition(transition, name) || {};
+  const delay = valueTransition.delay || transition.delay || 0;
+  let { elapsed = 0 } = transition;
+  elapsed = elapsed - secondsToMilliseconds(delay);
+  let options = {
+    keyframes: Array.isArray(target) ? target : [null, target],
     ease: "easeOut",
-    velocity: r.getVelocity(),
-    ...o,
-    delay: -m,
-    onUpdate: (t) => {
-      r.set(t), o.onUpdate && o.onUpdate(t);
+    velocity: value.getVelocity(),
+    ...valueTransition,
+    delay: -elapsed,
+    onUpdate: (v) => {
+      value.set(v);
+      valueTransition.onUpdate && valueTransition.onUpdate(v);
     },
     onComplete: () => {
-      u(), o.onComplete && o.onComplete();
+      onComplete();
+      valueTransition.onComplete && valueTransition.onComplete();
     },
-    name: i,
-    motionValue: r,
-    element: l ? void 0 : s
+    name,
+    motionValue: value,
+    element: isHandoff ? void 0 : element
   };
-  U(o) || (e = {
-    ...e,
-    ...c(i, e)
-  }), e.duration && (e.duration = f(e.duration)), e.repeatDelay && (e.repeatDelay = f(e.repeatDelay)), e.from !== void 0 && (e.keyframes[0] = e.from);
-  let p = !1;
-  if ((e.type === !1 || e.duration === 0 && !e.repeatDelay) && (e.duration = 0, e.delay === 0 && (p = !0)), p && !l && r.get() !== void 0) {
-    const t = T(e.keyframes, o);
-    if (t !== void 0)
-      return k.update(() => {
-        e.onUpdate(t), e.onComplete();
-      }), new C([]);
+  if (!isTransitionDefined(valueTransition)) {
+    options = {
+      ...options,
+      ...getDefaultTransition(name, options)
+    };
+  }
+  if (options.duration) {
+    options.duration = secondsToMilliseconds(options.duration);
+  }
+  if (options.repeatDelay) {
+    options.repeatDelay = secondsToMilliseconds(options.repeatDelay);
+  }
+  if (options.from !== void 0) {
+    options.keyframes[0] = options.from;
+  }
+  let shouldSkip = false;
+  if (options.type === false || options.duration === 0 && !options.repeatDelay) {
+    options.duration = 0;
+    if (options.delay === 0) {
+      shouldSkip = true;
+    }
+  }
+  if (shouldSkip && !isHandoff && value.get() !== void 0) {
+    const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);
+    if (finalKeyframe !== void 0) {
+      frame.update(() => {
+        options.onUpdate(finalKeyframe);
+        options.onComplete();
+      });
+      return new GroupPlaybackControls([]);
+    }
+  }
+  if (!isHandoff && AcceleratedAnimation.supports(options)) {
+    return new AcceleratedAnimation(options);
+  } else {
+    return new MainThreadAnimation(options);
   }
-  return !l && d.supports(e) ? new d(e) : new A(e);
 };
 export {
-  G as animateMotionValue
+  animateMotionValue
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs

@@ -1,45 +1,59 @@
-import { transformProps as M } from "../../render/html/utils/transform.mjs";
-import { animateMotionValue as S } from "./motion-value.mjs";
-import { setTarget as A } from "../../render/utils/setters.mjs";
-import { getValueTransition as H } from "../utils/get-value-transition.mjs";
-import { getOptimisedAppearId as P } from "../optimized-appear/get-appear-id.mjs";
-import { addValueToWillChange as B } from "../../value/use-will-change/add-will-change.mjs";
-import { frame as V } from "../../frameloop/frame.mjs";
-function I({ protectedKeys: t, needsAnimating: a }, n) {
-  const i = t.hasOwnProperty(n) && a[n] !== !0;
-  return a[n] = !1, i;
+import { transformProps } from "../../render/html/utils/transform.mjs";
+import { animateMotionValue } from "./motion-value.mjs";
+import { setTarget } from "../../render/utils/setters.mjs";
+import { getValueTransition } from "../utils/get-value-transition.mjs";
+import { getOptimisedAppearId } from "../optimized-appear/get-appear-id.mjs";
+import { addValueToWillChange } from "../../value/use-will-change/add-will-change.mjs";
+import { frame } from "../../frameloop/frame.mjs";
+function shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {
+  const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
+  needsAnimating[key] = false;
+  return shouldBlock;
 }
-function W(t, a, { delay: n = 0, transitionOverride: i, type: m } = {}) {
-  var r;
-  let { transition: p = t.getDefaultTransition(), transitionEnd: e, ...d } = a;
-  i && (p = i);
-  const f = [], u = m && t.animationState && t.animationState.getState()[m];
-  for (const o in d) {
-    const s = t.getValue(o, (r = t.latestValues[o]) !== null && r !== void 0 ? r : null), c = d[o];
-    if (c === void 0 || u && I(u, o))
+function animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {
+  var _a;
+  let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = targetAndTransition;
+  if (transitionOverride)
+    transition = transitionOverride;
+  const animations = [];
+  const animationTypeState = type && visualElement.animationState && visualElement.animationState.getState()[type];
+  for (const key in target) {
+    const value = visualElement.getValue(key, (_a = visualElement.latestValues[key]) !== null && _a !== void 0 ? _a : null);
+    const valueTarget = target[key];
+    if (valueTarget === void 0 || animationTypeState && shouldBlockAnimation(animationTypeState, key)) {
       continue;
-    const l = {
-      delay: n,
-      ...H(p || {}, o)
+    }
+    const valueTransition = {
+      delay,
+      ...getValueTransition(transition || {}, key)
     };
-    let T = !1;
+    let isHandoff = false;
     if (window.MotionHandoffAnimation) {
-      const h = P(t);
-      if (h) {
-        const w = window.MotionHandoffAnimation(h, o, V);
-        w !== null && (l.startTime = w, T = !0);
+      const appearId = getOptimisedAppearId(visualElement);
+      if (appearId) {
+        const startTime = window.MotionHandoffAnimation(appearId, key, frame);
+        if (startTime !== null) {
+          valueTransition.startTime = startTime;
+          isHandoff = true;
+        }
       }
     }
-    B(t, o), s.start(S(o, s, c, t.shouldReduceMotion && M.has(o) ? { type: !1 } : l, t, T));
-    const g = s.animation;
-    g && f.push(g);
+    addValueToWillChange(visualElement, key);
+    value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && transformProps.has(key) ? { type: false } : valueTransition, visualElement, isHandoff));
+    const animation = value.animation;
+    if (animation) {
+      animations.push(animation);
+    }
   }
-  return e && Promise.all(f).then(() => {
-    V.update(() => {
-      e && A(t, e);
+  if (transitionEnd) {
+    Promise.all(animations).then(() => {
+      frame.update(() => {
+        transitionEnd && setTarget(visualElement, transitionEnd);
+      });
     });
-  }), f;
+  }
+  return animations;
 }
 export {
-  W as animateTarget
+  animateTarget
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.mjs

@@ -1,6 +1,7 @@
-import { camelToDash as a } from "../../render/dom/utils/camel-to-dash.mjs";
-const t = "framerAppearId", e = "data-" + a(t);
+import { camelToDash } from "../../render/dom/utils/camel-to-dash.mjs";
+const optimizedAppearDataId = "framerAppearId";
+const optimizedAppearDataAttribute = "data-" + camelToDash(optimizedAppearDataId);
 export {
-  e as optimizedAppearDataAttribute,
-  t as optimizedAppearDataId
+  optimizedAppearDataAttribute,
+  optimizedAppearDataId
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.mjs

@@ -1,7 +1,7 @@
-import { optimizedAppearDataAttribute as p } from "./data-id.mjs";
-function e(t) {
-  return t.props[p];
+import { optimizedAppearDataAttribute } from "./data-id.mjs";
+function getOptimisedAppearId(visualElement) {
+  return visualElement.props[optimizedAppearDataAttribute];
 }
 export {
-  e as getOptimisedAppearId
+  getOptimisedAppearId
 };