laif-ds 0.1.9 → 0.1.11

package/dist/node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.js

@@ -1,206 +0,0 @@
-"use client";
-import "../../../../../motion-utils/dist/es/errors.js";
-import { noop as y } from "../../../../../motion-utils/dist/es/noop.js";
-import { millisecondsToSeconds as g, secondsToMilliseconds as T } from "../../../../../motion-utils/dist/es/time-conversion.js";
-import { isGenerator as V } from "../../../../../motion-dom/dist/es/animation/generators/utils/is-generator.js";
-import { attachTimeline as w } from "../../../../../motion-dom/dist/es/animation/waapi/utils/attach-timeline.js";
-import { isWaapiSupportedEasing as F } from "../../../../../motion-dom/dist/es/animation/waapi/utils/easing.js";
-import { supportsLinearEasing as K } from "../../../../../motion-dom/dist/es/utils/supports/linear-easing.js";
-import { anticipate as E } from "../../easing/anticipate.js";
-import { backInOut as R } from "../../easing/back.js";
-import { circInOut as b } from "../../easing/circ.js";
-import { DOMKeyframesResolver as D } from "../../render/dom/DOMKeyframesResolver.js";
-import { BaseAnimation as M } from "./BaseAnimation.js";
-import { MainThreadAnimation as S } from "./MainThreadAnimation.js";
-import { acceleratedValues as U } from "./utils/accelerated-values.js";
-import { startWaapiAnimation as W } from "./waapi/index.js";
-import { getFinalKeyframe as x } from "./waapi/utils/get-final-keyframe.js";
-import { supportsWaapi as C } from "./waapi/utils/supports-waapi.js";
-const f = 10, G = 2e4;
-function O(r) {
-  return V(r.type) || r.type === "spring" || !F(r.ease);
-}
-function k(r, e) {
-  const t = new S({
-    ...e,
-    keyframes: r,
-    repeat: 0,
-    delay: 0,
-    isGenerator: !0
-  });
-  let i = { done: !1, value: r[0] };
-  const s = [];
-  let n = 0;
-  for (; !i.done && n < G; )
-    i = t.sample(n), s.push(i.value), n += f;
-  return {
-    times: void 0,
-    keyframes: s,
-    duration: n - f,
-    ease: "linear"
-  };
-}
-const A = {
-  anticipate: E,
-  backInOut: R,
-  circInOut: b
-};
-function I(r) {
-  return r in A;
-}
-class ne extends M {
-  constructor(e) {
-    super(e);
-    const { name: t, motionValue: i, element: s, keyframes: n } = this.options;
-    this.resolver = new D(n, (a, o) => this.onKeyframesResolved(a, o), t, i, s), this.resolver.scheduleResolve();
-  }
-  initPlayback(e, t) {
-    let { duration: i = 300, times: s, ease: n, type: a, motionValue: o, name: p, startTime: m } = this.options;
-    if (!o.owner || !o.owner.current)
-      return !1;
-    if (typeof n == "string" && K() && I(n) && (n = A[n]), O(this.options)) {
-      const { onComplete: c, onUpdate: P, motionValue: v, element: h, ...u } = this.options, d = k(e, u);
-      e = d.keyframes, e.length === 1 && (e[1] = e[0]), i = d.duration, s = d.times, n = d.ease, a = "keyframes";
-    }
-    const l = W(o.owner.current, p, e, { ...this.options, duration: i, times: s, ease: n });
-    return l.startTime = m ?? this.calcStartTime(), this.pendingTimeline ? (w(l, this.pendingTimeline), this.pendingTimeline = void 0) : l.onfinish = () => {
-      const { onComplete: c } = this.options;
-      o.set(x(e, this.options, t)), c && c(), this.cancel(), this.resolveFinishedPromise();
-    }, {
-      animation: l,
-      duration: i,
-      times: s,
-      type: a,
-      ease: n,
-      keyframes: e
-    };
-  }
-  get duration() {
-    const { resolved: e } = this;
-    if (!e)
-      return 0;
-    const { duration: t } = e;
-    return g(t);
-  }
-  get time() {
-    const { resolved: e } = this;
-    if (!e)
-      return 0;
-    const { animation: t } = e;
-    return g(t.currentTime || 0);
-  }
-  set time(e) {
-    const { resolved: t } = this;
-    if (!t)
-      return;
-    const { animation: i } = t;
-    i.currentTime = T(e);
-  }
-  get speed() {
-    const { resolved: e } = this;
-    if (!e)
-      return 1;
-    const { animation: t } = e;
-    return t.playbackRate;
-  }
-  set speed(e) {
-    const { resolved: t } = this;
-    if (!t)
-      return;
-    const { animation: i } = t;
-    i.playbackRate = e;
-  }
-  get state() {
-    const { resolved: e } = this;
-    if (!e)
-      return "idle";
-    const { animation: t } = e;
-    return t.playState;
-  }
-  get startTime() {
-    const { resolved: e } = this;
-    if (!e)
-      return null;
-    const { animation: t } = e;
-    return t.startTime;
-  }
-  /**
-   * Replace the default DocumentTimeline with another AnimationTimeline.
-   * Currently used for scroll animations.
-   */
-  attachTimeline(e) {
-    if (!this._resolved)
-      this.pendingTimeline = e;
-    else {
-      const { resolved: t } = this;
-      if (!t)
-        return y;
-      const { animation: i } = t;
-      w(i, e);
-    }
-    return y;
-  }
-  play() {
-    if (this.isStopped)
-      return;
-    const { resolved: e } = this;
-    if (!e)
-      return;
-    const { animation: t } = e;
-    t.playState === "finished" && this.updateFinishedPromise(), t.play();
-  }
-  pause() {
-    const { resolved: e } = this;
-    if (!e)
-      return;
-    const { animation: t } = e;
-    t.pause();
-  }
-  stop() {
-    if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
-      return;
-    this.resolveFinishedPromise(), this.updateFinishedPromise();
-    const { resolved: e } = this;
-    if (!e)
-      return;
-    const { animation: t, keyframes: i, duration: s, type: n, ease: a, times: o } = e;
-    if (t.playState === "idle" || t.playState === "finished")
-      return;
-    if (this.time) {
-      const { motionValue: m, onUpdate: l, onComplete: c, element: P, ...v } = this.options, h = new S({
-        ...v,
-        keyframes: i,
-        duration: s,
-        type: n,
-        ease: a,
-        times: o,
-        isGenerator: !0
-      }), u = T(this.time);
-      m.setWithVelocity(h.sample(u - f).value, h.sample(u).value, f);
-    }
-    const { onStop: p } = this.options;
-    p && p(), this.cancel();
-  }
-  complete() {
-    const { resolved: e } = this;
-    e && e.animation.finish();
-  }
-  cancel() {
-    const { resolved: e } = this;
-    e && e.animation.cancel();
-  }
-  static supports(e) {
-    const { motionValue: t, name: i, repeatDelay: s, repeatType: n, damping: a, type: o } = e;
-    if (!t || !t.owner || !(t.owner.current instanceof HTMLElement))
-      return !1;
-    const { onUpdate: p, transformTemplate: m } = t.owner.getProps();
-    return C() && i && U.has(i) && /**
-     * 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.
-     */
-    !p && !m && !s && n !== "mirror" && a !== 0 && o !== "inertia";
-  }
-}
-export {
-  ne as AcceleratedAnimation
-};

