motion-v 0.2.5 → 0.3.0

package/dist/es/features/gestures/hover.mjs

@@ -0,0 +1,33 @@
+import { dispatchPointerEvent as i } from "../../utils/events.mjs";
+import { BaseGesture as u } from "./base.mjs";
+function o(s, r, e) {
+  return (t) => {
+    t.pointerType && t.pointerType !== "mouse" || (e(), i(s, r, t));
+  };
+}
+class a extends u {
+  isActive() {
+    return !!this.state.getOptions().hover;
+  }
+  constructor(r) {
+    super(r), this.subscribeEvents = () => {
+      const e = this.state.getElement(), t = o(e, "hoverstart", () => {
+        this.state.setActive("hover", !0);
+      }), n = o(e, "hoverend", () => {
+        this.state.setActive("hover", !1);
+      });
+      return e.addEventListener("pointerenter", t), e.addEventListener("pointerleave", n), () => {
+        e.removeEventListener("pointerenter", t), e.removeEventListener("pointerleave", n);
+      };
+    };
+  }
+  mount() {
+    this.updateGestureSubscriptions();
+  }
+  update() {
+    this.updateGestureSubscriptions();
+  }
+}
+export {
+  a as HoverGesture
+};

package/dist/es/features/gestures/in-view.mjs

@@ -0,0 +1,29 @@
+import { dispatchPointerEvent as i } from "../../utils/events.mjs";
+import { inView as p } from "../../node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/dom/viewport/index.mjs";
+import { BaseGesture as a } from "./base.mjs";
+class w extends a {
+  isActive() {
+    return !!this.state.getOptions().inView;
+  }
+  constructor(s) {
+    super(s), this.subscribeEvents = () => {
+      var e;
+      const t = this.state.getElement(), { once: n, ...r } = ((e = this.state.getOptions()) == null ? void 0 : e.inViewOptions) || {};
+      return p(t, (o) => {
+        if (this.state.setActive("inView", !0), i(t, "viewenter", o), !n)
+          return (u) => {
+            this.state.setActive("inView", !1), i(t, "viewleave", u);
+          };
+      }, r);
+    };
+  }
+  mount() {
+    this.updateGestureSubscriptions();
+  }
+  update() {
+    this.updateGestureSubscriptions();
+  }
+}
+export {
+  w as InViewGesture
+};

package/dist/es/features/gestures/press.mjs

@@ -0,0 +1,28 @@
+import { dispatchPointerEvent as r } from "../../utils/events.mjs";
+import { BaseGesture as o } from "./base.mjs";
+class d extends o {
+  isActive() {
+    return !!this.state.getOptions().press;
+  }
+  constructor(i) {
+    super(i), this.subscribeEvents = () => {
+      const e = this.state.getElement(), t = (s) => {
+        this.state.setActive("press", !1), r(e, "pressend", s), window.removeEventListener("pointerup", t);
+      }, n = (s) => {
+        this.state.setActive("press", !0), r(e, "pressstart", s), window.addEventListener("pointerup", t);
+      };
+      return e.addEventListener("pointerdown", n), () => {
+        e.removeEventListener("pointerdown", n), window.removeEventListener("pointerup", t);
+      };
+    };
+  }
+  mount() {
+    this.updateGestureSubscriptions();
+  }
+  update() {
+    this.updateGestureSubscriptions();
+  }
+}
+export {
+  d as PressGesture
+};

package/dist/es/features/svg.mjs

@@ -0,0 +1,30 @@
+import { Feature as i } from "./feature.mjs";
+import { frame as s } from "../node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/frame.mjs";
+function o(e) {
+  return e instanceof SVGElement && e.tagName !== "svg";
+}
+class u extends i {
+  mount() {
+    const t = this.state.getElement();
+    if (!o(t))
+      return;
+    const n = this.state.visualElement;
+    s.read(() => {
+      try {
+        n.renderState.dimensions = typeof t.getBBox == "function" ? t.getBBox() : t.getBoundingClientRect();
+      } catch {
+        n.renderState.dimensions = {
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0
+        };
+      }
+    });
+  }
+  unmount() {
+  }
+}
+export {
+  u as SVGFeature
+};

package/dist/es/index.mjs

