motion-v 0.3.0 → 0.3.1-beta.1

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

@@ -1,66 +0,0 @@
-import { supportsScrollTimeline as n } from "../render/dom/scroll/supports.mjs";
-class o {
-  constructor(t) {
-    this.stop = () => this.runAll("stop"), this.animations = t.filter(Boolean);
-  }
-  then(t, e) {
-    return Promise.all(this.animations).then(t).catch(e);
-  }
-  /**
-   * TODO: Filter out cancelled or stopped animations before returning
-   */
-  getAll(t) {
-    return this.animations[0][t];
-  }
-  setAll(t, e) {
-    for (let s = 0; s < this.animations.length; s++)
-      this.animations[s][t] = e;
-  }
-  attachTimeline(t, e) {
-    const s = this.animations.map((i) => n() && i.attachTimeline ? i.attachTimeline(t) : e(i));
-    return () => {
-      s.forEach((i, l) => {
-        i && i(), this.animations[l].stop();
-      });
-    };
-  }
-  get time() {
-    return this.getAll("time");
-  }
-  set time(t) {
-    this.setAll("time", t);
-  }
-  get speed() {
-    return this.getAll("speed");
-  }
-  set speed(t) {
-    this.setAll("speed", t);
-  }
-  get startTime() {
-    return this.getAll("startTime");
-  }
-  get duration() {
-    let t = 0;
-    for (let e = 0; e < this.animations.length; e++)
-      t = Math.max(t, this.animations[e].duration);
-    return t;
-  }
-  runAll(t) {
-    this.animations.forEach((e) => e[t]());
-  }
-  play() {
-    this.runAll("play");
-  }
-  pause() {
-    this.runAll("pause");
-  }
-  cancel() {
-    this.runAll("cancel");
-  }
-  complete() {
-    this.runAll("complete");
-  }
-}
-export {
-  o as GroupPlaybackControls
-};

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

@@ -1,20 +0,0 @@
-import { GroupPlaybackControls as e } from "../GroupPlaybackControls.mjs";
-import { animateSequence as f } from "./sequence.mjs";
-import { animateSubject as u } from "./subject.mjs";
-function A(n) {
-  return Array.isArray(n) && Array.isArray(n[0]);
-}
-function c(n) {
-  function o(i, r, m) {
-    let t = [];
-    A(i) ? t = f(i, r, n) : t = u(i, r, m, n);
-    const a = new e(t);
-    return n && n.animations.push(a), a;
-  }
-  return o;
-}
-const l = c();
-export {
-  l as animate,
-  c as createScopedAnimate
-};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animate/resolve-subjects.mjs

@@ -1,8 +0,0 @@
-import { resolveElements as f } from "../../render/dom/utils/resolve-element.mjs";
-import { isDOMKeyframes as n } from "../utils/is-dom-keyframes.mjs";
-function s(r, e, o, i) {
-  return typeof r == "string" && n(e) ? f(r, o, i) : r instanceof NodeList ? Array.from(r) : Array.isArray(r) ? r : [r];
-}
-export {
-  s as resolveSubjects
-};

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

@@ -1,12 +0,0 @@
-import { spring as r } from "../generators/spring/index.mjs";
-import { createAnimationsFromSequence as c } from "../sequence/create.mjs";
-import { animateSubject as s } from "./subject.mjs";
-function h(i, o, t) {
-  const n = [];
-  return c(i, o, t, { spring: r }).forEach(({ keyframes: e, transition: a }, m) => {
-    n.push(...s(m, e, a));
-  }), n;
-}
-export {
-  h as animateSequence
-};

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

@@ -1,10 +0,0 @@
-import { animateMotionValue as m } from "../interfaces/motion-value.mjs";
-import { motionValue as a } from "../../value/index.mjs";
-import { isMotionValue as r } from "../../value/utils/is-motion-value.mjs";
-function f(o, i, n) {
-  const t = r(o) ? o : a(o);
-  return t.start(m("", t, i, n)), t.animation;
-}
-export {
-  f as animateSingleValue
-};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animate/subject.mjs