package/dist/node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.js

@@ -1,83 +0,0 @@
-"use client";
-import { time as d } from "../../frameloop/sync-time.js";
-import { flushKeyframeResolvers as m } from "../../render/utils/KeyframesResolver.js";
-import { canAnimate as p } from "./utils/can-animate.js";
-import { getFinalKeyframe as v } from "./waapi/utils/get-final-keyframe.js";
-const c = 40;
-class F {
-  constructor({ autoplay: e = !0, delay: t = 0, type: i = "keyframes", repeat: o = 0, repeatDelay: r = 0, repeatType: n = "loop", ...s }) {
-    this.isStopped = !1, this.hasAttemptedResolve = !1, this.createdAt = d.now(), this.options = {
-      autoplay: e,
-      delay: t,
-      type: i,
-      repeat: o,
-      repeatDelay: r,
-      repeatType: n,
-      ...s
-    }, this.updateFinishedPromise();
-  }
-  /**
-   * This method uses the createdAt and resolvedAt to calculate the
-   * animation startTime. *Ideally*, we would use the createdAt time as t=0
-   * as the following frame would then be the first frame of the animation in
-   * progress, which would feel snappier.
-   *
-   * However, if there's a delay (main thread work) between the creation of
-   * the animation and the first commited frame, we prefer to use resolvedAt
-   * to avoid a sudden jump into the animation.
-   */
-  calcStartTime() {
-    return this.resolvedAt ? this.resolvedAt - this.createdAt > c ? this.resolvedAt : this.createdAt : this.createdAt;
-  }
-  /**
-   * A getter for resolved data. If keyframes are not yet resolved, accessing
-   * this.resolved will synchronously flush all pending keyframe resolvers.
-   * This is a deoptimisation, but at its worst still batches read/writes.
-   */
-  get resolved() {
-    return !this._resolved && !this.hasAttemptedResolve && m(), this._resolved;
-  }
-  /**
-   * A method to be called when the keyframes resolver completes. This method
-   * will check if its possible to run the animation and, if not, skip it.
-   * Otherwise, it will call initPlayback on the implementing class.
-   */
-  onKeyframesResolved(e, t) {
-    this.resolvedAt = d.now(), this.hasAttemptedResolve = !0;
-    const { name: i, type: o, velocity: r, delay: n, onComplete: s, onUpdate: h, isGenerator: a } = this.options;
-    if (!a && !p(e, i, o, r))
-      if (n)
-        this.options.duration = 0;
-      else {
-        h && h(v(e, this.options, t)), s && s(), this.resolveFinishedPromise();
-        return;
-      }
-    const l = this.initPlayback(e, t);
-    l !== !1 && (this._resolved = {
-      keyframes: e,
-      finalKeyframe: t,
-      ...l
-    }, this.onPostResolved());
-  }
-  onPostResolved() {
-  }
-  /**
-   * Allows the returned animation to be awaited or promise-chained. Currently
-   * resolves when the animation finishes at all but in a future update could/should
-   * reject if its cancels.
-   */
-  then(e, t) {
-    return this.currentFinishedPromise.then(e, t);
-  }
-  flatten() {
-    this.options.type = "keyframes", this.options.ease = "linear";
-  }
-  updateFinishedPromise() {
-    this.currentFinishedPromise = new Promise((e) => {
-      this.resolveFinishedPromise = e;
-    });
-  }
-}
-export {
-  F as BaseAnimation
-};