@@ -0,0 +1,104 @@
+import { default as e } from "./components/Motion.vue.mjs";
+import { default as m } from "./components/AnimatePresence.vue.mjs";
+import { components as a, utilities as f } from "./constants/index.mjs";
+import { MotionValue as i, motionValue as x, motionValue as s } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/value/index.mjs";
+import { animate as u, createScopedAnimate as l } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animate/index.mjs";
+import { animateMini as d } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/animators/waapi/animate-style.mjs";
+import { scroll as V } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/dom/scroll/index.mjs";
+import { scrollInfo as O } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/dom/scroll/track.mjs";
+import { inView as y } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/render/dom/viewport/index.mjs";
+import { anticipate as k } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/anticipate.mjs";
+import { backIn as A, backInOut as T, backOut as v } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/back.mjs";
+import { circIn as E, circInOut as F, circOut as z } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/circ.mjs";
+import { easeIn as C, easeInOut as P, easeOut as h } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/ease.mjs";
+import { cubicBezier as q } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs";
+import { steps as H } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/steps.mjs";
+import { mirrorEasing as K } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs";
+import { reverseEasing as N } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs";
+import { spring as R } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs";
+import { inertia as W } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/generators/inertia.mjs";
+import { keyframes as Y } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs";
+import { stagger as _ } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/animation/utils/stagger.mjs";
+import { transform as rr } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/transform.mjs";
+import { clamp as er } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/clamp.mjs";
+import { delayInSeconds as mr } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/delay.mjs";
+import { distance as ar, distance2D as fr } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/distance.mjs";
+import { invariant as ir, warning as xr } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/errors.mjs";
+import { interpolate as cr } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/interpolate.mjs";
+import { mix as lr } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/mix/index.mjs";
+import { pipe as dr } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/pipe.mjs";
+import { progress as Vr } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/progress.mjs";
+import { wrap as Or } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/wrap.mjs";
+import { cancelSync as yr, sync as br } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/index-legacy.mjs";
+import { cancelFrame as wr, frame as Ar, frameData as Tr, frameSteps as vr } from "./node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/frameloop/frame.mjs";
+import { useTransform as Er } from "./value/use-transform.mjs";
+import { useTime as zr } from "./value/use-time.mjs";
+import { useMotionTemplate as Cr } from "./value/use-motion-template.mjs";
+import { useSpring as hr } from "./value/use-spring.mjs";
+import { useScroll as qr } from "./value/use-scroll.mjs";
+import { useAnimate as Hr } from "./animation/use-animate.mjs";
+import { createContext as Kr } from "./utils/createContext.mjs";
+import { isMotionValue as Nr } from "./utils/motion-value.mjs";
+import { useInView as Rr } from "./utils/use-in-view.mjs";
+import { useAnimationFrame as Wr } from "./utils/use-animation-frame.mjs";
+export {
+  m as AnimatePresence,
+  e as Motion,
+  i as MotionValue,
+  u as animate,
+  d as animateMini,
+  k as anticipate,
+  A as backIn,
+  T as backInOut,
+  v as backOut,
+  wr as cancelFrame,
+  yr as cancelSync,
+  E as circIn,
+  F as circInOut,
+  z as circOut,
+  er as clamp,
+  a as components,
+  Kr as createContext,
+  l as createScopedAnimate,
+  q as cubicBezier,
+  mr as delay,
+  ar as distance,
+  fr as distance2D,
+  C as easeIn,
+  P as easeInOut,
+  h as easeOut,
+  Ar as frame,
+  Tr as frameData,
+  vr as frameSteps,
+  y as inView,
+  W as inertia,
+  cr as interpolate,
+  ir as invariant,
+  Nr as isMotionValue,
+  Y as keyframes,
+  K as mirrorEasing,
+  lr as mix,
+  x as motionValue,
+  dr as pipe,
+  Vr as progress,
+  N as reverseEasing,
+  V as scroll,
+  O as scrollInfo,
+  R as spring,
+  _ as stagger,
+  H as steps,
+  br as sync,
+  rr as transform,
+  Hr as useAnimate,
+  Wr as useAnimationFrame,
+  Rr as useInView,
+  Cr as useMotionTemplate,
+  s as useMotionValue,
+  qr as useScroll,
+  hr as useSpring,
+  zr as useTime,
+  Er as useTransform,
+  f as utilities,
+  xr as warning,
+  Or as wrap
+};

package/dist/es/node_modules/.pnpm/@vueuse_shared@11.1.0_vue@3.4.38_typescript@5.5.4_/node_modules/@vueuse/shared/index.mjs

@@ -0,0 +1,6 @@
+import "vue";
+typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
+const n = (e) => typeof e < "u";
+export {
+  n as isDef
+};

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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,202 @@
+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

@@ -0,0 +1,79 @@
+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
+};