motion-v 0.3.0 → 0.3.1-beta.1

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

@@ -0,0 +1,11 @@
+import { animateMotionValue } from "../interfaces/motion-value.mjs";
+import { motionValue } from "../../value/index.mjs";
+import { isMotionValue } from "../../value/utils/is-motion-value.mjs";
+function animateSingleValue(value, keyframes, options) {
+  const motionValue$1 = isMotionValue(value) ? value : motionValue(value);
+  motionValue$1.start(animateMotionValue("", motionValue$1, keyframes, options));
+  return motionValue$1.animation;
+}
+export {
+  animateSingleValue
+};

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

@@ -0,0 +1,38 @@
+import { visualElementStore } from "../../render/store.mjs";
+import { invariant } from "../../utils/errors.mjs";
+import { isMotionValue } from "../../value/utils/is-motion-value.mjs";
+import { animateTarget } from "../interfaces/visual-element-target.mjs";
+import { createDOMVisualElement, createObjectVisualElement } from "../utils/create-visual-element.mjs";
+import { isDOMKeyframes } from "../utils/is-dom-keyframes.mjs";
+import { resolveSubjects } from "./resolve-subjects.mjs";
+import { animateSingleValue } from "./single-value.mjs";
+function isSingleValue(subject, keyframes) {
+  return isMotionValue(subject) || typeof subject === "number" || typeof subject === "string" && !isDOMKeyframes(keyframes);
+}
+function animateSubject(subject, keyframes, options, scope) {
+  const animations = [];
+  if (isSingleValue(subject, keyframes)) {
+    animations.push(animateSingleValue(subject, isDOMKeyframes(keyframes) ? keyframes.default || keyframes : keyframes, options ? options.default || options : options));
+  } else {
+    const subjects = resolveSubjects(subject, keyframes, scope);
+    const numSubjects = subjects.length;
+    invariant(Boolean(numSubjects), "No valid elements provided.");
+    for (let i = 0; i < numSubjects; i++) {
+      const thisSubject = subjects[i];
+      const createVisualElement = thisSubject instanceof Element ? createDOMVisualElement : createObjectVisualElement;
+      if (!visualElementStore.has(thisSubject)) {
+        createVisualElement(thisSubject);
+      }
+      const visualElement = visualElementStore.get(thisSubject);
+      const transition = { ...options };
+      if ("delay" in transition && typeof transition.delay === "function") {
+        transition.delay = transition.delay(i, numSubjects);
+      }
+      animations.push(...animateTarget(visualElement, { ...keyframes, transition }, {}));
+    }
+  }
+  return animations;
+}
+export {
+  animateSubject
+};

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

