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/easing/cubic-bezier.mjs

@@ -1,18 +1,28 @@
-import { noop as b } from "../utils/noop.mjs";
-const s = (n, i, r) => (((1 - 3 * r + 3 * i) * n + (3 * r - 6 * i)) * n + 3 * i) * n, f = 1e-7, l = 12;
-function a(n, i, r, c, o) {
-  let e, t, u = 0;
-  do
-    t = i + (r - i) / 2, e = s(t, c, o) - n, e > 0 ? r = t : i = t;
-  while (Math.abs(e) > f && ++u < l);
-  return t;
+import { noop } from "../utils/noop.mjs";
+const calcBezier = (t, a1, a2) => (((1 - 3 * a2 + 3 * a1) * t + (3 * a2 - 6 * a1)) * t + 3 * a1) * t;
+const subdivisionPrecision = 1e-7;
+const subdivisionMaxIterations = 12;
+function binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {
+  let currentX;
+  let currentT;
+  let i = 0;
+  do {
+    currentT = lowerBound + (upperBound - lowerBound) / 2;
+    currentX = calcBezier(currentT, mX1, mX2) - x;
+    if (currentX > 0) {
+      upperBound = currentT;
+    } else {
+      lowerBound = currentT;
+    }
+  } while (Math.abs(currentX) > subdivisionPrecision && ++i < subdivisionMaxIterations);
+  return currentT;
 }
-function d(n, i, r, c) {
-  if (n === i && r === c)
-    return b;
-  const o = (e) => a(e, 0, 1, n, r);
-  return (e) => e === 0 || e === 1 ? e : s(o(e), i, c);
+function cubicBezier(mX1, mY1, mX2, mY2) {
+  if (mX1 === mY1 && mX2 === mY2)
+    return noop;
+  const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);
+  return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);
 }
 export {
-  d as cubicBezier
+  cubicBezier
 };

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

@@ -1,7 +1,9 @@
-import { cubicBezier as e } from "./cubic-bezier.mjs";
-const o = /* @__PURE__ */ e(0.42, 0, 1, 1), s = /* @__PURE__ */ e(0, 0, 0.58, 1), c = /* @__PURE__ */ e(0.42, 0, 0.58, 1);
+import { cubicBezier } from "./cubic-bezier.mjs";
+const easeIn = /* @__PURE__ */ cubicBezier(0.42, 0, 1, 1);
+const easeOut = /* @__PURE__ */ cubicBezier(0, 0, 0.58, 1);
+const easeInOut = /* @__PURE__ */ cubicBezier(0.42, 0, 0.58, 1);
 export {
-  o as easeIn,
-  c as easeInOut,
-  s as easeOut
+  easeIn,
+  easeInOut,
+  easeOut
 };

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

