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/sequence/create.mjs

@@ -1,106 +1,153 @@
-import { createGeneratorEasing as Q } from "../../easing/utils/create-generator-easing.mjs";
-import { defaultOffset as R } from "../../utils/offsets/default.mjs";
-import { fillOffset as U } from "../../utils/offsets/fill.mjs";
-import { progress as W } from "../../utils/progress.mjs";
-import { secondsToMilliseconds as X } from "../../utils/time-conversion.mjs";
-import { isMotionValue as Y } from "../../value/utils/is-motion-value.mjs";
-import { resolveSubjects as Z } from "../animate/resolve-subjects.mjs";
-import { isGenerator as _ } from "../generators/utils/is-generator.mjs";
-import { calcNextTime as q } from "./utils/calc-time.mjs";
-import { addKeyframes as $ } from "./utils/edit.mjs";
-import { compareByTime as ee } from "./utils/sort.mjs";
-const te = "easeInOut";
-function ye(e, { defaultTransition: t = {}, ...C } = {}, F, A) {
-  const z = t.duration || 0.3, b = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map(), H = {}, S = /* @__PURE__ */ new Map();
-  let j = 0, l = 0, v = 0;
-  for (let p = 0; p < e.length; p++) {
-    const i = e[p];
-    if (typeof i == "string") {
-      S.set(i, l);
+import { createGeneratorEasing } from "../../easing/utils/create-generator-easing.mjs";
+import { defaultOffset } from "../../utils/offsets/default.mjs";
+import { fillOffset } from "../../utils/offsets/fill.mjs";
+import { progress } from "../../utils/progress.mjs";
+import { secondsToMilliseconds } from "../../utils/time-conversion.mjs";
+import { isMotionValue } from "../../value/utils/is-motion-value.mjs";
+import { resolveSubjects } from "../animate/resolve-subjects.mjs";
+import { isGenerator } from "../generators/utils/is-generator.mjs";
+import { calcNextTime } from "./utils/calc-time.mjs";
+import { addKeyframes } from "./utils/edit.mjs";
+import { compareByTime } from "./utils/sort.mjs";
+const defaultSegmentEasing = "easeInOut";
+function createAnimationsFromSequence(sequence, { defaultTransition = {}, ...sequenceTransition } = {}, scope, generators) {
+  const defaultDuration = defaultTransition.duration || 0.3;
+  const animationDefinitions = /* @__PURE__ */ new Map();
+  const sequences = /* @__PURE__ */ new Map();
+  const elementCache = {};
+  const timeLabels = /* @__PURE__ */ new Map();
+  let prevTime = 0;
+  let currentTime = 0;
+  let totalDuration = 0;
+  for (let i = 0; i < sequence.length; i++) {
+    const segment = sequence[i];
+    if (typeof segment === "string") {
+      timeLabels.set(segment, currentTime);
       continue;
-    } else if (!Array.isArray(i)) {
-      S.set(i.name, q(l, i.at, j, S));
+    } else if (!Array.isArray(segment)) {
+      timeLabels.set(segment.name, calcNextTime(currentTime, segment.at, prevTime, timeLabels));
       continue;
     }
-    let [m, r, o = {}] = i;
-    o.at !== void 0 && (l = q(l, o.at, j, S));
-    let s = 0;
-    const h = (a, u, f, d = 0, y = 0) => {
-      const n = ne(a), { delay: T = 0, times: g = R(n), type: x = "keyframes", ...J } = u;
-      let { ease: D = t.ease || "easeOut", duration: c } = u;
-      const O = typeof T == "function" ? T(d, y) : T, k = n.length, E = _(x) ? x : A == null ? void 0 : A[x];
-      if (k <= 2 && E) {
-        let G = 100;
-        if (k === 2 && ie(n)) {
-          const P = n[1] - n[0];
-          G = Math.abs(P);
+    let [subject, keyframes, transition = {}] = segment;
+    if (transition.at !== void 0) {
+      currentTime = calcNextTime(currentTime, transition.at, prevTime, timeLabels);
+    }
+    let maxDuration = 0;
+    const resolveValueSequence = (valueKeyframes, valueTransition, valueSequence, elementIndex = 0, numSubjects = 0) => {
+      const valueKeyframesAsList = keyframesAsList(valueKeyframes);
+      const { delay = 0, times = defaultOffset(valueKeyframesAsList), type = "keyframes", ...remainingTransition } = valueTransition;
+      let { ease = defaultTransition.ease || "easeOut", duration } = valueTransition;
+      const calculatedDelay = typeof delay === "function" ? delay(elementIndex, numSubjects) : delay;
+      const numKeyframes = valueKeyframesAsList.length;
+      const createGenerator = isGenerator(type) ? type : generators === null || generators === void 0 ? void 0 : generators[type];
+      if (numKeyframes <= 2 && createGenerator) {
+        let absoluteDelta = 100;
+        if (numKeyframes === 2 && isNumberKeyframesArray(valueKeyframesAsList)) {
+          const delta = valueKeyframesAsList[1] - valueKeyframesAsList[0];
+          absoluteDelta = Math.abs(delta);
+        }
+        const springTransition = { ...remainingTransition };
+        if (duration !== void 0) {
+          springTransition.duration = secondsToMilliseconds(duration);
         }
-        const L = { ...J };
-        c !== void 0 && (L.duration = X(c));
-        const N = Q(L, G, E);
-        D = N.ease, c = N.duration;
+        const springEasing = createGeneratorEasing(springTransition, absoluteDelta, createGenerator);
+        ease = springEasing.ease;
+        duration = springEasing.duration;
       }
-      c ?? (c = z);
-      const K = l + O, V = K + c;
-      g.length === 1 && g[0] === 0 && (g[1] = 1);
-      const w = g.length - n.length;
-      w > 0 && U(g, w), n.length === 1 && n.unshift(null), $(f, n, D, g, K, V), s = Math.max(O + c, s), v = Math.max(V, v);
+      duration !== null && duration !== void 0 ? duration : duration = defaultDuration;
+      const startTime = currentTime + calculatedDelay;
+      const targetTime = startTime + duration;
+      if (times.length === 1 && times[0] === 0) {
+        times[1] = 1;
+      }
+      const remainder = times.length - valueKeyframesAsList.length;
+      remainder > 0 && fillOffset(times, remainder);
+      valueKeyframesAsList.length === 1 && valueKeyframesAsList.unshift(null);
+      addKeyframes(valueSequence, valueKeyframesAsList, ease, times, startTime, targetTime);
+      maxDuration = Math.max(calculatedDelay + duration, maxDuration);
+      totalDuration = Math.max(targetTime, totalDuration);
     };
-    if (Y(m)) {
-      const a = I(m, M);
-      h(r, o, B("default", a));
+    if (isMotionValue(subject)) {
+      const subjectSequence = getSubjectSequence(subject, sequences);
+      resolveValueSequence(keyframes, transition, getValueSequence("default", subjectSequence));
     } else {
-      const a = Z(m, r, F, H), u = a.length;
-      for (let f = 0; f < u; f++) {
-        r = r, o = o;
-        const d = a[f], y = I(d, M);
-        for (const n in r)
-          h(r[n], oe(o, n), B(n, y), f, u);
+      const subjects = resolveSubjects(subject, keyframes, scope, elementCache);
+      const numSubjects = subjects.length;
+      for (let subjectIndex = 0; subjectIndex < numSubjects; subjectIndex++) {
+        keyframes = keyframes;
+        transition = transition;
+        const thisSubject = subjects[subjectIndex];
+        const subjectSequence = getSubjectSequence(thisSubject, sequences);
+        for (const key in keyframes) {
+          resolveValueSequence(keyframes[key], getValueTransition(transition, key), getValueSequence(key, subjectSequence), subjectIndex, numSubjects);
+        }
       }
     }
-    j = l, l += s;
+    prevTime = currentTime;
+    currentTime += maxDuration;
   }
-  return M.forEach((p, i) => {
-    for (const m in p) {
-      const r = p[m];
-      r.sort(ee);
-      const o = [], s = [], h = [];
-      for (let u = 0; u < r.length; u++) {
-        const { at: f, value: d, easing: y } = r[u];
-        o.push(d), s.push(W(0, v, f)), h.push(y || "easeOut");
+  sequences.forEach((valueSequences, element) => {
+    for (const key in valueSequences) {
+      const valueSequence = valueSequences[key];
+      valueSequence.sort(compareByTime);
+      const keyframes = [];
+      const valueOffset = [];
+      const valueEasing = [];
+      for (let i = 0; i < valueSequence.length; i++) {
+        const { at, value, easing } = valueSequence[i];
+        keyframes.push(value);
+        valueOffset.push(progress(0, totalDuration, at));
+        valueEasing.push(easing || "easeOut");
+      }
+      if (valueOffset[0] !== 0) {
+        valueOffset.unshift(0);
+        keyframes.unshift(keyframes[0]);
+        valueEasing.unshift(defaultSegmentEasing);
+      }
+      if (valueOffset[valueOffset.length - 1] !== 1) {
+        valueOffset.push(1);
+        keyframes.push(null);
+      }
+      if (!animationDefinitions.has(element)) {
+        animationDefinitions.set(element, {
+          keyframes: {},
+          transition: {}
+        });
       }
-      s[0] !== 0 && (s.unshift(0), o.unshift(o[0]), h.unshift(te)), s[s.length - 1] !== 1 && (s.push(1), o.push(null)), b.has(i) || b.set(i, {
-        keyframes: {},
-        transition: {}
-      });
-      const a = b.get(i);
-      a.keyframes[m] = o, a.transition[m] = {
-        ...t,
-        duration: v,
-        ease: h,
-        times: s,
-        ...C
+      const definition = animationDefinitions.get(element);
+      definition.keyframes[key] = keyframes;
+      definition.transition[key] = {
+        ...defaultTransition,
+        duration: totalDuration,
+        ease: valueEasing,
+        times: valueOffset,
+        ...sequenceTransition
       };
     }
-  }), b;
+  });
+  return animationDefinitions;
 }
-function I(e, t) {
-  return !t.has(e) && t.set(e, {}), t.get(e);
+function getSubjectSequence(subject, sequences) {
+  !sequences.has(subject) && sequences.set(subject, {});
+  return sequences.get(subject);
 }
-function B(e, t) {
-  return t[e] || (t[e] = []), t[e];
+function getValueSequence(name, sequences) {
+  if (!sequences[name])
+    sequences[name] = [];
+  return sequences[name];
 }
-function ne(e) {
-  return Array.isArray(e) ? e : [e];
+function keyframesAsList(keyframes) {
+  return Array.isArray(keyframes) ? keyframes : [keyframes];
 }
-function oe(e, t) {
-  return e && e[t] ? {
-    ...e,
-    ...e[t]
-  } : { ...e };
+function getValueTransition(transition, key) {
+  return transition && transition[key] ? {
+    ...transition,
+    ...transition[key]
+  } : { ...transition };
 }
-const se = (e) => typeof e == "number", ie = (e) => e.every(se);
+const isNumber = (keyframe) => typeof keyframe === "number";
+const isNumberKeyframesArray = (keyframes) => keyframes.every(isNumber);
 export {
-  ye as createAnimationsFromSequence,
-  oe as getValueTransition
+  createAnimationsFromSequence,
+  getValueTransition
 };

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

@@ -1,7 +1,15 @@
-function s(t, r, a, i) {
-  var e;
-  return typeof r == "number" ? r : r.startsWith("-") || r.startsWith("+") ? Math.max(0, t + parseFloat(r)) : r === "<" ? a : (e = i.get(r)) !== null && e !== void 0 ? e : t;
+function calcNextTime(current, next, prev, labels) {
+  var _a;
+  if (typeof next === "number") {
+    return next;
+  } else if (next.startsWith("-") || next.startsWith("+")) {
+    return Math.max(0, current + parseFloat(next));
+  } else if (next === "<") {
+    return prev;
+  } else {
+    return (_a = labels.get(next)) !== null && _a !== void 0 ? _a : current;
+  }
 }
 export {
-  s as calcNextTime
+  calcNextTime
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/sequence/utils/edit.mjs

@@ -1,22 +1,26 @@
-import { getEasingForSegment as e } from "../../../easing/utils/get-easing-for-segment.mjs";
-import { removeItem as g } from "../../../utils/array.mjs";
-import { mixNumber as n } from "../../../utils/mix/number.mjs";
-function l(t, f, a) {
-  for (let o = 0; o < t.length; o++) {
-    const r = t[o];
-    r.at > f && r.at < a && (g(t, r), o--);
+import { getEasingForSegment } from "../../../easing/utils/get-easing-for-segment.mjs";
+import { removeItem } from "../../../utils/array.mjs";
+import { mixNumber } from "../../../utils/mix/number.mjs";
+function eraseKeyframes(sequence, startTime, endTime) {
+  for (let i = 0; i < sequence.length; i++) {
+    const keyframe = sequence[i];
+    if (keyframe.at > startTime && keyframe.at < endTime) {
+      removeItem(sequence, keyframe);
+      i--;
+    }
   }
 }
-function u(t, f, a, o, r, i) {
-  l(t, r, i);
-  for (let m = 0; m < f.length; m++)
-    t.push({
-      value: f[m],
-      at: n(r, i, o[m]),
-      easing: e(a, m)
+function addKeyframes(sequence, keyframes, easing, offset, startTime, endTime) {
+  eraseKeyframes(sequence, startTime, endTime);
+  for (let i = 0; i < keyframes.length; i++) {
+    sequence.push({
+      value: keyframes[i],
+      at: mixNumber(startTime, endTime, offset[i]),
+      easing: getEasingForSegment(easing, i)
     });
+  }
 }
 export {
-  u as addKeyframes,
-  l as eraseKeyframes
+  addKeyframes,
+  eraseKeyframes
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/sequence/utils/sort.mjs

@@ -1,6 +1,14 @@
-function t(e, r) {
-  return e.at === r.at ? e.value === null ? 1 : r.value === null ? -1 : 0 : e.at - r.at;
+function compareByTime(a, b) {
+  if (a.at === b.at) {
+    if (a.value === null)
+      return 1;
+    if (b.value === null)
+      return -1;
+    return 0;
+  } else {
+    return a.at - b.at;
+  }
 }
 export {
-  t as compareByTime
+  compareByTime
 };

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

@@ -1,10 +1,10 @@
-import { isSVGElement as r } from "../../render/dom/utils/is-svg-element.mjs";
-import { SVGVisualElement as s } from "../../render/svg/SVGVisualElement.mjs";
-import { HTMLVisualElement as a } from "../../render/html/HTMLVisualElement.mjs";
-import { visualElementStore as o } from "../../render/store.mjs";
-import { ObjectVisualElement as l } from "../../render/object/ObjectVisualElement.mjs";
-function f(t) {
-  const n = {
+import { isSVGElement } from "../../render/dom/utils/is-svg-element.mjs";
+import { SVGVisualElement } from "../../render/svg/SVGVisualElement.mjs";
+import { HTMLVisualElement } from "../../render/html/HTMLVisualElement.mjs";
+import { visualElementStore } from "../../render/store.mjs";
+import { ObjectVisualElement } from "../../render/object/ObjectVisualElement.mjs";
+function createDOMVisualElement(element) {
+  const options = {
     presenceContext: null,
     props: {},
     visualState: {
@@ -17,11 +17,13 @@ function f(t) {
       },
       latestValues: {}
     }
-  }, e = r(t) ? new s(n) : new a(n);
-  e.mount(t), o.set(t, e);
+  };
+  const node = isSVGElement(element) ? new SVGVisualElement(options) : new HTMLVisualElement(options);
+  node.mount(element);
+  visualElementStore.set(element, node);
 }
-function V(t) {
-  const n = {
+function createObjectVisualElement(subject) {
+  const options = {
     presenceContext: null,
     props: {},
     visualState: {
@@ -30,10 +32,12 @@ function V(t) {
       },
       latestValues: {}
     }
-  }, e = new l(n);
-  e.mount(t), o.set(t, e);
+  };
+  const node = new ObjectVisualElement(options);
+  node.mount(subject);
+  visualElementStore.set(subject, node);
 }
 export {
-  f as createDOMVisualElement,
-  V as createObjectVisualElement
+  createDOMVisualElement,
+  createObjectVisualElement
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs

@@ -1,22 +1,33 @@
-import { transformProps as s } from "../../render/html/utils/transform.mjs";
-const r = {
+import { transformProps } from "../../render/html/utils/transform.mjs";
+const underDampedSpring = {
   type: "spring",
   stiffness: 500,
   damping: 25,
   restSpeed: 10
-}, n = (t) => ({
+};
+const criticallyDampedSpring = (target) => ({
   type: "spring",
   stiffness: 550,
-  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  damping: target === 0 ? 2 * Math.sqrt(550) : 30,
   restSpeed: 10
-}), i = {
+});
+const keyframesTransition = {
   type: "keyframes",
   duration: 0.8
-}, a = {
+};
+const ease = {
   type: "keyframes",
   ease: [0.25, 0.1, 0.35, 1],
   duration: 0.3
-}, o = (t, { keyframes: e }) => e.length > 2 ? i : s.has(t) ? t.startsWith("scale") ? n(e[1]) : r : a;
+};
+const getDefaultTransition = (valueKey, { keyframes }) => {
+  if (keyframes.length > 2) {
+    return keyframesTransition;
+  } else if (transformProps.has(valueKey)) {
+    return valueKey.startsWith("scale") ? criticallyDampedSpring(keyframes[1]) : underDampedSpring;
+  }
+  return ease;
+};
 export {
-  o as getDefaultTransition
+  getDefaultTransition
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/utils/get-value-transition.mjs

@@ -1,6 +1,6 @@
-function d(e, u) {
-  return e ? e[u] || e.default || e : void 0;
+function getValueTransition(transition, key) {
+  return transition ? transition[key] || transition["default"] || transition : void 0;
 }
 export {
-  d as getValueTransition
+  getValueTransition
 };

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

@@ -1,7 +1,16 @@
-import { complex as e } from "../../value/types/complex/index.mjs";
-const n = (r, t) => t === "zIndex" ? !1 : !!(typeof r == "number" || Array.isArray(r) || typeof r == "string" && // It's animatable if we have a string
-(e.test(r) || r === "0") && // And it contains numbers and/or colors
-!r.startsWith("url("));
+import { complex } from "../../value/types/complex/index.mjs";
+const isAnimatable = (value, name) => {
+  if (name === "zIndex")
+    return false;
+  if (typeof value === "number" || Array.isArray(value))
+    return true;
+  if (typeof value === "string" && // It's animatable if we have a string
+  (complex.test(value) || value === "0") && // And it contains numbers and/or colors
+  !value.startsWith("url(")) {
+    return true;
+  }
+  return false;
+};
 export {
-  n as isAnimatable
+  isAnimatable
 };

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

@@ -1,6 +1,6 @@
-function n(t) {
-  return t !== null && typeof t == "object" && typeof t.start == "function";
+function isAnimationControls(v) {
+  return v !== null && typeof v === "object" && typeof v.start === "function";
 }
 export {
-  n as isAnimationControls
+  isAnimationControls
 };

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

@@ -1,6 +1,6 @@
-function t(r) {
-  return typeof r == "object" && !Array.isArray(r);
+function isDOMKeyframes(keyframes) {
+  return typeof keyframes === "object" && !Array.isArray(keyframes);
 }
 export {
-  t as isDOMKeyframes
+  isDOMKeyframes
 };

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

@@ -1,4 +1,6 @@
-const e = (r) => Array.isArray(r);
+const isKeyframesTarget = (v) => {
+  return Array.isArray(v);
+};
 export {
-  e as isKeyframesTarget
+  isKeyframesTarget
 };

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

@@ -1,7 +1,13 @@
-import { isZeroValueString as n } from "../../utils/is-zero-value-string.mjs";
-function t(r) {
-  return typeof r == "number" ? r === 0 : r !== null ? r === "none" || r === "0" || n(r) : !0;
+import { isZeroValueString } from "../../utils/is-zero-value-string.mjs";
+function isNone(value) {
+  if (typeof value === "number") {
+    return value === 0;
+  } else if (value !== null) {
+    return value === "none" || value === "0" || isZeroValueString(value);
+  } else {
+    return true;
+  }
 }
 export {
-  t as isNone
+  isNone
 };

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

@@ -1,6 +1,6 @@
-function g({ when: r, delay: t, delayChildren: a, staggerChildren: n, staggerDirection: i, repeat: l, repeatType: d, repeatDelay: p, from: s, elapsed: y, ...e }) {
-  return !!Object.keys(e).length;
+function isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, elapsed, ...transition }) {
+  return !!Object.keys(transition).length;
 }
 export {
-  g as isTransitionDefined
+  isTransitionDefined
 };

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

@@ -1,24 +1,26 @@
-import { easingDefinitionToFunction as g } from "../../easing/utils/map.mjs";
-function f(t, e) {
-  if (t === "first")
+import { easingDefinitionToFunction } from "../../easing/utils/map.mjs";
+function getOriginIndex(from, total) {
+  if (from === "first") {
     return 0;
-  {
-    const n = e - 1;
-    return t === "last" ? n : n / 2;
+  } else {
+    const lastIndex = total - 1;
+    return from === "last" ? lastIndex : lastIndex / 2;
   }
 }
-function d(t = 0.1, { startDelay: e = 0, from: n = 0, ease: s } = {}) {
-  return (c, o) => {
-    const a = typeof n == "number" ? n : f(n, o), u = Math.abs(a - c);
-    let i = t * u;
-    if (s) {
-      const r = o * t;
-      i = g(s)(i / r) * r;
+function stagger(duration = 0.1, { startDelay = 0, from = 0, ease } = {}) {
+  return (i, total) => {
+    const fromIndex = typeof from === "number" ? from : getOriginIndex(from, total);
+    const distance = Math.abs(fromIndex - i);
+    let delay = duration * distance;
+    if (ease) {
+      const maxDelay = total * duration;
+      const easingFunction = easingDefinitionToFunction(ease);
+      delay = easingFunction(delay / maxDelay) * maxDelay;
     }
-    return e + i;
+    return startDelay + delay;
   };
 }
 export {
-  f as getOriginIndex,
-  d as stagger
+  getOriginIndex,
+  stagger
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/anticipate.mjs

@@ -1,5 +1,5 @@
-import { backIn as o } from "./back.mjs";
-const c = (t) => (t *= 2) < 1 ? 0.5 * o(t) : 0.5 * (2 - Math.pow(2, -10 * (t - 1)));
+import { backIn } from "./back.mjs";
+const anticipate = (p) => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));
 export {
-  c as anticipate
+  anticipate
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/back.mjs

@@ -1,9 +1,11 @@
-import { cubicBezier as r } from "./cubic-bezier.mjs";
-import { mirrorEasing as o } from "./modifiers/mirror.mjs";
-import { reverseEasing as t } from "./modifiers/reverse.mjs";
-const c = /* @__PURE__ */ r(0.33, 1.53, 0.69, 0.99), i = /* @__PURE__ */ t(c), s = /* @__PURE__ */ o(i);
+import { cubicBezier } from "./cubic-bezier.mjs";
+import { mirrorEasing } from "./modifiers/mirror.mjs";
+import { reverseEasing } from "./modifiers/reverse.mjs";
+const backOut = /* @__PURE__ */ cubicBezier(0.33, 1.53, 0.69, 0.99);
+const backIn = /* @__PURE__ */ reverseEasing(backOut);
+const backInOut = /* @__PURE__ */ mirrorEasing(backIn);
 export {
-  i as backIn,
-  s as backInOut,
-  c as backOut
+  backIn,
+  backInOut,
+  backOut
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/circ.mjs

@@ -1,8 +1,10 @@
-import { mirrorEasing as o } from "./modifiers/mirror.mjs";
-import { reverseEasing as t } from "./modifiers/reverse.mjs";
-const r = (c) => 1 - Math.sin(Math.acos(c)), s = t(r), a = o(r);
+import { mirrorEasing } from "./modifiers/mirror.mjs";
+import { reverseEasing } from "./modifiers/reverse.mjs";
+const circIn = (p) => 1 - Math.sin(Math.acos(p));
+const circOut = reverseEasing(circIn);
+const circInOut = mirrorEasing(circIn);
 export {
-  r as circIn,
-  a as circInOut,
-  s as circOut
+  circIn,
+  circInOut,
+  circOut
 };