package/dist/node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.js

@@ -1,148 +0,0 @@
-"use client";
-import { invariant as w } from "../../../../../motion-utils/dist/es/errors.js";
-import { millisecondsToSeconds as g, secondsToMilliseconds as x } from "../../../../../motion-utils/dist/es/time-conversion.js";
-import { calcGeneratorDuration as G } from "../../../../../motion-dom/dist/es/animation/generators/utils/calc-duration.js";
-import { isGenerator as O } from "../../../../../motion-dom/dist/es/animation/generators/utils/is-generator.js";
-import { KeyframeResolver as I } from "../../render/utils/KeyframesResolver.js";
-import { clamp as A } from "../../utils/clamp.js";
-import { mix as B } from "../../utils/mix/index.js";
-import { pipe as C } from "../../utils/pipe.js";
-import { inertia as _ } from "../generators/inertia.js";
-import { keyframes as v } from "../generators/keyframes.js";
-import { spring as E } from "../generators/spring/index.js";
-import { BaseAnimation as N } from "./BaseAnimation.js";
-import { frameloopDriver as V } from "./drivers/driver-frameloop.js";
-import { getFinalKeyframe as j } from "./waapi/utils/get-final-keyframe.js";
-const U = {
-  decay: _,
-  inertia: _,
-  tween: v,
-  keyframes: v,
-  spring: E
-}, W = (P) => P / 100;
-class nt extends N {
-  constructor(t) {
-    super(t), this.holdTime = null, this.cancelTime = null, this.currentTime = 0, this.playbackSpeed = 1, this.pendingPlayState = "running", this.startTime = null, this.state = "idle", this.stop = () => {
-      if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
-        return;
-      this.teardown();
-      const { onStop: n } = this.options;
-      n && n();
-    };
-    const { name: i, motionValue: r, element: e, keyframes: o } = this.options, u = (e == null ? void 0 : e.KeyframeResolver) || I, a = (n, l) => this.onKeyframesResolved(n, l);
-    this.resolver = new u(o, a, i, r, e), this.resolver.scheduleResolve();
-  }
-  flatten() {
-    super.flatten(), this._resolved && Object.assign(this._resolved, this.initPlayback(this._resolved.keyframes));
-  }
-  initPlayback(t) {
-    const { type: i = "keyframes", repeat: r = 0, repeatDelay: e = 0, repeatType: o, velocity: u = 0 } = this.options, a = O(i) ? i : U[i] || v;
-    let n, l;
-    a !== v && typeof t[0] != "number" && (process.env.NODE_ENV !== "production" && w(t.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${t}`), n = C(W, B(t[0], t[1])), t = [0, 100]);
-    const s = a({ ...this.options, keyframes: t });
-    o === "mirror" && (l = a({
-      ...this.options,
-      keyframes: [...t].reverse(),
-      velocity: -u
-    })), s.calculatedDuration === null && (s.calculatedDuration = G(s));
-    const { calculatedDuration: d } = s, p = d + e, f = p * (r + 1) - e;
-    return {
-      generator: s,
-      mirroredGenerator: l,
-      mapPercentToKeyframes: n,
-      calculatedDuration: d,
-      resolvedDuration: p,
-      totalDuration: f
-    };
-  }
-  onPostResolved() {
-    const { autoplay: t = !0 } = this.options;
-    this.play(), this.pendingPlayState === "paused" || !t ? this.pause() : this.state = this.pendingPlayState;
-  }
-  tick(t, i = !1) {
-    const { resolved: r } = this;
-    if (!r) {
-      const { keyframes: c } = this.options;
-      return { done: !0, value: c[c.length - 1] };
-    }
-    const { finalKeyframe: e, generator: o, mirroredGenerator: u, mapPercentToKeyframes: a, keyframes: n, calculatedDuration: l, totalDuration: s, resolvedDuration: d } = r;
-    if (this.startTime === null)
-      return o.next(0);
-    const { delay: p, repeat: f, repeatType: D, repeatDelay: S, onUpdate: k } = this.options;
-    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - s / this.speed, this.startTime)), i ? this.currentTime = t : this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = Math.round(t - this.startTime) * this.speed;
-    const y = this.currentTime - p * (this.speed >= 0 ? 1 : -1), M = this.speed >= 0 ? y < 0 : y > s;
-    this.currentTime = Math.max(y, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = s);
-    let b = this.currentTime, K = o;
-    if (f) {
-      const c = Math.min(this.currentTime, s) / d;
-      let T = Math.floor(c), h = c % 1;
-      !h && c >= 1 && (h = 1), h === 1 && T--, T = Math.min(T, f + 1), !!(T % 2) && (D === "reverse" ? (h = 1 - h, S && (h -= S / d)) : D === "mirror" && (K = u)), b = A(0, 1, h) * d;
-    }
-    const m = M ? { done: !1, value: n[0] } : K.next(b);
-    a && (m.value = a(m.value));
-    let { done: F } = m;
-    !M && l !== null && (F = this.speed >= 0 ? this.currentTime >= s : this.currentTime <= 0);
-    const R = this.holdTime === null && (this.state === "finished" || this.state === "running" && F);
-    return R && e !== void 0 && (m.value = j(n, this.options, e)), k && k(m.value), R && this.finish(), m;
-  }
-  get duration() {
-    const { resolved: t } = this;
-    return t ? g(t.calculatedDuration) : 0;
-  }
-  get time() {
-    return g(this.currentTime);
-  }
-  set time(t) {
-    t = x(t), this.currentTime = t, this.holdTime !== null || this.speed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.speed);
-  }
-  get speed() {
-    return this.playbackSpeed;
-  }
-  set speed(t) {
-    const i = this.playbackSpeed !== t;
-    this.playbackSpeed = t, i && (this.time = g(this.currentTime));
-  }
-  play() {
-    if (this.resolver.isScheduled || this.resolver.resume(), !this._resolved) {
-      this.pendingPlayState = "running";
-      return;
-    }
-    if (this.isStopped)
-      return;
-    const { driver: t = V, onPlay: i, startTime: r } = this.options;
-    this.driver || (this.driver = t((o) => this.tick(o))), i && i();
-    const e = this.driver.now();
-    this.holdTime !== null ? this.startTime = e - this.holdTime : this.startTime ? this.state === "finished" && (this.startTime = e) : this.startTime = r ?? this.calcStartTime(), this.state === "finished" && this.updateFinishedPromise(), this.cancelTime = this.startTime, this.holdTime = null, this.state = "running", this.driver.start();
-  }
-  pause() {
-    var t;
-    if (!this._resolved) {
-      this.pendingPlayState = "paused";
-      return;
-    }
-    this.state = "paused", this.holdTime = (t = this.currentTime) !== null && t !== void 0 ? t : 0;
-  }
-  complete() {
-    this.state !== "running" && this.play(), this.pendingPlayState = this.state = "finished", this.holdTime = null;
-  }
-  finish() {
-    this.teardown(), this.state = "finished";
-    const { onComplete: t } = this.options;
-    t && t();
-  }
-  cancel() {
-    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() {
-    this.driver && (this.driver.stop(), this.driver = void 0);
-  }
-  sample(t) {
-    return this.startTime = 0, this.tick(t, !0);
-  }
-}
-export {
-  nt as MainThreadAnimation
-};

package/dist/node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.js

@@ -1,18 +0,0 @@
-"use client";
-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 = (r) => {
-  const t = ({ timestamp: m }) => r(m);
-  return {
-    start: () => s.update(t, !0),
-    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/framer-motion/dist/es/animation/animators/utils/accelerated-values.js

@@ -1,13 +0,0 @@
-"use client";
-const e = /* @__PURE__ */ new Set([
-  "opacity",
-  "clipPath",
-  "filter",
-  "transform"
-  // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved
-  // or until we implement support for linear() easing.
-  // "background-color"
-]);
-export {
-  e as acceleratedValues
-};

package/dist/node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.js

@@ -1,24 +0,0 @@
-"use client";
-import { warning as s } from "../../../../../../motion-utils/dist/es/errors.js";
-import { isGenerator as f } from "../../../../../../motion-dom/dist/es/animation/generators/utils/is-generator.js";
-import { isAnimatable as l } from "../../utils/is-animatable.js";
-function g(t) {
-  const i = t[0];
-  if (t.length === 1)
-    return !0;
-  for (let n = 0; n < t.length; n++)
-    if (t[n] !== i)
-      return !0;
-}
-function h(t, i, n, u) {
-  const r = t[0];
-  if (r === null)
-    return !1;
-  if (i === "display" || i === "visibility")
-    return !0;
-  const e = t[t.length - 1], a = l(r, i), o = l(e, i);
-  return s(a === o, `You are trying to animate ${i} from "${r}" to "${e}". ${r} is not an animatable value - to enable this animation set ${r} to a value animatable to ${e} via the \`style\` property.`), !a || !o ? !1 : g(t) || (n === "spring" || f(n)) && u;
-}
-export {
-  h as canAnimate
-};

package/dist/node_modules/framer-motion/dist/es/animation/animators/waapi/index.js

@@ -1,19 +0,0 @@
-"use client";
-import "../../../../../../motion-utils/dist/es/errors.js";
-import { mapEasingToNativeEasing as p } from "../../../../../../motion-dom/dist/es/animation/waapi/utils/easing.js";
-function y(n, t, o, { delay: s = 0, duration: r = 300, repeat: f = 0, repeatType: l = "loop", ease: m = "easeInOut", times: e } = {}) {
-  const i = { [t]: o };
-  e && (i.offset = e);
-  const a = p(m, r);
-  return Array.isArray(a) && (i.easing = a), n.animate(i, {
-    delay: s,
-    duration: r,
-    easing: Array.isArray(a) ? "linear" : a,
-    fill: "both",
-    iterations: f + 1,
-    direction: l === "reverse" ? "alternate" : "normal"
-  });
-}
-export {
-  y as startWaapiAnimation
-};

package/dist/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.js

@@ -1,9 +0,0 @@
-"use client";
-const i = (e) => e !== null;
-function u(e, { repeat: n, repeatType: s = "loop" }, o) {
-  const l = e.filter(i), t = n && s !== "loop" && n % 2 === 1 ? 0 : l.length - 1;
-  return !t || o === void 0 ? l[t] : o;
-}
-export {
-  u as getFinalKeyframe
-};

package/dist/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/supports-waapi.js

@@ -1,7 +0,0 @@
-"use client";
-import "../../../../../../../motion-utils/dist/es/errors.js";
-import { memo as t } from "../../../../../../../motion-utils/dist/es/memo.js";
-const p = /* @__PURE__ */ t(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
-export {
-  p as supportsWaapi
-};

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

@@ -1,38 +0,0 @@
-"use client";
-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 o = g[0], n = {
-    done: !1,
-    value: o
-  }, 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 = o + c, u = l === void 0 ? d : l(d);
-  u !== d && (c = u - o);
-  const p = (e) => -c * Math.exp(-e / b), h = (e) => u + p(e), y = (e) => {
-    const s = p(e), G = h(e);
-    n.done = Math.abs(s) <= 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 s = !1;
-      return !i && r === void 0 && (s = !0, y(e), v(e)), r !== void 0 && e >= r ? i.next(e - r) : (!s && y(e), n);
-    }
-  };
-}
-export {
-  $ as inertia
-};

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

@@ -1,31 +0,0 @@
-"use client";
-import { easeInOut as c } from "../../easing/ease.js";
-import { isEasingArray as p } from "../../easing/utils/is-easing-array.js";
-import { easingDefinitionToFunction as f } from "../../easing/utils/map.js";
-import { interpolate as u } from "../../utils/interpolate.js";
-import { defaultOffset as l } from "../../utils/offsets/default.js";
-import { convertOffsetToTimes as g } from "../../utils/offsets/time.js";
-function T(n, t) {
-  return n.map(() => t || c).splice(0, n.length - 1);
-}
-function y({ duration: n = 300, keyframes: t, times: o, ease: e = "easeInOut" }) {
-  const r = p(e) ? e.map(f) : f(e), i = {
-    done: !1,
-    value: t[0]
-  }, m = g(
-    // 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 : l(t),
-    n
-  ), a = u(m, t, {
-    ease: Array.isArray(r) ? r : T(t, r)
-  });
-  return {
-    calculatedDuration: n,
-    next: (s) => (i.value = a(s), i.done = s >= n, i)
-  };
-}
-export {
-  T as defaultEasing,
-  y as keyframes
-};

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

@@ -1,33 +0,0 @@
-"use client";
-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
-};