@pibit.ai/cure-design-system 0.3.5 → 0.3.6

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

@@ -0,0 +1,106 @@
+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/JSAnimation.js

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

@@ -0,0 +1,109 @@
+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 o, 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: n, pseudoElement: s, allowFlatten: l = !1, finalKeyframe: h, onComplete: a } = i;
+    this.isPseudoElement = !!s, 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, n, m, s), m.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
+      if (this.finishedTime = this.time, !s) {
+        const r = f(n, this.options, h, this.speed);
+        this.updateMotionValue ? this.updateMotionValue(r) : u(t, e, r), this.animation.cancel();
+      }
+      a == null || a(), 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 t, e, n;
+    const i = (t = this.options) == null ? void 0 : t.element;
+    !this.isPseudoElement && (i != null && i.isConnected) && ((n = (e = this.animation).commitStyles) == null || n.call(e));
+  }
+  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 o(Number(i));
+  }
+  get iterationDuration() {
+    const { delay: i = 0 } = this.options || {};
+    return this.duration + o(i);
+  }
+  get time() {
+    return o(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

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

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

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

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

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

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

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

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

@@ -0,0 +1,98 @@
+import { generateLinearEasing as w } from "../../waapi/utils/linear.js";
+import { calcGeneratorDuration as B, maxGeneratorDuration as E } from "../utils/calc-duration.js";
+import { createGeneratorEasing as K } from "../utils/create-generator-easing.js";
+import { calcGeneratorVelocity as O } from "../utils/velocity.js";
+import { springDefaults as a } from "./defaults.js";
+import { findSpring as V, calcAngularFreq as j } from "./find.js";
+import { millisecondsToSeconds as T, secondsToMilliseconds as k } from "../../../../../../motion-utils/dist/es/time-conversion.js";
+import { clamp as I } from "../../../../../../motion-utils/dist/es/clamp.js";
+const L = ["duration", "bounce"], P = ["stiffness", "damping", "mass"];
+function b(t, n) {
+  return n.some((s) => t[s] !== void 0);
+}
+function z(t) {
+  let n = {
+    velocity: a.velocity,
+    stiffness: a.stiffness,
+    damping: a.damping,
+    mass: a.mass,
+    isResolvedFromDuration: !1,
+    ...t
+  };
+  if (!b(t, P) && b(t, L))
+    if (t.visualDuration) {
+      const s = t.visualDuration, u = 2 * Math.PI / (s * 1.2), m = u * u, h = 2 * I(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(m);
+      n = {
+        ...n,
+        mass: a.mass,
+        stiffness: m,
+        damping: h
+      };
+    } else {
+      const s = V(t);
+      n = {
+        ...n,
+        ...s,
+        mass: a.mass
+      }, n.isResolvedFromDuration = !0;
+    }
+  return n;
+}
+function x(t = a.visualDuration, n = a.bounce) {
+  const s = typeof t != "object" ? {
+    visualDuration: t,
+    keyframes: [0, 1],
+    bounce: n
+  } : t;
+  let { restSpeed: u, restDelta: m } = s;
+  const h = s.keyframes[0], f = s.keyframes[s.keyframes.length - 1], d = { done: !1, value: h }, { stiffness: M, damping: G, mass: D, duration: S, velocity: R, isResolvedFromDuration: q } = z({
+    ...s,
+    velocity: -T(s.velocity || 0)
+  }), p = R || 0, o = G / (2 * Math.sqrt(M * D)), c = f - h, i = T(Math.sqrt(M / D)), F = Math.abs(c) < 5;
+  u || (u = F ? a.restSpeed.granular : a.restSpeed.default), m || (m = F ? a.restDelta.granular : a.restDelta.default);
+  let g;
+  if (o < 1) {
+    const e = j(i, o);
+    g = (r) => {
+      const l = Math.exp(-o * i * r);
+      return f - l * ((p + o * i * c) / e * Math.sin(e * r) + c * Math.cos(e * r));
+    };
+  } else if (o === 1)
+    g = (e) => f - Math.exp(-i * e) * (c + (p + i * c) * e);
+  else {
+    const e = i * Math.sqrt(o * o - 1);
+    g = (r) => {
+      const l = Math.exp(-o * i * r), y = Math.min(e * r, 300);
+      return f - l * ((p + o * i * c) * Math.sinh(y) + e * c * Math.cosh(y)) / e;
+    };
+  }
+  const v = {
+    calculatedDuration: q && S || null,
+    next: (e) => {
+      const r = g(e);
+      if (q)
+        d.done = e >= S;
+      else {
+        let l = e === 0 ? p : 0;
+        o < 1 && (l = e === 0 ? k(p) : O(g, e, r));
+        const y = Math.abs(l) <= u, A = Math.abs(f - r) <= m;
+        d.done = y && A;
+      }
+      return d.value = d.done ? f : r, d;
+    },
+    toString: () => {
+      const e = Math.min(B(v), E), r = w((l) => v.next(e * l).value, e, 30);
+      return e + "ms " + r;
+    },
+    toTransition: () => {
+    }
+  };
+  return v;
+}
+x.applyToOptions = (t) => {
+  const n = K(t, 100, x);
+  return t.ease = n.ease, t.duration = k(n.duration), t.type = "keyframes", t;
+};
+export {
+  x as spring
+};