@@ -1,30 +0,0 @@
-import { visualElementStore as u } from "../../render/store.mjs";
-import { invariant as d } from "../../utils/errors.mjs";
-import { isMotionValue as S } from "../../value/utils/is-motion-value.mjs";
-import { animateTarget as g } from "../interfaces/visual-element-target.mjs";
-import { createDOMVisualElement as v, createObjectVisualElement as E } from "../utils/create-visual-element.mjs";
-import { isDOMKeyframes as s } from "../utils/is-dom-keyframes.mjs";
-import { resolveSubjects as V } from "./resolve-subjects.mjs";
-import { animateSingleValue as h } from "./single-value.mjs";
-function b(e, t) {
-  return S(e) || typeof e == "number" || typeof e == "string" && !s(t);
-}
-function N(e, t, n, c) {
-  const a = [];
-  if (b(e, t))
-    a.push(h(e, s(t) && t.default || t, n && (n.default || n)));
-  else {
-    const m = V(e, t, c), r = m.length;
-    d(!!r, "No valid elements provided.");
-    for (let o = 0; o < r; o++) {
-      const l = m[o], f = l instanceof Element ? v : E;
-      u.has(l) || f(l);
-      const p = u.get(l), i = { ...n };
-      "delay" in i && typeof i.delay == "function" && (i.delay = i.delay(o, r)), a.push(...g(p, { ...t, transition: i }, {}));
-    }
-  }
-  return a;
-}
-export {
-  N as animateSubject
-};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.mjs