@@ -1,4 +1,4 @@
-const t = (o) => (r) => r <= 0.5 ? o(2 * r) / 2 : (2 - o(2 * (1 - r))) / 2;
+const mirrorEasing = (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;
 export {
-  t as mirrorEasing
+  mirrorEasing
 };

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

@@ -1,4 +1,4 @@
-const s = (e) => (r) => 1 - e(1 - r);
+const reverseEasing = (easing) => (p) => 1 - easing(1 - p);
 export {
-  s as reverseEasing
+  reverseEasing
 };

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

@@ -1,11 +1,12 @@
-import { clamp as o } from "../utils/clamp.mjs";
-function h(t, a = "end") {
-  return (n) => {
-    n = a === "end" ? Math.min(n, 0.999) : Math.max(n, 1e-3);
-    const d = n * t, e = a === "end" ? Math.floor(d) : Math.ceil(d);
-    return o(0, 1, e / t);
+import { clamp } from "../utils/clamp.mjs";
+function steps(numSteps, direction = "end") {
+  return (progress) => {
+    progress = direction === "end" ? Math.min(progress, 0.999) : Math.max(progress, 1e-3);
+    const expanded = progress * numSteps;
+    const rounded = direction === "end" ? Math.floor(expanded) : Math.ceil(expanded);
+    return clamp(0, 1, rounded / numSteps);
   };
 }
 export {
-  h as steps
+  steps
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/utils/create-generator-easing.mjs

@@ -1,13 +1,14 @@
-import { calcGeneratorDuration as i, maxGeneratorDuration as m } from "../../animation/generators/utils/calc-duration.mjs";
-import { millisecondsToSeconds as s } from "../../utils/time-conversion.mjs";
-function f(t, e = 100, n) {
-  const r = n({ ...t, keyframes: [0, e] }), o = Math.min(i(r), m);
+import { calcGeneratorDuration, maxGeneratorDuration } from "../../animation/generators/utils/calc-duration.mjs";
+import { millisecondsToSeconds } from "../../utils/time-conversion.mjs";
+function createGeneratorEasing(options, scale = 100, createGenerator) {
+  const generator = createGenerator({ ...options, keyframes: [0, scale] });
+  const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
   return {
     type: "keyframes",
-    ease: (a) => r.next(o * a).value / e,
-    duration: s(o)
+    ease: (progress) => generator.next(duration * progress).value / scale,
+    duration: millisecondsToSeconds(duration)
   };
 }
 export {
-  f as createGeneratorEasing
+  createGeneratorEasing
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/utils/get-easing-for-segment.mjs

@@ -1,8 +1,8 @@
-import { wrap as o } from "../../utils/wrap.mjs";
-import { isEasingArray as m } from "./is-easing-array.mjs";
-function e(r, t) {
-  return m(r) ? r[o(0, r.length, t)] : r;
+import { wrap } from "../../utils/wrap.mjs";
+import { isEasingArray } from "./is-easing-array.mjs";
+function getEasingForSegment(easing, i) {
+  return isEasingArray(easing) ? easing[wrap(0, easing.length, i)] : easing;
 }
 export {
-  e as getEasingForSegment
+  getEasingForSegment
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/utils/is-bezier-definition.mjs

@@ -1,4 +1,4 @@
-const e = (r) => Array.isArray(r) && typeof r[0] == "number";
+const isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === "number";
 export {
-  e as isBezierDefinition
+  isBezierDefinition
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/utils/is-easing-array.mjs

@@ -1,4 +1,6 @@
-const n = (r) => Array.isArray(r) && typeof r[0] != "number";
+const isEasingArray = (ease) => {
+  return Array.isArray(ease) && typeof ease[0] !== "number";
+};
 export {
-  n as isEasingArray
+  isEasingArray
 };

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

@@ -1,32 +1,35 @@
-import { invariant as t } from "../../utils/errors.mjs";
-import { cubicBezier as i } from "../cubic-bezier.mjs";
-import { noop as m } from "../../utils/noop.mjs";
-import { easeIn as u, easeInOut as s, easeOut as p } from "../ease.mjs";
-import { circIn as f, circInOut as I, circOut as b } from "../circ.mjs";
-import { backIn as l, backInOut as O, backOut as g } from "../back.mjs";
-import { anticipate as y } from "../anticipate.mjs";
-import { isBezierDefinition as k } from "./is-bezier-definition.mjs";
-const e = {
-  linear: m,
-  easeIn: u,
-  easeInOut: s,
-  easeOut: p,
-  circIn: f,
-  circInOut: I,
-  circOut: b,
-  backIn: l,
-  backInOut: O,
-  backOut: g,
-  anticipate: y
-}, L = (r) => {
-  if (k(r)) {
-    t(r.length === 4, "Cubic bezier arrays must contain four numerical values.");
-    const [o, a, n, c] = r;
-    return i(o, a, n, c);
-  } else if (typeof r == "string")
-    return t(e[r] !== void 0, `Invalid easing type '${r}'`), e[r];
-  return r;
+import { invariant } from "../../utils/errors.mjs";
+import { cubicBezier } from "../cubic-bezier.mjs";
+import { noop } from "../../utils/noop.mjs";
+import { easeIn, easeInOut, easeOut } from "../ease.mjs";
+import { circIn, circInOut, circOut } from "../circ.mjs";
+import { backIn, backInOut, backOut } from "../back.mjs";
+import { anticipate } from "../anticipate.mjs";
+import { isBezierDefinition } from "./is-bezier-definition.mjs";
+const easingLookup = {
+  linear: noop,
+  easeIn,
+  easeInOut,
+  easeOut,
+  circIn,
+  circInOut,
+  circOut,
+  backIn,
+  backInOut,
+  backOut,
+  anticipate
+};
+const easingDefinitionToFunction = (definition) => {
+  if (isBezierDefinition(definition)) {
+    invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);
+    const [x1, y1, x2, y2] = definition;
+    return cubicBezier(x1, y1, x2, y2);
+  } else if (typeof definition === "string") {
+    invariant(easingLookup[definition] !== void 0, `Invalid easing type '${definition}'`);
+    return easingLookup[definition];
+  }
+  return definition;
 };
 export {
-  L as easingDefinitionToFunction
+  easingDefinitionToFunction
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/events/add-dom-event.mjs

@@ -0,0 +1,7 @@
+function addDomEvent(target, eventName, handler, options = { passive: true }) {
+  target.addEventListener(eventName, handler, options);
+  return () => target.removeEventListener(eventName, handler);
+}
+export {
+  addDomEvent
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/batcher.mjs

@@ -1,5 +1,5 @@
-import { createRenderStep as E } from "./render-step.mjs";
-const a = [
+import { createRenderStep } from "./render-step.mjs";
+const stepsOrder = [
   "read",
   // Read
   "resolveKeyframes",
@@ -12,28 +12,64 @@ const a = [
   // Write
   "postRender"
   // Compute
-], F = 40;
-function B(o, l) {
-  let t = !1, c = !0;
-  const e = {
+];
+const maxElapsed = 40;
+function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {
+  let runNextFrame = false;
+  let useDefaultElapsed = true;
+  const state = {
     delta: 0,
     timestamp: 0,
-    isProcessing: !1
-  }, d = () => t = !0, n = a.reduce((s, r) => (s[r] = E(d), s), {}), { read: u, resolveKeyframes: i, update: f, preRender: m, render: R, postRender: g } = n, p = () => {
-    const s = performance.now();
-    t = !1, e.delta = c ? 1e3 / 60 : Math.max(Math.min(s - e.timestamp, F), 1), e.timestamp = s, e.isProcessing = !0, u.process(e), i.process(e), f.process(e), m.process(e), R.process(e), g.process(e), e.isProcessing = !1, t && l && (c = !1, o(p));
-  }, h = () => {
-    t = !0, c = !0, e.isProcessing || o(p);
+    isProcessing: false
   };
-  return { schedule: a.reduce((s, r) => {
-    const x = n[r];
-    return s[r] = (P, v = !1, w = !1) => (t || h(), x.schedule(P, v, w)), s;
-  }, {}), cancel: (s) => {
-    for (let r = 0; r < a.length; r++)
-      n[a[r]].cancel(s);
-  }, state: e, steps: n };
+  const flagRunNextFrame = () => runNextFrame = true;
+  const steps = stepsOrder.reduce((acc, key) => {
+    acc[key] = createRenderStep(flagRunNextFrame);
+    return acc;
+  }, {});
+  const { read, resolveKeyframes, update, preRender, render, postRender } = steps;
+  const processBatch = () => {
+    const timestamp = performance.now();
+    runNextFrame = false;
+    state.delta = useDefaultElapsed ? 1e3 / 60 : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);
+    state.timestamp = timestamp;
+    state.isProcessing = true;
+    read.process(state);
+    resolveKeyframes.process(state);
+    update.process(state);
+    preRender.process(state);
+    render.process(state);
+    postRender.process(state);
+    state.isProcessing = false;
+    if (runNextFrame && allowKeepAlive) {
+      useDefaultElapsed = false;
+      scheduleNextBatch(processBatch);
+    }
+  };
+  const wake = () => {
+    runNextFrame = true;
+    useDefaultElapsed = true;
+    if (!state.isProcessing) {
+      scheduleNextBatch(processBatch);
+    }
+  };
+  const schedule = stepsOrder.reduce((acc, key) => {
+    const step = steps[key];
+    acc[key] = (process, keepAlive = false, immediate = false) => {
+      if (!runNextFrame)
+        wake();
+      return step.schedule(process, keepAlive, immediate);
+    };
+    return acc;
+  }, {});
+  const cancel = (process) => {
+    for (let i = 0; i < stepsOrder.length; i++) {
+      steps[stepsOrder[i]].cancel(process);
+    }
+  };
+  return { schedule, cancel, state, steps };
 }
 export {
-  B as createRenderBatcher,
-  a as stepsOrder
+  createRenderBatcher,
+  stepsOrder
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/frame.mjs

@@ -1,9 +1,9 @@
-import { noop as e } from "../utils/noop.mjs";
-import { createRenderBatcher as r } from "./batcher.mjs";
-const { schedule: m, cancel: n, state: o, steps: c } = r(typeof requestAnimationFrame < "u" ? requestAnimationFrame : e, !0);
+import { noop } from "../utils/noop.mjs";
+import { createRenderBatcher } from "./batcher.mjs";
+const { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps } = createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop, true);
 export {
-  n as cancelFrame,
-  m as frame,
-  o as frameData,
-  c as frameSteps
+  cancelFrame,
+  frame,
+  frameData,
+  frameSteps
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/index-legacy.mjs

@@ -1,7 +1,11 @@
-import { stepsOrder as n } from "./batcher.mjs";
-import { frame as o, cancelFrame as t } from "./frame.mjs";
-const p = o, a = n.reduce((r, e) => (r[e] = (c) => t(c), r), {});
+import { stepsOrder } from "./batcher.mjs";
+import { frame, cancelFrame } from "./frame.mjs";
+const sync = frame;
+const cancelSync = stepsOrder.reduce((acc, key) => {
+  acc[key] = (process) => cancelFrame(process);
+  return acc;
+}, {});
 export {
-  a as cancelSync,
-  p as sync
+  cancelSync,
+  sync
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/microtask.mjs

@@ -0,0 +1,6 @@
+import { createRenderBatcher } from "./batcher.mjs";
+const { schedule: microtask, cancel: cancelMicrotask } = createRenderBatcher(queueMicrotask, false);
+export {
+  cancelMicrotask,
+  microtask
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/render-step.mjs

@@ -1,41 +1,63 @@
-function p(d) {
-  let s = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set(), r = !1, n = !1;
-  const a = /* @__PURE__ */ new WeakSet();
-  let i = {
+function createRenderStep(runNextFrame) {
+  let thisFrame = /* @__PURE__ */ new Set();
+  let nextFrame = /* @__PURE__ */ new Set();
+  let isProcessing = false;
+  let flushNextFrame = false;
+  const toKeepAlive = /* @__PURE__ */ new WeakSet();
+  let latestFrameData = {
     delta: 0,
     timestamp: 0,
-    isProcessing: !1
+    isProcessing: false
   };
-  function u(e) {
-    a.has(e) && (f.schedule(e), d()), e(i);
+  function triggerCallback(callback) {
+    if (toKeepAlive.has(callback)) {
+      step.schedule(callback);
+      runNextFrame();
+    }
+    callback(latestFrameData);
   }
-  const f = {
+  const step = {
     /**
      * Schedule a process to run on the next frame.
      */
-    schedule: (e, l = !1, h = !1) => {
-      const o = h && r ? s : t;
-      return l && a.add(e), o.has(e) || o.add(e), e;
+    schedule: (callback, keepAlive = false, immediate = false) => {
+      const addToCurrentFrame = immediate && isProcessing;
+      const queue = addToCurrentFrame ? thisFrame : nextFrame;
+      if (keepAlive)
+        toKeepAlive.add(callback);
+      if (!queue.has(callback))
+        queue.add(callback);
+      return callback;
     },
     /**
      * Cancel the provided callback from running on the next frame.
      */
-    cancel: (e) => {
-      t.delete(e), a.delete(e);
+    cancel: (callback) => {
+      nextFrame.delete(callback);
+      toKeepAlive.delete(callback);
     },
     /**
      * Execute all schedule callbacks.
      */
-    process: (e) => {
-      if (i = e, r) {
-        n = !0;
+    process: (frameData) => {
+      latestFrameData = frameData;
+      if (isProcessing) {
+        flushNextFrame = true;
         return;
       }
-      r = !0, [s, t] = [t, s], t.clear(), s.forEach(u), r = !1, n && (n = !1, f.process(e));
+      isProcessing = true;
+      [thisFrame, nextFrame] = [nextFrame, thisFrame];
+      nextFrame.clear();
+      thisFrame.forEach(triggerCallback);
+      isProcessing = false;
+      if (flushNextFrame) {
+        flushNextFrame = false;
+        step.process(frameData);
+      }
     }
   };
-  return f;
+  return step;
 }
 export {
-  p as createRenderStep
+  createRenderStep
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/sync-time.mjs

@@ -1,15 +1,21 @@
-import { MotionGlobalConfig as i } from "../utils/GlobalConfig.mjs";
-import { frameData as n } from "./frame.mjs";
-let e;
-function t() {
-  e = void 0;
+import { MotionGlobalConfig } from "../utils/GlobalConfig.mjs";
+import { frameData } from "./frame.mjs";
+let now;
+function clearTime() {
+  now = void 0;
 }
-const r = {
-  now: () => (e === void 0 && r.set(n.isProcessing || i.useManualTiming ? n.timestamp : performance.now()), e),
-  set: (o) => {
-    e = o, queueMicrotask(t);
+const time = {
+  now: () => {
+    if (now === void 0) {
+      time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming ? frameData.timestamp : performance.now());
+    }
+    return now;
+  },
+  set: (newTime) => {
+    now = newTime;
+    queueMicrotask(clearTime);
   }
 };
 export {
-  r as time
+  time
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/motion/features/definitions.mjs

@@ -1,4 +1,4 @@
-const n = {
+const featureProps = {
   animation: [
     "animate",
     "variants",
@@ -17,11 +17,13 @@ const n = {
   pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
   inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
   layout: ["layout", "layoutId"]
-}, t = {};
-for (const e in n)
-  t[e] = {
-    isEnabled: (o) => n[e].some((a) => !!o[a])
+};
+const featureDefinitions = {};
+for (const key in featureProps) {
+  featureDefinitions[key] = {
+    isEnabled: (props) => featureProps[key].some((name) => !!props[name])
   };
+}
 export {
-  t as featureDefinitions
+  featureDefinitions
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs

@@ -1,8 +1,8 @@
-import { scaleCorrectors as i } from "../../projection/styles/scale-correction.mjs";
-import { transformProps as n } from "../../render/html/utils/transform.mjs";
-function c(r, { layout: o, layoutId: t }) {
-  return n.has(r) || r.startsWith("origin") || (o || t !== void 0) && (!!i[r] || r === "opacity");
+import { scaleCorrectors } from "../../projection/styles/scale-correction.mjs";
+import { transformProps } from "../../render/html/utils/transform.mjs";
+function isForcedMotionValue(key, { layout, layoutId }) {
+  return transformProps.has(key) || key.startsWith("origin") || (layout || layoutId !== void 0) && (!!scaleCorrectors[key] || key === "opacity");
 }
 export {
-  c as isForcedMotionValue
+  isForcedMotionValue
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs

@@ -0,0 +1,60 @@
+import { circOut } from "../../easing/circ.mjs";
+import { progress } from "../../utils/progress.mjs";
+import { mixNumber } from "../../utils/mix/number.mjs";
+import { noop } from "../../utils/noop.mjs";
+import { percent, px } from "../../value/types/numbers/units.mjs";
+const borders = ["TopLeft", "TopRight", "BottomLeft", "BottomRight"];
+const numBorders = borders.length;
+const asNumber = (value) => typeof value === "string" ? parseFloat(value) : value;
+const isPx = (value) => typeof value === "number" || px.test(value);
+function mixValues(target, follow, lead, progress2, shouldCrossfadeOpacity, isOnlyMember) {
+  if (shouldCrossfadeOpacity) {
+    target.opacity = mixNumber(
+      0,
+      // TODO Reinstate this if only child
+      lead.opacity !== void 0 ? lead.opacity : 1,
+      easeCrossfadeIn(progress2)
+    );
+    target.opacityExit = mixNumber(follow.opacity !== void 0 ? follow.opacity : 1, 0, easeCrossfadeOut(progress2));
+  } else if (isOnlyMember) {
+    target.opacity = mixNumber(follow.opacity !== void 0 ? follow.opacity : 1, lead.opacity !== void 0 ? lead.opacity : 1, progress2);
+  }
+  for (let i = 0; i < numBorders; i++) {
+    const borderLabel = `border${borders[i]}Radius`;
+    let followRadius = getRadius(follow, borderLabel);
+    let leadRadius = getRadius(lead, borderLabel);
+    if (followRadius === void 0 && leadRadius === void 0)
+      continue;
+    followRadius || (followRadius = 0);
+    leadRadius || (leadRadius = 0);
+    const canMix = followRadius === 0 || leadRadius === 0 || isPx(followRadius) === isPx(leadRadius);
+    if (canMix) {
+      target[borderLabel] = Math.max(mixNumber(asNumber(followRadius), asNumber(leadRadius), progress2), 0);
+      if (percent.test(leadRadius) || percent.test(followRadius)) {
+        target[borderLabel] += "%";
+      }
+    } else {
+      target[borderLabel] = leadRadius;
+    }
+  }
+  if (follow.rotate || lead.rotate) {
+    target.rotate = mixNumber(follow.rotate || 0, lead.rotate || 0, progress2);
+  }
+}
+function getRadius(values, radiusName) {
+  return values[radiusName] !== void 0 ? values[radiusName] : values.borderRadius;
+}
+const easeCrossfadeIn = /* @__PURE__ */ compress(0, 0.5, circOut);
+const easeCrossfadeOut = /* @__PURE__ */ compress(0.5, 0.95, noop);
+function compress(min, max, easing) {
+  return (p) => {
+    if (p < min)
+      return 0;
+    if (p > max)
+      return 1;
+    return easing(progress(min, max, p));
+  };
+}
+export {
+  mixValues
+};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs

@@ -1,21 +1,22 @@
-function n({ top: t, left: o, right: x, bottom: e }) {
+function convertBoundingBoxToBox({ top, left, right, bottom }) {
   return {
-    x: { min: o, max: x },
-    y: { min: t, max: e }
+    x: { min: left, max: right },
+    y: { min: top, max: bottom }
   };
 }
-function r(t, o) {
-  if (!o)
-    return t;
-  const x = o({ x: t.left, y: t.top }), e = o({ x: t.right, y: t.bottom });
+function transformBoxPoints(point, transformPoint) {
+  if (!transformPoint)
+    return point;
+  const topLeft = transformPoint({ x: point.left, y: point.top });
+  const bottomRight = transformPoint({ x: point.right, y: point.bottom });
   return {
-    top: x.y,
-    left: x.x,
-    bottom: e.y,
-    right: e.x
+    top: topLeft.y,
+    left: topLeft.x,
+    bottom: bottomRight.y,
+    right: bottomRight.x
   };
 }
 export {
-  n as convertBoundingBoxToBox,
-  r as transformBoxPoints
+  convertBoundingBoxToBox,
+  transformBoxPoints
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/projection/geometry/copy.mjs

@@ -0,0 +1,19 @@
+function copyAxisInto(axis, originAxis) {
+  axis.min = originAxis.min;
+  axis.max = originAxis.max;
+}
+function copyBoxInto(box, originBox) {
+  copyAxisInto(box.x, originBox.x);
+  copyAxisInto(box.y, originBox.y);
+}
+function copyAxisDeltaInto(delta, originDelta) {
+  delta.translate = originDelta.translate;
+  delta.scale = originDelta.scale;
+  delta.originPoint = originDelta.originPoint;
+  delta.origin = originDelta.origin;
+}
+export {
+  copyAxisDeltaInto,
+  copyAxisInto,
+  copyBoxInto
+};