@vkzstudio/muza-ui 1.0.48 → 1.2.0

package/dist/node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation.js

@@ -1,106 +0,0 @@
-import { time as A } from "../frameloop/sync-time.js";
-import { JSAnimation as y } from "./JSAnimation.js";
-import { getFinalKeyframe as g } from "./keyframes/get-final.js";
-import { KeyframeResolver as R, flushKeyframeResolvers as T } from "./keyframes/KeyframesResolver.js";
-import { NativeAnimationExtended as _ } from "./NativeAnimationExtended.js";
-import { canAnimate as w } from "./utils/can-animate.js";
-import { makeAnimationInstant as K } from "./utils/make-animation-instant.js";
-import { WithPromise as D } from "./utils/WithPromise.js";
-import { supportsBrowserAnimation as E } from "./waapi/supports/waapi.js";
-import { MotionGlobalConfig as k } from "../../../../motion-utils/dist/es/global-config.js";
-import { noop as x } from "../../../../motion-utils/dist/es/noop.js";
-const M = 40;
-class I extends D {
-  constructor({ autoplay: i = !0, delay: a = 0, type: n = "keyframes", repeat: f = 0, repeatDelay: d = 0, repeatType: c = "loop", keyframes: p, name: r, motionValue: m, element: t, ...v }) {
-    var h;
-    super(), this.stop = () => {
-      var e, s;
-      this._animation && (this._animation.stop(), (e = this.stopTimeline) == null || e.call(this)), (s = this.keyframeResolver) == null || s.cancel();
-    }, this.createdAt = A.now();
-    const o = {
-      autoplay: i,
-      delay: a,
-      type: n,
-      repeat: f,
-      repeatDelay: d,
-      repeatType: c,
-      name: r,
-      motionValue: m,
-      element: t,
-      ...v
-    }, u = (t == null ? void 0 : t.KeyframeResolver) || R;
-    this.keyframeResolver = new u(p, (e, s, l) => this.onKeyframesResolved(e, s, o, !l), r, m, t), (h = this.keyframeResolver) == null || h.scheduleResolve();
-  }
-  onKeyframesResolved(i, a, n, f) {
-    var s, l;
-    this.keyframeResolver = void 0;
-    const { name: d, type: c, velocity: p, delay: r, isHandoff: m, onUpdate: t } = n;
-    this.resolvedAt = A.now(), w(i, d, c, p) || ((k.instantAnimations || !r) && (t == null || t(g(i, n, a))), i[0] = i[i.length - 1], K(n), n.repeat = 0);
-    const o = {
-      startTime: f ? this.resolvedAt ? this.resolvedAt - this.createdAt > M ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
-      finalKeyframe: a,
-      ...n,
-      keyframes: i
-    }, u = !m && E(o), h = (l = (s = o.motionValue) == null ? void 0 : s.owner) == null ? void 0 : l.current, e = u ? new _({
-      ...o,
-      element: h
-    }) : new y(o);
-    e.finished.then(() => {
-      this.notifyFinished();
-    }).catch(x), this.pendingTimeline && (this.stopTimeline = e.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = e;
-  }
-  get finished() {
-    return this._animation ? this.animation.finished : this._finished;
-  }
-  then(i, a) {
-    return this.finished.finally(i).then(() => {
-    });
-  }
-  get animation() {
-    var i;
-    return this._animation || ((i = this.keyframeResolver) == null || i.resume(), T()), this._animation;
-  }
-  get duration() {
-    return this.animation.duration;
-  }
-  get iterationDuration() {
-    return this.animation.iterationDuration;
-  }
-  get time() {
-    return this.animation.time;
-  }
-  set time(i) {
-    this.animation.time = i;
-  }
-  get speed() {
-    return this.animation.speed;
-  }
-  get state() {
-    return this.animation.state;
-  }
-  set speed(i) {
-    this.animation.speed = i;
-  }
-  get startTime() {
-    return this.animation.startTime;
-  }
-  attachTimeline(i) {
-    return this._animation ? this.stopTimeline = this.animation.attachTimeline(i) : this.pendingTimeline = i, () => this.stop();
-  }
-  play() {
-    this.animation.play();
-  }
-  pause() {
-    this.animation.pause();
-  }
-  complete() {
-    this.animation.complete();
-  }
-  cancel() {
-    var i;
-    this._animation && this.animation.cancel(), (i = this.keyframeResolver) == null || i.cancel();
-  }
-}
-export {
-  I as AsyncMotionValueAnimation
-};

package/dist/node_modules/motion-dom/dist/es/animation/GroupAnimation.js

@@ -1,76 +0,0 @@
-class l {
-  constructor(t) {
-    this.stop = () => this.runAll("stop"), this.animations = t.filter(Boolean);
-  }
-  get finished() {
-    return Promise.all(this.animations.map((t) => t.finished));
-  }
-  /**
-   * TODO: Filter out cancelled or stopped animations before returning
-   */
-  getAll(t) {
-    return this.animations[0][t];
-  }
-  setAll(t, e) {
-    for (let i = 0; i < this.animations.length; i++)
-      this.animations[i][t] = e;
-  }
-  attachTimeline(t) {
-    const e = this.animations.map((i) => i.attachTimeline(t));
-    return () => {
-      e.forEach((i, s) => {
-        i && i(), this.animations[s].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 state() {
-    return this.getAll("state");
-  }
-  get startTime() {
-    return this.getAll("startTime");
-  }
-  get duration() {
-    return a(this.animations, "duration");
-  }
-  get iterationDuration() {
-    return a(this.animations, "iterationDuration");
-  }
-  runAll(t) {
-    this.animations.forEach((e) => e[t]());
-  }
-  play() {
-    this.runAll("play");
-  }
-  pause() {
-    this.runAll("pause");
-  }
-  cancel() {
-    this.runAll("cancel");
-  }
-  complete() {
-    this.runAll("complete");
-  }
-}
-function a(n, t) {
-  let e = 0;
-  for (let i = 0; i < n.length; i++) {
-    const s = n[i][t];
-    s !== null && s > e && (e = s);
-  }
-  return e;
-}
-export {
-  l as GroupAnimation
-};

package/dist/node_modules/motion-dom/dist/es/animation/GroupAnimationWithThen.js

@@ -1,10 +0,0 @@
-import { GroupAnimation as t } from "./GroupAnimation.js";
-class r extends t {
-  then(n, i) {
-    return this.finished.finally(n).then(() => {
-    });
-  }
-}
-export {
-  r as GroupAnimationWithThen
-};

package/dist/node_modules/motion-dom/dist/es/animation/JSAnimation.js

@@ -1,133 +0,0 @@
-import { time as u } from "../frameloop/sync-time.js";
-import { mix as G } from "../utils/mix/index.js";
-import { frameloopDriver as I } from "./drivers/frame.js";
-import { inertia as K } from "./generators/inertia.js";
-import { keyframes as c } from "./generators/keyframes.js";
-import { calcGeneratorDuration as O } from "./generators/utils/calc-duration.js";
-import { getFinalKeyframe as C } from "./keyframes/get-final.js";
-import { replaceTransitionType as E } from "./utils/replace-transition-type.js";
-import { WithPromise as N } from "./utils/WithPromise.js";
-import { invariant as V } from "../../../../motion-utils/dist/es/errors.js";
-import { pipe as W } from "../../../../motion-utils/dist/es/pipe.js";
-import { millisecondsToSeconds as f, secondsToMilliseconds as $ } from "../../../../motion-utils/dist/es/time-conversion.js";
-import { clamp as B } from "../../../../motion-utils/dist/es/clamp.js";
-const J = (v) => v / 100;
-class et extends N {
-  constructor(t) {
-    super(), this.state = "idle", this.startTime = null, this.isStopped = !1, this.currentTime = 0, this.holdTime = null, this.playbackSpeed = 1, this.stop = () => {
-      var r, e;
-      const { motionValue: i } = this.options;
-      i && i.updatedAt !== u.now() && this.tick(u.now()), this.isStopped = !0, this.state !== "idle" && (this.teardown(), (e = (r = this.options).onStop) == null || e.call(r));
-    }, this.options = t, this.initAnimation(), this.play(), t.autoplay === !1 && this.pause();
-  }
-  initAnimation() {
-    const { options: t } = this;
-    E(t);
-    const { type: i = c, repeat: r = 0, repeatDelay: e = 0, repeatType: n, velocity: m = 0 } = t;
-    let { keyframes: s } = t;
-    const h = i || c;
-    process.env.NODE_ENV !== "production" && h !== c && V(s.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${s}`, "spring-two-frames"), h !== c && typeof s[0] != "number" && (this.mixKeyframes = W(J, G(s[0], s[1])), s = [0, 100]);
-    const a = h({ ...t, keyframes: s });
-    n === "mirror" && (this.mirroredGenerator = h({
-      ...t,
-      keyframes: [...s].reverse(),
-      velocity: -m
-    })), a.calculatedDuration === null && (a.calculatedDuration = O(a));
-    const { calculatedDuration: p } = a;
-    this.calculatedDuration = p, this.resolvedDuration = p + e, this.totalDuration = this.resolvedDuration * (r + 1) - e, this.generator = a;
-  }
-  updateTime(t) {
-    const i = Math.round(t - this.startTime) * this.playbackSpeed;
-    this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = i;
-  }
-  tick(t, i = !1) {
-    const { generator: r, totalDuration: e, mixKeyframes: n, mirroredGenerator: m, resolvedDuration: s, calculatedDuration: h } = this;
-    if (this.startTime === null)
-      return r.next(0);
-    const { delay: a = 0, keyframes: p, repeat: k, repeatType: D, repeatDelay: g, type: F, onUpdate: S, finalKeyframe: P } = this.options;
-    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - e / this.speed, this.startTime)), i ? this.currentTime = t : this.updateTime(t);
-    const T = this.currentTime - a * (this.playbackSpeed >= 0 ? 1 : -1), b = this.playbackSpeed >= 0 ? T < 0 : T > e;
-    this.currentTime = Math.max(T, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = e);
-    let w = this.currentTime, x = r;
-    if (k) {
-      const y = Math.min(this.currentTime, e) / s;
-      let d = Math.floor(y), o = y % 1;
-      !o && y >= 1 && (o = 1), o === 1 && d--, d = Math.min(d, k + 1), !!(d % 2) && (D === "reverse" ? (o = 1 - o, g && (o -= g / s)) : D === "mirror" && (x = m)), w = B(0, 1, o) * s;
-    }
-    const l = b ? { done: !1, value: p[0] } : x.next(w);
-    n && (l.value = n(l.value));
-    let { done: M } = l;
-    !b && h !== null && (M = this.playbackSpeed >= 0 ? this.currentTime >= e : this.currentTime <= 0);
-    const A = this.holdTime === null && (this.state === "finished" || this.state === "running" && M);
-    return A && F !== K && (l.value = C(p, this.options, P, this.speed)), S && S(l.value), A && this.finish(), l;
-  }
-  /**
-   * 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(t, i) {
-    return this.finished.then(t, i);
-  }
-  get duration() {
-    return f(this.calculatedDuration);
-  }
-  get iterationDuration() {
-    const { delay: t = 0 } = this.options || {};
-    return this.duration + f(t);
-  }
-  get time() {
-    return f(this.currentTime);
-  }
-  set time(t) {
-    var i;
-    t = $(t), this.currentTime = t, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.playbackSpeed), (i = this.driver) == null || i.start(!1);
-  }
-  get speed() {
-    return this.playbackSpeed;
-  }
-  set speed(t) {
-    this.updateTime(u.now());
-    const i = this.playbackSpeed !== t;
-    this.playbackSpeed = t, i && (this.time = f(this.currentTime));
-  }
-  play() {
-    var e, n;
-    if (this.isStopped)
-      return;
-    const { driver: t = I, startTime: i } = this.options;
-    this.driver || (this.driver = t((m) => this.tick(m))), (n = (e = this.options).onPlay) == null || n.call(e);
-    const r = this.driver.now();
-    this.state === "finished" ? (this.updateFinished(), this.startTime = r) : this.holdTime !== null ? this.startTime = r - this.holdTime : this.startTime || (this.startTime = i ?? r), this.state === "finished" && this.speed < 0 && (this.startTime += this.calculatedDuration), this.holdTime = null, this.state = "running", this.driver.start();
-  }
-  pause() {
-    this.state = "paused", this.updateTime(u.now()), this.holdTime = this.currentTime;
-  }
-  complete() {
-    this.state !== "running" && this.play(), this.state = "finished", this.holdTime = null;
-  }
-  finish() {
-    var t, i;
-    this.notifyFinished(), this.teardown(), this.state = "finished", (i = (t = this.options).onComplete) == null || i.call(t);
-  }
-  cancel() {
-    var t, i;
-    this.holdTime = null, this.startTime = 0, this.tick(0), this.teardown(), (i = (t = this.options).onCancel) == null || i.call(t);
-  }
-  teardown() {
-    this.state = "idle", this.stopDriver(), this.startTime = this.holdTime = null;
-  }
-  stopDriver() {
-    this.driver && (this.driver.stop(), this.driver = void 0);
-  }
-  sample(t) {
-    return this.startTime = 0, this.tick(t, !0);
-  }
-  attachTimeline(t) {
-    var i;
-    return this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear", this.initAnimation()), (i = this.driver) == null || i.stop(), t.observe(this);
-  }
-}
-export {
-  et as JSAnimation
-};

package/dist/node_modules/motion-dom/dist/es/animation/NativeAnimation.js

@@ -1,108 +0,0 @@
-import { setStyle as u } from "../render/dom/style-set.js";
-import { supportsScrollTimeline as p } from "../utils/supports/scroll-timeline.js";
-import { getFinalKeyframe as f } from "./keyframes/get-final.js";
-import { WithPromise as d } from "./utils/WithPromise.js";
-import { startWaapiAnimation as c } from "./waapi/start-waapi-animation.js";
-import { applyGeneratorOptions as T } from "./waapi/utils/apply-generator.js";
-import { invariant as y } from "../../../../motion-utils/dist/es/errors.js";
-import { millisecondsToSeconds as a, secondsToMilliseconds as S } from "../../../../motion-utils/dist/es/time-conversion.js";
-import { noop as g } from "../../../../motion-utils/dist/es/noop.js";
-class x extends d {
-  constructor(i) {
-    if (super(), this.finishedTime = null, this.isStopped = !1, this.manualStartTime = null, !i)
-      return;
-    const { element: t, name: e, keyframes: o, pseudoElement: n, allowFlatten: l = !1, finalKeyframe: h, onComplete: s } = i;
-    this.isPseudoElement = !!n, this.allowFlatten = l, this.options = i, y(typeof i.type != "string", `Mini animate() doesn't support "type" as a string.`, "mini-spring");
-    const m = T(i);
-    this.animation = c(t, e, o, m, n), m.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
-      if (this.finishedTime = this.time, !n) {
-        const r = f(o, this.options, h, this.speed);
-        this.updateMotionValue ? this.updateMotionValue(r) : u(t, e, r), this.animation.cancel();
-      }
-      s == null || s(), this.notifyFinished();
-    };
-  }
-  play() {
-    this.isStopped || (this.manualStartTime = null, this.animation.play(), this.state === "finished" && this.updateFinished());
-  }
-  pause() {
-    this.animation.pause();
-  }
-  complete() {
-    var i, t;
-    (t = (i = this.animation).finish) == null || t.call(i);
-  }
-  cancel() {
-    try {
-      this.animation.cancel();
-    } catch {
-    }
-  }
-  stop() {
-    if (this.isStopped)
-      return;
-    this.isStopped = !0;
-    const { state: i } = this;
-    i === "idle" || i === "finished" || (this.updateMotionValue ? this.updateMotionValue() : this.commitStyles(), this.isPseudoElement || this.cancel());
-  }
-  /**
-   * WAAPI doesn't natively have any interruption capabilities.
-   *
-   * In this method, we commit styles back to the DOM before cancelling
-   * the animation.
-   *
-   * This is designed to be overridden by NativeAnimationExtended, which
-   * will create a renderless JS animation and sample it twice to calculate
-   * its current value, "previous" value, and therefore allow
-   * Motion to also correctly calculate velocity for any subsequent animation
-   * while deferring the commit until the next animation frame.
-   */
-  commitStyles() {
-    var i, t;
-    this.isPseudoElement || (t = (i = this.animation).commitStyles) == null || t.call(i);
-  }
-  get duration() {
-    var t, e;
-    const i = ((e = (t = this.animation.effect) == null ? void 0 : t.getComputedTiming) == null ? void 0 : e.call(t).duration) || 0;
-    return a(Number(i));
-  }
-  get iterationDuration() {
-    const { delay: i = 0 } = this.options || {};
-    return this.duration + a(i);
-  }
-  get time() {
-    return a(Number(this.animation.currentTime) || 0);
-  }
-  set time(i) {
-    this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = S(i);
-  }
-  /**
-   * The playback speed of the animation.
-   * 1 = normal speed, 2 = double speed, 0.5 = half speed.
-   */
-  get speed() {
-    return this.animation.playbackRate;
-  }
-  set speed(i) {
-    i < 0 && (this.finishedTime = null), this.animation.playbackRate = i;
-  }
-  get state() {
-    return this.finishedTime !== null ? "finished" : this.animation.playState;
-  }
-  get startTime() {
-    return this.manualStartTime ?? Number(this.animation.startTime);
-  }
-  set startTime(i) {
-    this.manualStartTime = this.animation.startTime = i;
-  }
-  /**
-   * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
-   */
-  attachTimeline({ timeline: i, observe: t }) {
-    var e;
-    return this.allowFlatten && ((e = this.animation.effect) == null || e.updateTiming({ easing: "linear" })), this.animation.onfinish = null, i && p() ? (this.animation.timeline = i, g) : t(this);
-  }
-}
-export {
-  x as NativeAnimation
-};

package/dist/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.js

@@ -1,37 +0,0 @@
-import { time as r } from "../frameloop/sync-time.js";
-import { JSAnimation as s } from "./JSAnimation.js";
-import { NativeAnimation as p } from "./NativeAnimation.js";
-import { replaceTransitionType as l } from "./utils/replace-transition-type.js";
-import { replaceStringEasing as c } from "./waapi/utils/unsupported-easing.js";
-import { clamp as f } from "../../../../motion-utils/dist/es/clamp.js";
-const m = 10;
-class g extends p {
-  constructor(t) {
-    c(t), l(t), super(t), t.startTime !== void 0 && (this.startTime = t.startTime), this.options = t;
-  }
-  /**
-   * WAAPI doesn't natively have any interruption capabilities.
-   *
-   * Rather than read committed styles back out of the DOM, we can
-   * create a renderless JS animation and sample it twice to calculate
-   * its current value, "previous" value, and therefore allow
-   * Motion to calculate velocity for any subsequent animation.
-   */
-  updateMotionValue(t) {
-    const { motionValue: e, onUpdate: d, onComplete: h, element: T, ...n } = this.options;
-    if (!e)
-      return;
-    if (t !== void 0) {
-      e.set(t);
-      return;
-    }
-    const i = new s({
-      ...n,
-      autoplay: !1
-    }), a = Math.max(m, r.now() - this.startTime), o = f(0, m, a - m);
-    e.setWithVelocity(i.sample(Math.max(0, a - o)).value, i.sample(a).value, o), i.stop();
-  }
-}
-export {
-  g as NativeAnimationExtended
-};

package/dist/node_modules/motion-dom/dist/es/animation/animate/single-value.js

@@ -1,10 +0,0 @@
-import { animateMotionValue as m } from "../interfaces/motion-value.js";
-import { motionValue as a } from "../../value/index.js";
-import { isMotionValue as r } from "../../value/utils/is-motion-value.js";
-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/node_modules/motion-dom/dist/es/animation/drivers/frame.js

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

package/dist/node_modules/motion-dom/dist/es/animation/generators/inertia.js

@@ -1,37 +0,0 @@
-import { spring as L } from "./spring/index.js";
-import { calcGeneratorVelocity as R } from "./utils/velocity.js";
-function $({ keyframes: g, velocity: B = 0, power: M = 0.8, timeConstant: b = 325, bounceDamping: k = 10, bounceStiffness: F = 500, modifyTarget: l, min: t, max: a, restDelta: f = 0.5, restSpeed: O }) {
-  const s = g[0], n = {
-    done: !1,
-    value: s
-  }, C = (e) => t !== void 0 && e < t || a !== void 0 && e > a, D = (e) => t === void 0 ? a : a === void 0 || Math.abs(t - e) < Math.abs(a - e) ? t : a;
-  let c = M * B;
-  const d = s + c, u = l === void 0 ? d : l(d);
-  u !== d && (c = u - s);
-  const p = (e) => -c * Math.exp(-e / b), h = (e) => u + p(e), y = (e) => {
-    const o = p(e), G = h(e);
-    n.done = Math.abs(o) <= f, n.value = n.done ? u : G;
-  };
-  let r, i;
-  const v = (e) => {
-    C(n.value) && (r = e, i = L({
-      keyframes: [n.value, D(n.value)],
-      velocity: R(h, e, n.value),
-      // TODO: This should be passing * 1000
-      damping: k,
-      stiffness: F,
-      restDelta: f,
-      restSpeed: O
-    }));
-  };
-  return v(0), {
-    calculatedDuration: null,
-    next: (e) => {
-      let o = !1;
-      return !i && r === void 0 && (o = !0, y(e), v(e)), r !== void 0 && e >= r ? i.next(e - r) : (!o && y(e), n);
-    }
-  };
-}
-export {
-  $ as inertia
-};

package/dist/node_modules/motion-dom/dist/es/animation/generators/keyframes.js

@@ -1,30 +0,0 @@
-import { interpolate as c } from "../../utils/interpolate.js";
-import { defaultOffset as p } from "../keyframes/offsets/default.js";
-import { convertOffsetToTimes as u } from "../keyframes/offsets/time.js";
-import { isEasingArray as l } from "../../../../../motion-utils/dist/es/easing/utils/is-easing-array.js";
-import { easingDefinitionToFunction as m } from "../../../../../motion-utils/dist/es/easing/utils/map.js";
-import { easeInOut as g } from "../../../../../motion-utils/dist/es/easing/ease.js";
-function T(n, t) {
-  return n.map(() => t || g).splice(0, n.length - 1);
-}
-function y({ duration: n = 300, keyframes: t, times: o, ease: r = "easeInOut" }) {
-  const e = l(r) ? r.map(m) : m(r), i = {
-    done: !1,
-    value: t[0]
-  }, s = u(
-    // Only use the provided offsets if they're the correct length
-    // TODO Maybe we should warn here if there's a length mismatch
-    o && o.length === t.length ? o : p(t),
-    n
-  ), a = c(s, t, {
-    ease: Array.isArray(e) ? e : T(t, e)
-  });
-  return {
-    calculatedDuration: n,
-    next: (f) => (i.value = a(f), i.done = f >= n, i)
-  };
-}
-export {
-  T as defaultEasing,
-  y as keyframes
-};

package/dist/node_modules/motion-dom/dist/es/animation/generators/spring/defaults.js

@@ -1,32 +0,0 @@
-const a = {
-  // Default spring physics
-  stiffness: 100,
-  damping: 10,
-  mass: 1,
-  velocity: 0,
-  // Default duration/bounce-based options
-  duration: 800,
-  // in ms
-  bounce: 0.3,
-  visualDuration: 0.3,
-  // in seconds
-  // Rest thresholds
-  restSpeed: {
-    granular: 0.01,
-    default: 2
-  },
-  restDelta: {
-    granular: 5e-3,
-    default: 0.5
-  },
-  // Limits
-  minDuration: 0.01,
-  // in seconds
-  maxDuration: 10,
-  // in seconds
-  minDamping: 0.05,
-  maxDamping: 1
-};
-export {
-  a as springDefaults
-};

package/dist/node_modules/motion-dom/dist/es/animation/generators/spring/find.js

@@ -1,52 +0,0 @@
-import { springDefaults as s } from "./defaults.js";
-import { warning as S } from "../../../../../../motion-utils/dist/es/errors.js";
-import { secondsToMilliseconds as h, millisecondsToSeconds as N } from "../../../../../../motion-utils/dist/es/time-conversion.js";
-import { clamp as D } from "../../../../../../motion-utils/dist/es/clamp.js";
-const x = 1e-3;
-function v({ duration: t = s.duration, bounce: p = s.bounce, velocity: i = s.velocity, mass: e = s.mass }) {
-  let a, f;
-  S(t <= h(s.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
-  let o = 1 - p;
-  o = D(s.minDamping, s.maxDamping, o), t = D(s.minDuration, s.maxDuration, N(t)), o < 1 ? (a = (n) => {
-    const r = n * o, c = r * t, l = r - i, m = b(n, o), g = Math.exp(-c);
-    return x - l / m * g;
-  }, f = (n) => {
-    const c = n * o * t, l = c * i + i, m = Math.pow(o, 2) * Math.pow(n, 2) * t, g = Math.exp(-c), u = b(Math.pow(n, 2), o);
-    return (-a(n) + x > 0 ? -1 : 1) * ((l - m) * g) / u;
-  }) : (a = (n) => {
-    const r = Math.exp(-n * t), c = (n - i) * t + 1;
-    return -x + r * c;
-  }, f = (n) => {
-    const r = Math.exp(-n * t), c = (i - n) * (t * t);
-    return r * c;
-  });
-  const w = 5 / t, M = A(a, f, w);
-  if (t = h(t), isNaN(M))
-    return {
-      stiffness: s.stiffness,
-      damping: s.damping,
-      duration: t
-    };
-  {
-    const n = Math.pow(M, 2) * e;
-    return {
-      stiffness: n,
-      damping: o * 2 * Math.sqrt(e * n),
-      duration: t
-    };
-  }
-}
-const T = 12;
-function A(t, p, i) {
-  let e = i;
-  for (let a = 1; a < T; a++)
-    e = e - t(e) / p(e);
-  return e;
-}
-function b(t, p) {
-  return t * Math.sqrt(1 - p * p);
-}
-export {
-  b as calcAngularFreq,
-  v as findSpring
-};