@@ -1,202 +0,0 @@
-import { anticipate as F } from "../../easing/anticipate.mjs";
-import { backInOut as K } from "../../easing/back.mjs";
-import { circInOut as E } from "../../easing/circ.mjs";
-import { DOMKeyframesResolver as R } from "../../render/dom/DOMKeyframesResolver.mjs";
-import { noop as g } from "../../utils/noop.mjs";
-import { millisecondsToSeconds as T, secondsToMilliseconds as S } from "../../utils/time-conversion.mjs";
-import { isGenerator as b } from "../generators/utils/is-generator.mjs";
-import { BaseAnimation as D } from "./BaseAnimation.mjs";
-import { MainThreadAnimation as A } from "./MainThreadAnimation.mjs";
-import { acceleratedValues as M } from "./utils/accelerated-values.mjs";
-import { startWaapiAnimation as U } from "./waapi/index.mjs";
-import { isWaapiSupportedEasing as W } from "./waapi/easing.mjs";
-import { attachTimeline as w } from "./waapi/utils/attach-timeline.mjs";
-import { getFinalKeyframe as x } from "./waapi/utils/get-final-keyframe.mjs";
-import { supportsLinearEasing as C } from "./waapi/utils/supports-linear-easing.mjs";
-import { supportsWaapi as G } from "./waapi/utils/supports-waapi.mjs";
-const d = 10, O = 2e4;
-function k(r) {
-  return b(r.type) || r.type === "spring" || !W(r.ease);
-}
-function I(r, e) {
-  const t = new A({
-    ...e,
-    keyframes: r,
-    repeat: 0,
-    delay: 0,
-    isGenerator: !0
-  });
-  let i = { done: !1, value: r[0] };
-  const s = [];
-  let n = 0;
-  for (; !i.done && n < O; )
-    i = t.sample(n), s.push(i.value), n += d;
-  return {
-    times: void 0,
-    keyframes: s,
-    duration: n - d,
-    ease: "linear"
-  };
-}
-const P = {
-  anticipate: F,
-  backInOut: K,
-  circInOut: E
-};
-function L(r) {
-  return r in P;
-}
-class ne extends D {
-  constructor(e) {
-    super(e);
-    const { name: t, motionValue: i, element: s, keyframes: n } = this.options;
-    this.resolver = new R(n, (o, a) => this.onKeyframesResolved(o, a), t, i, s), this.resolver.scheduleResolve();
-  }
-  initPlayback(e, t) {
-    var i;
-    let { duration: s = 300, times: n, ease: o, type: a, motionValue: m, name: h, startTime: p } = this.options;
-    if (!(!((i = m.owner) === null || i === void 0) && i.current))
-      return !1;
-    if (typeof o == "string" && C() && L(o) && (o = P[o]), k(this.options)) {
-      const { onComplete: c, onUpdate: y, motionValue: f, element: v, ...V } = this.options, u = I(e, V);
-      e = u.keyframes, e.length === 1 && (e[1] = e[0]), s = u.duration, n = u.times, o = u.ease, a = "keyframes";
-    }
-    const l = U(m.owner.current, h, e, { ...this.options, duration: s, times: n, ease: o });
-    return l.startTime = p ?? this.calcStartTime(), this.pendingTimeline ? (w(l, this.pendingTimeline), this.pendingTimeline = void 0) : l.onfinish = () => {
-      const { onComplete: c } = this.options;
-      m.set(x(e, this.options, t)), c && c(), this.cancel(), this.resolveFinishedPromise();
-    }, {
-      animation: l,
-      duration: s,
-      times: n,
-      type: a,
-      ease: o,
-      keyframes: e
-    };
-  }
-  get duration() {
-    const { resolved: e } = this;
-    if (!e)
-      return 0;
-    const { duration: t } = e;
-    return T(t);
-  }
-  get time() {
-    const { resolved: e } = this;
-    if (!e)
-      return 0;
-    const { animation: t } = e;
-    return T(t.currentTime || 0);
-  }
-  set time(e) {
-    const { resolved: t } = this;
-    if (!t)
-      return;
-    const { animation: i } = t;
-    i.currentTime = S(e);
-  }
-  get speed() {
-    const { resolved: e } = this;
-    if (!e)
-      return 1;
-    const { animation: t } = e;
-    return t.playbackRate;
-  }
-  set speed(e) {
-    const { resolved: t } = this;
-    if (!t)
-      return;
-    const { animation: i } = t;
-    i.playbackRate = e;
-  }
-  get state() {
-    const { resolved: e } = this;
-    if (!e)
-      return "idle";
-    const { animation: t } = e;
-    return t.playState;
-  }
-  get startTime() {
-    const { resolved: e } = this;
-    if (!e)
-      return null;
-    const { animation: t } = e;
-    return t.startTime;
-  }
-  /**
-   * Replace the default DocumentTimeline with another AnimationTimeline.
-   * Currently used for scroll animations.
-   */
-  attachTimeline(e) {
-    if (!this._resolved)
-      this.pendingTimeline = e;
-    else {
-      const { resolved: t } = this;
-      if (!t)
-        return g;
-      const { animation: i } = t;
-      w(i, e);
-    }
-    return g;
-  }
-  play() {
-    if (this.isStopped)
-      return;
-    const { resolved: e } = this;
-    if (!e)
-      return;
-    const { animation: t } = e;
-    t.playState === "finished" && this.updateFinishedPromise(), t.play();
-  }
-  pause() {
-    const { resolved: e } = this;
-    if (!e)
-      return;
-    const { animation: t } = e;
-    t.pause();
-  }
-  stop() {
-    if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
-      return;
-    this.resolveFinishedPromise(), this.updateFinishedPromise();
-    const { resolved: e } = this;
-    if (!e)
-      return;
-    const { animation: t, keyframes: i, duration: s, type: n, ease: o, times: a } = e;
-    if (t.playState === "idle" || t.playState === "finished")
-      return;
-    if (this.time) {
-      const { motionValue: h, onUpdate: p, onComplete: l, element: c, ...y } = this.options, f = new A({
-        ...y,
-        keyframes: i,
-        duration: s,
-        type: n,
-        ease: o,
-        times: a,
-        isGenerator: !0
-      }), v = S(this.time);
-      h.setWithVelocity(f.sample(v - d).value, f.sample(v).value, d);
-    }
-    const { onStop: m } = this.options;
-    m && m(), this.cancel();
-  }
-  complete() {
-    const { resolved: e } = this;
-    e && e.animation.finish();
-  }
-  cancel() {
-    const { resolved: e } = this;
-    e && e.animation.cancel();
-  }
-  static supports(e) {
-    const { motionValue: t, name: i, repeatDelay: s, repeatType: n, damping: o, type: a } = e;
-    return G() && i && M.has(i) && t && t.owner && t.owner.current instanceof HTMLElement && /**
-     * If we're outputting values to onUpdate then we can't use WAAPI as there's
-     * no way to read the value from WAAPI every frame.
-     */
-    !t.owner.getProps().onUpdate && !s && n !== "mirror" && o !== 0 && a !== "inertia";
-  }
-}
-export {
-  ne as AcceleratedAnimation
-};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs

