motion-v 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/es/value/use-time.mjs

@@ -1,6 +1,5 @@
 import { useAnimationFrame } from "../utils/use-animation-frame.mjs";
-import { motionValue } from "../external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/value/index.mjs";
-import "../external/.pnpm/motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
+import { motionValue } from "../external/.pnpm/motion-dom@12.9.0/external/motion-dom/dist/es/value/index.mjs";
 function useTime() {
   const time = motionValue(0);
   useAnimationFrame((t) => time.set(t));

package/dist/es/value/use-transform.d.ts

@@ -1,5 +1,4 @@
-import { TransformOptions } from '../types';
-import { MotionValue } from 'framer-motion/dom';
+import { MotionValue, TransformOptions } from 'framer-motion/dom';
 import { MaybeRef } from 'vue';
 type InputRange = number[];
 type SingleTransformer<I, O> = (input: I) => O;

package/dist/es/value/use-transform.mjs

@@ -1,7 +1,7 @@
 import { useComputed } from "./use-computed.mjs";
 import { useCombineMotionValues } from "./use-combine-values.mjs";
 import { isRef, computed } from "vue";
-import { transform } from "../external/.pnpm/framer-motion@12.5.0/external/framer-motion/dist/es/utils/transform.mjs";
+import { transform } from "../external/.pnpm/motion-dom@12.9.0/external/motion-dom/dist/es/utils/transform.mjs";
 function useTransform(input, inputRangeOrTransformer, outputRange, options) {
   if (typeof input === "function") {
     return useComputed(input);

package/dist/es/value/use-velocity.mjs

@@ -1,7 +1,6 @@
 import { useMotionValueEvent } from "./use-motion-value-event.mjs";
-import { motionValue } from "../external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/value/index.mjs";
-import "../external/.pnpm/motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
-import { frame } from "../external/.pnpm/motion-dom@12.5.0/external/motion-dom/dist/es/frameloop/frame.mjs";
+import { motionValue } from "../external/.pnpm/motion-dom@12.9.0/external/motion-dom/dist/es/value/index.mjs";
+import { frame } from "../external/.pnpm/motion-dom@12.9.0/external/motion-dom/dist/es/frameloop/frame.mjs";
 function useVelocity(value) {
   const velocity = motionValue(value.getVelocity());
   const updateVelocity = () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "motion-v",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.3",
   "description": "",
   "author": "",
   "license": "MIT",
@@ -67,9 +67,8 @@
   },
   "dependencies": {
     "@vueuse/core": "^10.0.0",
-    "framer-motion": "12.5.0",
-    "hey-listen": "^1.0.8",
-    "motion-dom": "^12.5.0"
+    "framer-motion": "12.9.0",
+    "hey-listen": "^1.0.8"
   },
   "devDependencies": {
     "vue": "3.4.38"

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

@@ -1,247 +0,0 @@
-import "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
-import { noop } from "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/noop.mjs";
-import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/time-conversion.mjs";
-import { isGenerator } from "../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/generators/utils/is-generator.mjs";
-import { attachTimeline } from "../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/waapi/utils/attach-timeline.mjs";
-import { isWaapiSupportedEasing } from "../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/waapi/utils/easing.mjs";
-import { supportsLinearEasing } from "../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/utils/supports/linear-easing.mjs";
-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 { BaseAnimation } from "./BaseAnimation.mjs";
-import { MainThreadAnimation } from "./MainThreadAnimation.mjs";
-import { acceleratedValues } from "./utils/accelerated-values.mjs";
-import { startWaapiAnimation } from "./waapi/index.mjs";
-import { getFinalKeyframe } from "./waapi/utils/get-final-keyframe.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) {
-    let { duration = 300, times, ease, type, motionValue, name, startTime } = this.options;
-    if (!motionValue.owner || !motionValue.owner.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;
-    if (!motionValue || !motionValue.owner || !(motionValue.owner.current instanceof HTMLElement)) {
-      return false;
-    }
-    const { onUpdate, transformTemplate } = motionValue.owner.getProps();
-    return supportsWaapi() && name && acceleratedValues.has(name) && /**
-     * 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.
-     */
-    !onUpdate && !transformTemplate && !repeatDelay && repeatType !== "mirror" && damping !== 0 && type !== "inertia";
-  }
-}
-export {
-  AcceleratedAnimation
-};

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

@@ -1,102 +0,0 @@
-import "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
-import { time } from "../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/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 && onUpdate(getFinalKeyframe(keyframes, this.options, finalKeyframe));
-        onComplete && 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);
-  }
-  flatten() {
-    if (!this.options.allowFlatten)
-      return;
-    this.options.type = "keyframes";
-    this.options.ease = "linear";
-  }
-  updateFinishedPromise() {
-    this.currentFinishedPromise = new Promise((resolve) => {
-      this.resolveFinishedPromise = resolve;
-    });
-  }
-}
-export {
-  BaseAnimation
-};

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

@@ -1,281 +0,0 @@
-import { invariant } from "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/errors.mjs";
-import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../../../../motion-utils@12.5.0/external/motion-utils/dist/es/time-conversion.mjs";
-import { calcGeneratorDuration } from "../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs";
-import { isGenerator } from "../../../../../../../motion-dom@12.5.0/external/motion-dom/dist/es/animation/generators/utils/is-generator.mjs";
-import { KeyframeResolver } from "../../render/utils/KeyframesResolver.mjs";
-import { clamp } from "../../utils/clamp.mjs";
-import { mix } from "../../utils/mix/index.mjs";
-import { pipe } from "../../utils/pipe.mjs";
-import { inertia } from "../generators/inertia.mjs";
-import { keyframes } from "../generators/keyframes.mjs";
-import { spring } from "../generators/spring/index.mjs";
-import { BaseAnimation } from "./BaseAnimation.mjs";
-import { frameloopDriver } from "./drivers/driver-frameloop.mjs";
-import { getFinalKeyframe } from "./waapi/utils/get-final-keyframe.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();
-  }
-  flatten() {
-    super.flatten();
-    if (this._resolved) {
-      Object.assign(this._resolved, this.initPlayback(this._resolved.keyframes));
-    }
-  }
-  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 (process.env.NODE_ENV !== "production" && generatorFactory !== keyframes) {
-      invariant(keyframes$1.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);
-    }
-    if (generatorFactory !== keyframes && typeof keyframes$1[0] !== "number") {
-      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
-};