@@ -0,0 +1,243 @@
+import { anticipate } from "../../easing/anticipate.mjs";
+import { backInOut } from "../../easing/back.mjs";
+import { circInOut } from "../../easing/circ.mjs";
+import { DOMKeyframesResolver } from "../../render/dom/DOMKeyframesResolver.mjs";
+import { noop } from "../../utils/noop.mjs";
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../utils/time-conversion.mjs";
+import { isGenerator } from "../generators/utils/is-generator.mjs";
+import { BaseAnimation } from "./BaseAnimation.mjs";
+import { MainThreadAnimation } from "./MainThreadAnimation.mjs";
+import { acceleratedValues } from "./utils/accelerated-values.mjs";
+import { startWaapiAnimation } from "./waapi/index.mjs";
+import { isWaapiSupportedEasing } from "./waapi/easing.mjs";
+import { attachTimeline } from "./waapi/utils/attach-timeline.mjs";
+import { getFinalKeyframe } from "./waapi/utils/get-final-keyframe.mjs";
+import { supportsLinearEasing } from "./waapi/utils/supports-linear-easing.mjs";
+import { supportsWaapi } from "./waapi/utils/supports-waapi.mjs";
+const sampleDelta = 10;
+const maxDuration = 2e4;
+function requiresPregeneratedKeyframes(options) {
+  return isGenerator(options.type) || options.type === "spring" || !isWaapiSupportedEasing(options.ease);
+}
+function pregenerateKeyframes(keyframes, options) {
+  const sampleAnimation = new MainThreadAnimation({
+    ...options,
+    keyframes,
+    repeat: 0,
+    delay: 0,
+    isGenerator: true
+  });
+  let state = { done: false, value: keyframes[0] };
+  const pregeneratedKeyframes = [];
+  let t = 0;
+  while (!state.done && t < maxDuration) {
+    state = sampleAnimation.sample(t);
+    pregeneratedKeyframes.push(state.value);
+    t += sampleDelta;
+  }
+  return {
+    times: void 0,
+    keyframes: pregeneratedKeyframes,
+    duration: t - sampleDelta,
+    ease: "linear"
+  };
+}
+const unsupportedEasingFunctions = {
+  anticipate,
+  backInOut,
+  circInOut
+};
+function isUnsupportedEase(key) {
+  return key in unsupportedEasingFunctions;
+}
+class AcceleratedAnimation extends BaseAnimation {
+  constructor(options) {
+    super(options);
+    const { name, motionValue, element, keyframes } = this.options;
+    this.resolver = new DOMKeyframesResolver(keyframes, (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe), name, motionValue, element);
+    this.resolver.scheduleResolve();
+  }
+  initPlayback(keyframes, finalKeyframe) {
+    var _a;
+    let { duration = 300, times, ease, type, motionValue, name, startTime } = this.options;
+    if (!((_a = motionValue.owner) === null || _a === void 0 ? void 0 : _a.current)) {
+      return false;
+    }
+    if (typeof ease === "string" && supportsLinearEasing() && isUnsupportedEase(ease)) {
+      ease = unsupportedEasingFunctions[ease];
+    }
+    if (requiresPregeneratedKeyframes(this.options)) {
+      const { onComplete, onUpdate, motionValue: motionValue2, element, ...options } = this.options;
+      const pregeneratedAnimation = pregenerateKeyframes(keyframes, options);
+      keyframes = pregeneratedAnimation.keyframes;
+      if (keyframes.length === 1) {
+        keyframes[1] = keyframes[0];
+      }
+      duration = pregeneratedAnimation.duration;
+      times = pregeneratedAnimation.times;
+      ease = pregeneratedAnimation.ease;
+      type = "keyframes";
+    }
+    const animation = startWaapiAnimation(motionValue.owner.current, name, keyframes, { ...this.options, duration, times, ease });
+    animation.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();
+    if (this.pendingTimeline) {
+      attachTimeline(animation, this.pendingTimeline);
+      this.pendingTimeline = void 0;
+    } else {
+      animation.onfinish = () => {
+        const { onComplete } = this.options;
+        motionValue.set(getFinalKeyframe(keyframes, this.options, finalKeyframe));
+        onComplete && onComplete();
+        this.cancel();
+        this.resolveFinishedPromise();
+      };
+    }
+    return {
+      animation,
+      duration,
+      times,
+      type,
+      ease,
+      keyframes
+    };
+  }
+  get duration() {
+    const { resolved } = this;
+    if (!resolved)
+      return 0;
+    const { duration } = resolved;
+    return millisecondsToSeconds(duration);
+  }
+  get time() {
+    const { resolved } = this;
+    if (!resolved)
+      return 0;
+    const { animation } = resolved;
+    return millisecondsToSeconds(animation.currentTime || 0);
+  }
+  set time(newTime) {
+    const { resolved } = this;
+    if (!resolved)
+      return;
+    const { animation } = resolved;
+    animation.currentTime = secondsToMilliseconds(newTime);
+  }
+  get speed() {
+    const { resolved } = this;
+    if (!resolved)
+      return 1;
+    const { animation } = resolved;
+    return animation.playbackRate;
+  }
+  set speed(newSpeed) {
+    const { resolved } = this;
+    if (!resolved)
+      return;
+    const { animation } = resolved;
+    animation.playbackRate = newSpeed;
+  }
+  get state() {
+    const { resolved } = this;
+    if (!resolved)
+      return "idle";
+    const { animation } = resolved;
+    return animation.playState;
+  }
+  get startTime() {
+    const { resolved } = this;
+    if (!resolved)
+      return null;
+    const { animation } = resolved;
+    return animation.startTime;
+  }
+  /**
+   * Replace the default DocumentTimeline with another AnimationTimeline.
+   * Currently used for scroll animations.
+   */
+  attachTimeline(timeline) {
+    if (!this._resolved) {
+      this.pendingTimeline = timeline;
+    } else {
+      const { resolved } = this;
+      if (!resolved)
+        return noop;
+      const { animation } = resolved;
+      attachTimeline(animation, timeline);
+    }
+    return noop;
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { resolved } = this;
+    if (!resolved)
+      return;
+    const { animation } = resolved;
+    if (animation.playState === "finished") {
+      this.updateFinishedPromise();
+    }
+    animation.play();
+  }
+  pause() {
+    const { resolved } = this;
+    if (!resolved)
+      return;
+    const { animation } = resolved;
+    animation.pause();
+  }
+  stop() {
+    this.resolver.cancel();
+    this.isStopped = true;
+    if (this.state === "idle")
+      return;
+    this.resolveFinishedPromise();
+    this.updateFinishedPromise();
+    const { resolved } = this;
+    if (!resolved)
+      return;
+    const { animation, keyframes, duration, type, ease, times } = resolved;
+    if (animation.playState === "idle" || animation.playState === "finished") {
+      return;
+    }
+    if (this.time) {
+      const { motionValue, onUpdate, onComplete, element, ...options } = this.options;
+      const sampleAnimation = new MainThreadAnimation({
+        ...options,
+        keyframes,
+        duration,
+        type,
+        ease,
+        times,
+        isGenerator: true
+      });
+      const sampleTime = secondsToMilliseconds(this.time);
+      motionValue.setWithVelocity(sampleAnimation.sample(sampleTime - sampleDelta).value, sampleAnimation.sample(sampleTime).value, sampleDelta);
+    }
+    const { onStop } = this.options;
+    onStop && onStop();
+    this.cancel();
+  }
+  complete() {
+    const { resolved } = this;
+    if (!resolved)
+      return;
+    resolved.animation.finish();
+  }
+  cancel() {
+    const { resolved } = this;
+    if (!resolved)
+      return;
+    resolved.animation.cancel();
+  }
+  static supports(options) {
+    const { motionValue, name, repeatDelay, repeatType, damping, type } = options;
+    return supportsWaapi() && name && acceleratedValues.has(name) && motionValue && motionValue.owner && motionValue.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.
+     */
+    !motionValue.owner.getProps().onUpdate && !repeatDelay && repeatType !== "mirror" && damping !== 0 && type !== "inertia";
+  }
+}
+export {
+  AcceleratedAnimation
+};

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