@@ -1,79 +0,0 @@
-import { time as l } from "../../frameloop/sync-time.mjs";
-import { flushKeyframeResolvers as m } from "../../render/utils/KeyframesResolver.mjs";
-import { canAnimate as v } from "./utils/can-animate.mjs";
-import { getFinalKeyframe as p } from "./waapi/utils/get-final-keyframe.mjs";
-const c = 40;
-class F {
-  constructor({ autoplay: e = !0, delay: t = 0, type: i = "keyframes", repeat: o = 0, repeatDelay: r = 0, repeatType: n = "loop", ...s }) {
-    this.isStopped = !1, this.hasAttemptedResolve = !1, this.createdAt = l.now(), this.options = {
-      autoplay: e,
-      delay: t,
-      type: i,
-      repeat: o,
-      repeatDelay: r,
-      repeatType: n,
-      ...s
-    }, this.updateFinishedPromise();
-  }
-  /**
-   * This method uses the createdAt and resolvedAt to calculate the
-   * animation startTime. *Ideally*, we would use the createdAt time as t=0
-   * as the following frame would then be the first frame of the animation in
-   * progress, which would feel snappier.
-   *
-   * However, if there's a delay (main thread work) between the creation of
-   * the animation and the first commited frame, we prefer to use resolvedAt
-   * to avoid a sudden jump into the animation.
-   */
-  calcStartTime() {
-    return this.resolvedAt ? this.resolvedAt - this.createdAt > c ? this.resolvedAt : this.createdAt : this.createdAt;
-  }
-  /**
-   * A getter for resolved data. If keyframes are not yet resolved, accessing
-   * this.resolved will synchronously flush all pending keyframe resolvers.
-   * This is a deoptimisation, but at its worst still batches read/writes.
-   */
-  get resolved() {
-    return !this._resolved && !this.hasAttemptedResolve && m(), this._resolved;
-  }
-  /**
-   * A method to be called when the keyframes resolver completes. This method
-   * will check if its possible to run the animation and, if not, skip it.
-   * Otherwise, it will call initPlayback on the implementing class.
-   */
-  onKeyframesResolved(e, t) {
-    this.resolvedAt = l.now(), this.hasAttemptedResolve = !0;
-    const { name: i, type: o, velocity: r, delay: n, onComplete: s, onUpdate: h, isGenerator: a } = this.options;
-    if (!a && !v(e, i, o, r))
-      if (n)
-        this.options.duration = 0;
-      else {
-        h == null || h(p(e, this.options, t)), s == null || s(), this.resolveFinishedPromise();
-        return;
-      }
-    const d = this.initPlayback(e, t);
-    d !== !1 && (this._resolved = {
-      keyframes: e,
-      finalKeyframe: t,
-      ...d
-    }, this.onPostResolved());
-  }
-  onPostResolved() {
-  }
-  /**
-   * Allows the returned animation to be awaited or promise-chained. Currently
-   * resolves when the animation finishes at all but in a future update could/should
-   * reject if its cancels.
-   */
-  then(e, t) {
-    return this.currentFinishedPromise.then(e, t);
-  }
-  updateFinishedPromise() {
-    this.currentFinishedPromise = new Promise((e) => {
-      this.resolveFinishedPromise = e;
-    });
-  }
-}
-export {
-  F as BaseAnimation
-};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs

@@ -1,148 +0,0 @@
-import { KeyframeResolver as x } from "../../render/utils/KeyframesResolver.mjs";
-import { spring as G } from "../generators/spring/index.mjs";
-import { inertia as b } from "../generators/inertia.mjs";
-import { keyframes as y } from "../generators/keyframes.mjs";
-import { BaseAnimation as I } from "./BaseAnimation.mjs";
-import { pipe as O } from "../../utils/pipe.mjs";
-import { mix as _ } from "../../utils/mix/index.mjs";
-import { calcGeneratorDuration as A } from "../generators/utils/calc-duration.mjs";
-import { millisecondsToSeconds as D, secondsToMilliseconds as V } from "../../utils/time-conversion.mjs";
-import { clamp as B } from "../../utils/clamp.mjs";
-import { invariant as C } from "../../utils/errors.mjs";
-import { frameloopDriver as E } from "./drivers/driver-frameloop.mjs";
-import { getFinalKeyframe as N } from "./waapi/utils/get-final-keyframe.mjs";
-import { isGenerator as U } from "../generators/utils/is-generator.mjs";
-const W = {
-  decay: b,
-  inertia: b,
-  tween: y,
-  keyframes: y,
-  spring: G
-}, j = (p) => p / 100;
-class q extends I {
-  constructor(t) {
-    super(t), this.holdTime = null, this.cancelTime = null, this.currentTime = 0, this.playbackSpeed = 1, this.pendingPlayState = "running", this.startTime = null, this.state = "idle", this.stop = () => {
-      if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
-        return;
-      this.teardown();
-      const { onStop: n } = this.options;
-      n && n();
-    };
-    const { name: i, motionValue: r, element: e, keyframes: o } = this.options, u = (e == null ? void 0 : e.KeyframeResolver) || x, a = (n, l) => this.onKeyframesResolved(n, l);
-    this.resolver = new u(o, a, i, r, e), this.resolver.scheduleResolve();
-  }
-  initPlayback(t) {
-    const { type: i = "keyframes", repeat: r = 0, repeatDelay: e = 0, repeatType: o, velocity: u = 0 } = this.options, a = U(i) ? i : W[i] || y;
-    let n, l;
-    a !== y && typeof t[0] != "number" && (process.env.NODE_ENV !== "production" && C(t.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${t}`), n = O(j, _(t[0], t[1])), t = [0, 100]);
-    const s = a({ ...this.options, keyframes: t });
-    o === "mirror" && (l = a({
-      ...this.options,
-      keyframes: [...t].reverse(),
-      velocity: -u
-    })), s.calculatedDuration === null && (s.calculatedDuration = A(s));
-    const { calculatedDuration: d } = s, f = d + e, T = f * (r + 1) - e;
-    return {
-      generator: s,
-      mirroredGenerator: l,
-      mapPercentToKeyframes: n,
-      calculatedDuration: d,
-      resolvedDuration: f,
-      totalDuration: T
-    };
-  }
-  onPostResolved() {
-    const { autoplay: t = !0 } = this.options;
-    this.play(), this.pendingPlayState === "paused" || !t ? this.pause() : this.state = this.pendingPlayState;
-  }
-  tick(t, i = !1) {
-    const { resolved: r } = this;
-    if (!r) {
-      const { keyframes: c } = this.options;
-      return { done: !0, value: c[c.length - 1] };
-    }
-    const { finalKeyframe: e, generator: o, mirroredGenerator: u, mapPercentToKeyframes: a, keyframes: n, calculatedDuration: l, totalDuration: s, resolvedDuration: d } = r;
-    if (this.startTime === null)
-      return o.next(0);
-    const { delay: f, repeat: T, repeatType: P, repeatDelay: S, onUpdate: k } = this.options;
-    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - s / this.speed, this.startTime)), i ? this.currentTime = t : this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = Math.round(t - this.startTime) * this.speed;
-    const g = this.currentTime - f * (this.speed >= 0 ? 1 : -1), M = this.speed >= 0 ? g < 0 : g > s;
-    this.currentTime = Math.max(g, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = s);
-    let K = this.currentTime, w = o;
-    if (T) {
-      const c = Math.min(this.currentTime, s) / d;
-      let v = Math.floor(c), h = c % 1;
-      !h && c >= 1 && (h = 1), h === 1 && v--, v = Math.min(v, T + 1), !!(v % 2) && (P === "reverse" ? (h = 1 - h, S && (h -= S / d)) : P === "mirror" && (w = u)), K = B(0, 1, h) * d;
-    }
-    const m = M ? { done: !1, value: n[0] } : w.next(K);
-    a && (m.value = a(m.value));
-    let { done: F } = m;
-    !M && l !== null && (F = this.speed >= 0 ? this.currentTime >= s : this.currentTime <= 0);
-    const R = this.holdTime === null && (this.state === "finished" || this.state === "running" && F);
-    return R && e !== void 0 && (m.value = N(n, this.options, e)), k && k(m.value), R && this.finish(), m;
-  }
-  get duration() {
-    const { resolved: t } = this;
-    return t ? D(t.calculatedDuration) : 0;
-  }
-  get time() {
-    return D(this.currentTime);
-  }
-  set time(t) {
-    t = V(t), this.currentTime = t, this.holdTime !== null || this.speed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.speed);
-  }
-  get speed() {
-    return this.playbackSpeed;
-  }
-  set speed(t) {
-    const i = this.playbackSpeed !== t;
-    this.playbackSpeed = t, i && (this.time = D(this.currentTime));
-  }
-  play() {
-    if (this.resolver.isScheduled || this.resolver.resume(), !this._resolved) {
-      this.pendingPlayState = "running";
-      return;
-    }
-    if (this.isStopped)
-      return;
-    const { driver: t = E, onPlay: i, startTime: r } = this.options;
-    this.driver || (this.driver = t((o) => this.tick(o))), i && i();
-    const e = this.driver.now();
-    this.holdTime !== null ? this.startTime = e - this.holdTime : this.startTime ? this.state === "finished" && (this.startTime = e) : this.startTime = r ?? this.calcStartTime(), this.state === "finished" && this.updateFinishedPromise(), this.cancelTime = this.startTime, this.holdTime = null, this.state = "running", this.driver.start();
-  }
-  pause() {
-    var t;
-    if (!this._resolved) {
-      this.pendingPlayState = "paused";
-      return;
-    }
-    this.state = "paused", this.holdTime = (t = this.currentTime) !== null && t !== void 0 ? t : 0;
-  }
-  complete() {
-    this.state !== "running" && this.play(), this.pendingPlayState = this.state = "finished", this.holdTime = null;
-  }
-  finish() {
-    this.teardown(), this.state = "finished";
-    const { onComplete: t } = this.options;
-    t && t();
-  }
-  cancel() {
-    this.cancelTime !== null && this.tick(this.cancelTime), this.teardown(), this.updateFinishedPromise();
-  }
-  teardown() {
-    this.state = "idle", this.stopDriver(), this.resolveFinishedPromise(), this.updateFinishedPromise(), this.startTime = this.cancelTime = null, this.resolver.cancel();
-  }
-  stopDriver() {
-    this.driver && (this.driver.stop(), this.driver = void 0);
-  }
-  sample(t) {
-    return this.startTime = 0, this.tick(t, !0);
-  }
-}
-function ot(p) {
-  return new q(p);
-}
-export {
-  q as MainThreadAnimation,
-  ot as animateValue
-};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.mjs

@@ -1,17 +0,0 @@
-import { time as o } from "../../../frameloop/sync-time.mjs";
-import { frame as a, cancelFrame as s, frameData as t } from "../../../frameloop/frame.mjs";
-const n = (e) => {
-  const r = ({ timestamp: m }) => e(m);
-  return {
-    start: () => a.update(r, !0),
-    stop: () => s(r),
-    /**
-     * If we're processing this frame we can use the
-     * framelocked timestamp to keep things in sync.
-     */
-    now: () => t.isProcessing ? t.timestamp : o.now()
-  };
-};
-export {
-  n as frameloopDriver
-};

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.mjs

@@ -1,23 +0,0 @@
-import { warning as s } from "../../../utils/errors.mjs";
-import { isGenerator as f } from "../../generators/utils/is-generator.mjs";
-import { isAnimatable as l } from "../../utils/is-animatable.mjs";
-function g(t) {
-  const i = t[0];
-  if (t.length === 1)
-    return !0;
-  for (let n = 0; n < t.length; n++)
-    if (t[n] !== i)
-      return !0;
-}
-function h(t, i, n, u) {
-  const r = t[0];
-  if (r === null)
-    return !1;
-  if (i === "display" || i === "visibility")
-    return !0;
-  const a = t[t.length - 1], e = l(r, i), o = l(a, i);
-  return s(e === o, `You are trying to animate ${i} from "${r}" to "${a}". ${r} is not an animatable value - to enable this animation set ${r} to a value animatable to ${a} via the \`style\` property.`), !e || !o ? !1 : g(t) || (n === "spring" || f(n)) && u;
-}
-export {
-  h as canAnimate
-};