@@ -0,0 +1,95 @@
+import { time } from "../../frameloop/sync-time.mjs";
+import { flushKeyframeResolvers } from "../../render/utils/KeyframesResolver.mjs";
+import { canAnimate } from "./utils/can-animate.mjs";
+import { getFinalKeyframe } from "./waapi/utils/get-final-keyframe.mjs";
+const MAX_RESOLVE_DELAY = 40;
+class BaseAnimation {
+  constructor({ autoplay = true, delay = 0, type = "keyframes", repeat = 0, repeatDelay = 0, repeatType = "loop", ...options }) {
+    this.isStopped = false;
+    this.hasAttemptedResolve = false;
+    this.createdAt = time.now();
+    this.options = {
+      autoplay,
+      delay,
+      type,
+      repeat,
+      repeatDelay,
+      repeatType,
+      ...options
+    };
+    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() {
+    if (!this.resolvedAt)
+      return this.createdAt;
+    return this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY ? this.resolvedAt : 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() {
+    if (!this._resolved && !this.hasAttemptedResolve) {
+      flushKeyframeResolvers();
+    }
+    return 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(keyframes, finalKeyframe) {
+    this.resolvedAt = time.now();
+    this.hasAttemptedResolve = true;
+    const { name, type, velocity, delay, onComplete, onUpdate, isGenerator } = this.options;
+    if (!isGenerator && !canAnimate(keyframes, name, type, velocity)) {
+      if (!delay) {
+        onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(getFinalKeyframe(keyframes, this.options, finalKeyframe));
+        onComplete === null || onComplete === void 0 ? void 0 : onComplete();
+        this.resolveFinishedPromise();
+        return;
+      } else {
+        this.options.duration = 0;
+      }
+    }
+    const resolvedAnimation = this.initPlayback(keyframes, finalKeyframe);
+    if (resolvedAnimation === false)
+      return;
+    this._resolved = {
+      keyframes,
+      finalKeyframe,
+      ...resolvedAnimation
+    };
+    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(resolve, reject) {
+    return this.currentFinishedPromise.then(resolve, reject);
+  }
+  updateFinishedPromise() {
+    this.currentFinishedPromise = new Promise((resolve) => {
+      this.resolveFinishedPromise = resolve;
+    });
+  }
+}
+export {
+  BaseAnimation
+};

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

@@ -0,0 +1,275 @@
+import { KeyframeResolver } from "../../render/utils/KeyframesResolver.mjs";
+import { spring } from "../generators/spring/index.mjs";
+import { inertia } from "../generators/inertia.mjs";
+import { keyframes } from "../generators/keyframes.mjs";
+import { BaseAnimation } from "./BaseAnimation.mjs";
+import { pipe } from "../../utils/pipe.mjs";
+import { mix } from "../../utils/mix/index.mjs";
+import { calcGeneratorDuration } from "../generators/utils/calc-duration.mjs";
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../utils/time-conversion.mjs";
+import { clamp } from "../../utils/clamp.mjs";
+import { invariant } from "../../utils/errors.mjs";
+import { frameloopDriver } from "./drivers/driver-frameloop.mjs";
+import { getFinalKeyframe } from "./waapi/utils/get-final-keyframe.mjs";
+import { isGenerator } from "../generators/utils/is-generator.mjs";
+const generators = {
+  decay: inertia,
+  inertia,
+  tween: keyframes,
+  keyframes,
+  spring
+};
+const percentToProgress = (percent) => percent / 100;
+class MainThreadAnimation extends BaseAnimation {
+  constructor(options) {
+    super(options);
+    this.holdTime = null;
+    this.cancelTime = null;
+    this.currentTime = 0;
+    this.playbackSpeed = 1;
+    this.pendingPlayState = "running";
+    this.startTime = null;
+    this.state = "idle";
+    this.stop = () => {
+      this.resolver.cancel();
+      this.isStopped = true;
+      if (this.state === "idle")
+        return;
+      this.teardown();
+      const { onStop } = this.options;
+      onStop && onStop();
+    };
+    const { name, motionValue, element, keyframes: keyframes2 } = this.options;
+    const KeyframeResolver$1 = (element === null || element === void 0 ? void 0 : element.KeyframeResolver) || KeyframeResolver;
+    const onResolved = (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe);
+    this.resolver = new KeyframeResolver$1(keyframes2, onResolved, name, motionValue, element);
+    this.resolver.scheduleResolve();
+  }
+  initPlayback(keyframes$1) {
+    const { type = "keyframes", repeat = 0, repeatDelay = 0, repeatType, velocity = 0 } = this.options;
+    const generatorFactory = isGenerator(type) ? type : generators[type] || keyframes;
+    let mapPercentToKeyframes;
+    let mirroredGenerator;
+    if (generatorFactory !== keyframes && typeof keyframes$1[0] !== "number") {
+      if (process.env.NODE_ENV !== "production") {
+        invariant(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);
+      }
+      mapPercentToKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));
+      keyframes$1 = [0, 100];
+    }
+    const generator = generatorFactory({ ...this.options, keyframes: keyframes$1 });
+    if (repeatType === "mirror") {
+      mirroredGenerator = generatorFactory({
+        ...this.options,
+        keyframes: [...keyframes$1].reverse(),
+        velocity: -velocity
+      });
+    }
+    if (generator.calculatedDuration === null) {
+      generator.calculatedDuration = calcGeneratorDuration(generator);
+    }
+    const { calculatedDuration } = generator;
+    const resolvedDuration = calculatedDuration + repeatDelay;
+    const totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;
+    return {
+      generator,
+      mirroredGenerator,
+      mapPercentToKeyframes,
+      calculatedDuration,
+      resolvedDuration,
+      totalDuration
+    };
+  }
+  onPostResolved() {
+    const { autoplay = true } = this.options;
+    this.play();
+    if (this.pendingPlayState === "paused" || !autoplay) {
+      this.pause();
+    } else {
+      this.state = this.pendingPlayState;
+    }
+  }
+  tick(timestamp, sample = false) {
+    const { resolved } = this;
+    if (!resolved) {
+      const { keyframes: keyframes3 } = this.options;
+      return { done: true, value: keyframes3[keyframes3.length - 1] };
+    }
+    const { finalKeyframe, generator, mirroredGenerator, mapPercentToKeyframes, keyframes: keyframes2, calculatedDuration, totalDuration, resolvedDuration } = resolved;
+    if (this.startTime === null)
+      return generator.next(0);
+    const { delay, repeat, repeatType, repeatDelay, onUpdate } = this.options;
+    if (this.speed > 0) {
+      this.startTime = Math.min(this.startTime, timestamp);
+    } else if (this.speed < 0) {
+      this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);
+    }
+    if (sample) {
+      this.currentTime = timestamp;
+    } else if (this.holdTime !== null) {
+      this.currentTime = this.holdTime;
+    } else {
+      this.currentTime = Math.round(timestamp - this.startTime) * this.speed;
+    }
+    const timeWithoutDelay = this.currentTime - delay * (this.speed >= 0 ? 1 : -1);
+    const isInDelayPhase = this.speed >= 0 ? timeWithoutDelay < 0 : timeWithoutDelay > totalDuration;
+    this.currentTime = Math.max(timeWithoutDelay, 0);
+    if (this.state === "finished" && this.holdTime === null) {
+      this.currentTime = totalDuration;
+    }
+    let elapsed = this.currentTime;
+    let frameGenerator = generator;
+    if (repeat) {
+      const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;
+      let currentIteration = Math.floor(progress);
+      let iterationProgress = progress % 1;
+      if (!iterationProgress && progress >= 1) {
+        iterationProgress = 1;
+      }
+      iterationProgress === 1 && currentIteration--;
+      currentIteration = Math.min(currentIteration, repeat + 1);
+      const isOddIteration = Boolean(currentIteration % 2);
+      if (isOddIteration) {
+        if (repeatType === "reverse") {
+          iterationProgress = 1 - iterationProgress;
+          if (repeatDelay) {
+            iterationProgress -= repeatDelay / resolvedDuration;
+          }
+        } else if (repeatType === "mirror") {
+          frameGenerator = mirroredGenerator;
+        }
+      }
+      elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;
+    }
+    const state = isInDelayPhase ? { done: false, value: keyframes2[0] } : frameGenerator.next(elapsed);
+    if (mapPercentToKeyframes) {
+      state.value = mapPercentToKeyframes(state.value);
+    }
+    let { done } = state;
+    if (!isInDelayPhase && calculatedDuration !== null) {
+      done = this.speed >= 0 ? this.currentTime >= totalDuration : this.currentTime <= 0;
+    }
+    const isAnimationFinished = this.holdTime === null && (this.state === "finished" || this.state === "running" && done);
+    if (isAnimationFinished && finalKeyframe !== void 0) {
+      state.value = getFinalKeyframe(keyframes2, this.options, finalKeyframe);
+    }
+    if (onUpdate) {
+      onUpdate(state.value);
+    }
+    if (isAnimationFinished) {
+      this.finish();
+    }
+    return state;
+  }
+  get duration() {
+    const { resolved } = this;
+    return resolved ? millisecondsToSeconds(resolved.calculatedDuration) : 0;
+  }
+  get time() {
+    return millisecondsToSeconds(this.currentTime);
+  }
+  set time(newTime) {
+    newTime = secondsToMilliseconds(newTime);
+    this.currentTime = newTime;
+    if (this.holdTime !== null || this.speed === 0) {
+      this.holdTime = newTime;
+    } else if (this.driver) {
+      this.startTime = this.driver.now() - newTime / this.speed;
+    }
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(newSpeed) {
+    const hasChanged = this.playbackSpeed !== newSpeed;
+    this.playbackSpeed = newSpeed;
+    if (hasChanged) {
+      this.time = millisecondsToSeconds(this.currentTime);
+    }
+  }
+  play() {
+    if (!this.resolver.isScheduled) {
+      this.resolver.resume();
+    }
+    if (!this._resolved) {
+      this.pendingPlayState = "running";
+      return;
+    }
+    if (this.isStopped)
+      return;
+    const { driver = frameloopDriver, onPlay, startTime } = this.options;
+    if (!this.driver) {
+      this.driver = driver((timestamp) => this.tick(timestamp));
+    }
+    onPlay && onPlay();
+    const now = this.driver.now();
+    if (this.holdTime !== null) {
+      this.startTime = now - this.holdTime;
+    } else if (!this.startTime) {
+      this.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();
+    } else if (this.state === "finished") {
+      this.startTime = now;
+    }
+    if (this.state === "finished") {
+      this.updateFinishedPromise();
+    }
+    this.cancelTime = this.startTime;
+    this.holdTime = null;
+    this.state = "running";
+    this.driver.start();
+  }
+  pause() {
+    var _a;
+    if (!this._resolved) {
+      this.pendingPlayState = "paused";
+      return;
+    }
+    this.state = "paused";
+    this.holdTime = (_a = this.currentTime) !== null && _a !== void 0 ? _a : 0;
+  }
+  complete() {
+    if (this.state !== "running") {
+      this.play();
+    }
+    this.pendingPlayState = this.state = "finished";
+    this.holdTime = null;
+  }
+  finish() {
+    this.teardown();
+    this.state = "finished";
+    const { onComplete } = this.options;
+    onComplete && onComplete();
+  }
+  cancel() {
+    if (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() {
+    if (!this.driver)
+      return;
+    this.driver.stop();
+    this.driver = void 0;
+  }
+  sample(time) {
+    this.startTime = 0;
+    return this.tick(time, true);
+  }
+}
+function animateValue(options) {
+  return new MainThreadAnimation(options);
+}
+export {
+  MainThreadAnimation,
+  animateValue
+};

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

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

package/dist/es/{node_modules/.pnpm/framer-motion@11.11.11/node_modules → external/.pnpm/framer-motion@11.11.11/external}/framer-motion/dist/es/animation/animators/utils/accelerated-values.mjs

@@ -1,4 +1,4 @@
-const e = /* @__PURE__ */ new Set([
+const acceleratedValues = /* @__PURE__ */ new Set([
   "opacity",
   "clipPath",
   "filter",
@@ -8,5 +8,5 @@ const e = /* @__PURE__ */ new Set([
   // "background-color"
 ]);
 export {
-  e as acceleratedValues
+  acceleratedValues
 };