animejs 4.2.0-beta.0 → 4.2.1

package/dist/modules/waapi/waapi.js

@@ -1,17 +1,17 @@
 /**
  * Anime.js - waapi - ESM
- * @version v4.2.0
+ * @version v4.2.1
  * @license MIT
  * @copyright 2025 - Julian Garnier
  */
 
-import { isNil, isUnd, stringStartsWith, isKey, isObj, isArr, isStr, toLowerCase, isFnc, isNum } from '../core/helpers.js';
+import { isNil, isUnd, stringStartsWith, isKey, isObj, isArr, toLowerCase, round, isStr, isFnc, isNum } from '../core/helpers.js';
 import { scope, globals } from '../core/globals.js';
 import { registerTargets } from '../core/targets.js';
 import { setValue, getFunctionValue } from '../core/values.js';
 import { isBrowser, validTransforms, noop, transformsSymbol, shortTransforms, transformsFragmentStrings, emptyString, K } from '../core/consts.js';
 import { none } from '../easings/none.js';
-import { parseEaseString, easeTypes, easeInPower } from '../easings/parser.js';
+import { parseEaseString } from '../easings/eases/parser.js';
 import { addWAAPIAnimation } from './composition.js';
 
 /**
@@ -25,7 +25,6 @@ import { addWAAPIAnimation } from './composition.js';
  *   WAAPIAnimationParams,
  *   WAAPITweenOptions,
  *   WAAPIKeyframeValue,
- *   WAAPICallback,
  *   WAAPITweenValue
  * } from '../types/index.js'
 */
@@ -33,7 +32,7 @@ import { addWAAPIAnimation } from './composition.js';
 /**
  * @import {
  *   Spring,
- * } from '../spring/spring.js'
+ * } from '../easings/spring/index.js'
 */
 
 /**
@@ -50,21 +49,11 @@ import { addWAAPIAnimation } from './composition.js';
  */
 const easingToLinear = (fn, samples = 100) => {
   const points = [];
-  for (let i = 0; i <= samples; i++) points.push(fn(i / samples));
+  for (let i = 0; i <= samples; i++) points.push(round(fn(i / samples), 4));
   return `linear(${points.join(', ')})`;
 };
 
-const WAAPIEasesLookups = {
-  in: 'ease-in',
-  out: 'ease-out',
-  inOut: 'ease-in-out',
-};
-
-const WAAPIeases = /*#__PURE__*/(() => {
-  const list = {};
-  for (let type in easeTypes) list[type] = (/** @type {String|Number} */p) => easeTypes[type](easeInPower(p));
-  return /** @type {Record<String, EasingFunction>} */(list);
-})();
+const WAAPIEasesLookups = {};
 
 /**
  * @param  {EasingParam} ease
@@ -85,9 +74,10 @@ const parseWAAPIEasing = (ease) => {
     } else if (stringStartsWith(ease, 'cubicB')) {
       parsedEase = toLowerCase(ease);
     } else {
-      const parsed = parseEaseString(ease, WAAPIeases, WAAPIEasesLookups);
+      const parsed = parseEaseString(ease);
       if (isFnc(parsed)) parsedEase = parsed === none ? 'linear' : easingToLinear(parsed);
     }
+    // Only cache string based easing name, otherwise function arguments get lost
     WAAPIEasesLookups[ease] = parsedEase;
   } else if (isFnc(ease)) {
     const easing = easingToLinear(ease);
@@ -128,7 +118,8 @@ let transformsPropertiesRegistered = null;
  * @return {String}
  */
 const normalizeTweenValue = (propName, value, $el, i, targetsLength) => {
-  let v = getFunctionValue(/** @type {any} */(value), $el, i, targetsLength);
+  // Do not try to compute strings with getFunctionValue otherwise it will convert CSS variables
+  let v = isStr(value) ? value : getFunctionValue(/** @type {any} */(value), $el, i, targetsLength);
   if (!isNum(v)) return v;
   if (commonDefaultPXProperties.includes(propName) || stringStartsWith(propName, 'translate')) return `${v}px`;
   if (stringStartsWith(propName, 'rotate') || stringStartsWith(propName, 'skew')) return `${v}deg`;
@@ -208,7 +199,7 @@ class WAAPIAnimation {
     /** @type {PlaybackDirection} */
     const direction = alternate ? reversed ? 'alternate-reverse' : 'alternate' : reversed ? 'reverse' : 'normal';
     /** @type {FillMode} */
-    const fill = 'forwards';
+    const fill = 'both'; // We use 'both' here because the animation can be reversed during playback
     /** @type {String} */
     const easing = parseWAAPIEasing(ease);
     const timeScale = (globals.timeScale === 1 ? 1 : K);
@@ -220,7 +211,7 @@ class WAAPIAnimation {
     /** @type {globalThis.Animation}] */
     this.controlAnimation = null;
     /** @type {Callback<this>} */
-    this.onComplete = params.onComplete || noop;
+    this.onComplete = params.onComplete || /** @type {Callback<WAAPIAnimation>} */(/** @type {unknown} */(globals.defaults.onComplete));
     /** @type {Number} */
     this.duration = 0;
     /** @type {Boolean} */
@@ -231,6 +222,8 @@ class WAAPIAnimation {
     this.paused = !autoplay || scroll !== false;
     /** @type {Boolean} */
     this.reversed = reversed;
+    /** @type {Boolean} */
+    this.persist = setValue(params.persist, globals.defaults.persist);
     /** @type {Boolean|ScrollObserver} */
     this.autoplay = autoplay;
     /** @type {Number} */
@@ -239,17 +232,18 @@ class WAAPIAnimation {
     this._resolve = noop; // Used by .then()
     /** @type {Number} */
     this._completed = 0;
-    /** @type {Array<Object>}] */
-    this._inlineStyles = parsedTargets.map($el => $el.getAttribute('style'));
+    /** @type {Array.<Object>} */
+    this._inlineStyles = [];
 
     parsedTargets.forEach(($el, i) => {
 
       const cachedTransforms = $el[transformsSymbol];
-
       const hasIndividualTransforms = validIndividualTransforms.some(t => params.hasOwnProperty(t));
+      const elStyle = $el.style;
+      const inlineStyles = this._inlineStyles[i] = {};
 
       /** @type {Number} */
-      const duration = (spring ? /** @type {Spring} */(spring).duration : getFunctionValue(setValue(params.duration, globals.defaults.duration), $el, i, targetsLength)) * timeScale;
+      const duration = (spring ? /** @type {Spring} */(spring).settlingDuration : getFunctionValue(setValue(params.duration, globals.defaults.duration), $el, i, targetsLength)) * timeScale;
       /** @type {Number} */
       const delay = getFunctionValue(setValue(params.delay, globals.defaults.delay), $el, i, targetsLength) * timeScale;
       /** @type {CompositeOperation} */
@@ -263,6 +257,12 @@ class WAAPIAnimation {
         const tweenParams = { iterations, direction, fill, easing, duration, delay, composite };
         const propertyValue = params[name];
         const individualTransformProperty = hasIndividualTransforms ? validTransforms.includes(name) ? name : shortTransforms.get(name) : false;
+
+        const styleName = individualTransformProperty ? 'transform' : name;
+        if (!inlineStyles[styleName]) {
+          inlineStyles[styleName] = elStyle[styleName];
+        }
+
         let parsedPropertyValue;
         if (isObj(propertyValue)) {
           const tweenOptions = /** @type {WAAPITweenOptions} */(propertyValue);
@@ -271,7 +271,7 @@ class WAAPIAnimation {
           const to = /** @type {WAAPITweenOptions} */(tweenOptions).to;
           const from = /** @type {WAAPITweenOptions} */(tweenOptions).from;
           /** @type {Number} */
-          tweenParams.duration = (tweenOptionsSpring ? /** @type {Spring} */(tweenOptionsSpring).duration : getFunctionValue(setValue(tweenOptions.duration, duration), $el, i, targetsLength)) * timeScale;
+          tweenParams.duration = (tweenOptionsSpring ? /** @type {Spring} */(tweenOptionsSpring).settlingDuration : getFunctionValue(setValue(tweenOptions.duration, duration), $el, i, targetsLength)) * timeScale;
           /** @type {Number} */
           tweenParams.delay = getFunctionValue(setValue(tweenOptions.delay, delay), $el, i, targetsLength) * timeScale;
           /** @type {CompositeOperation} */
@@ -288,10 +288,10 @@ class WAAPIAnimation {
           addWAAPIAnimation(this, $el, name, keyframes, tweenParams);
           if (!isUnd(from)) {
             if (!individualTransformProperty) {
-              $el.style[name] = keyframes[name][0];
+              elStyle[name] = keyframes[name][0];
             } else {
               const key = `--${individualTransformProperty}`;
-              $el.style.setProperty(key, keyframes[key][0]);
+              elStyle.setProperty(key, keyframes[key][0]);
             }
           }
         } else {
@@ -312,7 +312,7 @@ class WAAPIAnimation {
         for (let t in cachedTransforms) {
           transforms += `${transformsFragmentStrings[t]}var(--${t})) `;
         }
-        $el.style.transform = transforms;
+        elStyle.transform = transforms;
       }
     });
 
@@ -357,7 +357,8 @@ class WAAPIAnimation {
       // Make sure the animation playState is not 'paused' in order to properly trigger an onfinish callback.
       // The "paused" play state supersedes the "finished" play state; if the animation is both paused and finished, the "paused" state is the one that will be reported.
       // https://developer.mozilla.org/en-US/docs/Web/API/Animation/finish_event
-      if (t >= this.duration) anim.play();
+      // This is not needed for persisting animations since they never finish.
+      if (!this.persist && t >= this.duration) anim.play();
       anim.currentTime = t;
     });
   }
@@ -427,25 +428,46 @@ class WAAPIAnimation {
   }
 
   cancel() {
-    this.forEach('cancel');
-    return this.pause();
+    this.muteCallbacks = true; // This prevents triggering the onComplete callback and resolving the Promise
+    return this.commitStyles().forEach('cancel');
   }
 
   revert() {
-    this.cancel();
-    this.targets.forEach(($el, i) => $el.setAttribute('style', this._inlineStyles[i]) );
+    // NOTE: We need a better way to revert the transforms, since right now the entire transform property value is reverted,
+    // This means if you have multiple animations animating different transforms on the same target,
+    // reverting one of them will also override the transform property of the other animations.
+    // A better approach would be to store the original custom property values is they exist instead of the entire transform value,
+    // and update the CSS variables with the orignal value
+    this.cancel().targets.forEach(($el, i) => {
+      const targetStyle = $el.style;
+      const targetInlineStyles = this._inlineStyles[i];
+      for (let name in targetInlineStyles) {
+        const originalInlinedValue = targetInlineStyles[name];
+        if (isUnd(originalInlinedValue) || originalInlinedValue === emptyString) {
+          targetStyle.removeProperty(toLowerCase(name));
+        } else {
+          targetStyle[name] = originalInlinedValue;
+        }
+      }
+      // Remove style attribute if empty
+      if ($el.getAttribute('style') === emptyString) $el.removeAttribute('style');
+    });
     return this;
   }
 
   /**
-   * @param  {WAAPICallback} [callback]
-   * @return {Promise}
+   * @typedef {this & {then: null}} ResolvedWAAPIAnimation
+   */
+
+  /**
+   * @param  {Callback<ResolvedWAAPIAnimation>} [callback]
+   * @return Promise<this>
    */
   then(callback = noop) {
     const then = this.then;
     const onResolve = () => {
       this.then = null;
-      callback(this);
+      callback(/** @type {ResolvedWAAPIAnimation} */(this));
       this.then = then;
       this._resolve = noop;
     };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "animejs",
-  "version": "4.2.0-beta.0",
-  "description": "JavaScript animation engine",
+  "version": "4.2.1",
   "homepage": "https://animejs.com",
+  "description": "JavaScript animation engine",
   "author": "Julian Garnier <julian@animejs.com>",
   "license": "MIT",
   "repository": {
@@ -20,14 +20,18 @@
     "anime",
     "animejs",
     "anime.js",
+    "timer",
     "animation",
     "timeline",
+    "animatable",
+    "draggable",
+    "scope",
+    "engine",
+    "scroll",
     "easings",
+    "cubic-bezier",
     "spring",
-    "scroll",
-    "drag",
-    "text",
-    "JavaScript",
+    "splitText",
     "CSS",
     "SVG",
     "WAAPI",
@@ -100,18 +104,48 @@
       "import": "./dist/modules/events/index.js",
       "default": "./dist/modules/events/index.cjs"
     },
-    "./spring": {
-      "types": "./dist/modules/spring/index.d.ts",
-      "require": "./dist/modules/spring/index.cjs",
-      "import": "./dist/modules/spring/index.js",
-      "default": "./dist/modules/spring/index.cjs"
-    },
     "./easings": {
       "types": "./dist/modules/easings/index.d.ts",
       "require": "./dist/modules/easings/index.cjs",
       "import": "./dist/modules/easings/index.js",
       "default": "./dist/modules/easings/index.cjs"
     },
+    "./easings/eases": {
+      "types": "./dist/modules/easings/eases/index.d.ts",
+      "require": "./dist/modules/easings/eases/index.cjs",
+      "import": "./dist/modules/easings/eases/index.js",
+      "default": "./dist/modules/easings/eases/index.cjs"
+    },
+    "./easings/linear": {
+      "types": "./dist/modules/easings/linear/index.d.ts",
+      "require": "./dist/modules/easings/linear/index.cjs",
+      "import": "./dist/modules/easings/linear/index.js",
+      "default": "./dist/modules/easings/linear/index.cjs"
+    },
+    "./easings/steps": {
+      "types": "./dist/modules/easings/steps/index.d.ts",
+      "require": "./dist/modules/easings/steps/index.cjs",
+      "import": "./dist/modules/easings/steps/index.js",
+      "default": "./dist/modules/easings/steps/index.cjs"
+    },
+    "./easings/irregular": {
+      "types": "./dist/modules/easings/irregular/index.d.ts",
+      "require": "./dist/modules/easings/irregular/index.cjs",
+      "import": "./dist/modules/easings/irregular/index.js",
+      "default": "./dist/modules/easings/irregular/index.cjs"
+    },
+    "./easings/cubic-bezier": {
+      "types": "./dist/modules/easings/cubic-bezier/index.d.ts",
+      "require": "./dist/modules/easings/cubic-bezier/index.cjs",
+      "import": "./dist/modules/easings/cubic-bezier/index.js",
+      "default": "./dist/modules/easings/cubic-bezier/index.cjs"
+    },
+    "./easings/spring": {
+      "types": "./dist/modules/easings/spring/index.d.ts",
+      "require": "./dist/modules/easings/spring/index.cjs",
+      "import": "./dist/modules/easings/spring/index.js",
+      "default": "./dist/modules/easings/spring/index.cjs"
+    },
     "./utils": {
       "types": "./dist/modules/utils/index.d.ts",
       "require": "./dist/modules/utils/index.cjs",
@@ -139,8 +173,9 @@
   },
   "devDependencies": {
     "@rollup/plugin-terser": "^0.4.4",
+    "@types/mocha": "^10.0.10",
     "@types/node": "^24.3.0",
-    "browser-sync": "^2.29.3",
+    "browser-sync": "^3.0.4",
     "chai": "^4.3.10",
     "mocha": "^10.2.0",
     "nodemon": "^3.1.10",

package/dist/modules/easings/parser.cjs

@@ -1,59 +0,0 @@
-/**
- * Anime.js - easings - CJS
- * @version v4.2.0
- * @license MIT
- * @copyright 2025 - Julian Garnier
- */
-
-'use strict';
-
-var helpers = require('../core/helpers.cjs');
-var none = require('./none.cjs');
-
-/**
- * @import {
- *   EasingFunction,
- *   PowerEasing,
- *   EasingFunctionWithParams,
- * } from '../types/index.js'
-*/
-
-/** @type {PowerEasing} */
-const easeInPower = (p = 1.68) => t => helpers.pow(t, +p);
-
-/**
- * @callback EaseType
- * @param {EasingFunction} Ease
- * @return {EasingFunction}
- */
-
-/** @type {Record<String, EaseType>} */
-const easeTypes = {
-  in: easeIn => t => easeIn(t),
-  out: easeIn => t => 1 - easeIn(1 - t),
-  inOut: easeIn => t => t < .5 ? easeIn(t * 2) / 2 : 1 - easeIn(t * -2 + 2) / 2,
-  outIn: easeIn => t => t < .5 ? (1 - easeIn(1 - t * 2)) / 2 : (easeIn(t * 2 - 1) + 1) / 2,
-};
-
-/**
- * @param  {String} string
- * @param  {Record<String, EasingFunctionWithParams|EasingFunction>} easesFunctions
- * @param  {Object} easesLookups
- * @return {EasingFunction}
- */
-const parseEaseString = (string, easesFunctions, easesLookups) => {
-  if (easesLookups[string]) return easesLookups[string];
-  if (string.indexOf('(') <= -1) {
-    const hasParams = easeTypes[string] || string.includes('Back') || string.includes('Elastic');
-    const parsedFn = /** @type {EasingFunction} */(hasParams ? /** @type {EasingFunctionWithParams} */(easesFunctions[string])() : easesFunctions[string]);
-    return parsedFn ? easesLookups[string] = parsedFn : none.none;
-  } else {
-    const split = string.slice(0, -1).split('(');
-    const parsedFn = /** @type {EasingFunctionWithParams} */(easesFunctions[split[0]]);
-    return parsedFn ? easesLookups[string] = parsedFn(...split[1].split(',')) : none.none;
-  }
-};
-
-exports.easeInPower = easeInPower;
-exports.easeTypes = easeTypes;
-exports.parseEaseString = parseEaseString;

package/dist/modules/easings/parser.d.ts

@@ -1,21 +0,0 @@
-/**
- * @import {
- *   EasingFunction,
- *   PowerEasing,
- *   EasingFunctionWithParams,
- * } from '../types/index.js'
-*/
-/** @type {PowerEasing} */
-export const easeInPower: PowerEasing;
-/**
- * @callback EaseType
- * @param {EasingFunction} Ease
- * @return {EasingFunction}
- */
-/** @type {Record<String, EaseType>} */
-export const easeTypes: Record<string, EaseType>;
-export function parseEaseString(string: string, easesFunctions: Record<string, EasingFunctionWithParams | EasingFunction>, easesLookups: any): EasingFunction;
-export type EaseType = (Ease: EasingFunction) => EasingFunction;
-import type { PowerEasing } from '../types/index.js';
-import type { EasingFunctionWithParams } from '../types/index.js';
-import type { EasingFunction } from '../types/index.js';

package/dist/modules/easings/parser.js

@@ -1,55 +0,0 @@
-/**
- * Anime.js - easings - ESM
- * @version v4.2.0
- * @license MIT
- * @copyright 2025 - Julian Garnier
- */
-
-import { pow } from '../core/helpers.js';
-import { none } from './none.js';
-
-/**
- * @import {
- *   EasingFunction,
- *   PowerEasing,
- *   EasingFunctionWithParams,
- * } from '../types/index.js'
-*/
-
-/** @type {PowerEasing} */
-const easeInPower = (p = 1.68) => t => pow(t, +p);
-
-/**
- * @callback EaseType
- * @param {EasingFunction} Ease
- * @return {EasingFunction}
- */
-
-/** @type {Record<String, EaseType>} */
-const easeTypes = {
-  in: easeIn => t => easeIn(t),
-  out: easeIn => t => 1 - easeIn(1 - t),
-  inOut: easeIn => t => t < .5 ? easeIn(t * 2) / 2 : 1 - easeIn(t * -2 + 2) / 2,
-  outIn: easeIn => t => t < .5 ? (1 - easeIn(1 - t * 2)) / 2 : (easeIn(t * 2 - 1) + 1) / 2,
-};
-
-/**
- * @param  {String} string
- * @param  {Record<String, EasingFunctionWithParams|EasingFunction>} easesFunctions
- * @param  {Object} easesLookups
- * @return {EasingFunction}
- */
-const parseEaseString = (string, easesFunctions, easesLookups) => {
-  if (easesLookups[string]) return easesLookups[string];
-  if (string.indexOf('(') <= -1) {
-    const hasParams = easeTypes[string] || string.includes('Back') || string.includes('Elastic');
-    const parsedFn = /** @type {EasingFunction} */(hasParams ? /** @type {EasingFunctionWithParams} */(easesFunctions[string])() : easesFunctions[string]);
-    return parsedFn ? easesLookups[string] = parsedFn : none;
-  } else {
-    const split = string.slice(0, -1).split('(');
-    const parsedFn = /** @type {EasingFunctionWithParams} */(easesFunctions[split[0]]);
-    return parsedFn ? easesLookups[string] = parsedFn(...split[1].split(',')) : none;
-  }
-};
-
-export { easeInPower, easeTypes, parseEaseString };

package/dist/modules/spring/index.cjs

@@ -1,15 +0,0 @@
-/**
- * Anime.js - spring - CJS
- * @version v4.2.0
- * @license MIT
- * @copyright 2025 - Julian Garnier
- */
-
-'use strict';
-
-var spring = require('./spring.cjs');
-
-
-
-exports.Spring = spring.Spring;
-exports.createSpring = spring.createSpring;

package/dist/modules/spring/index.d.ts

@@ -1 +0,0 @@
-export * from "./spring.js";

package/dist/modules/spring/index.js

@@ -1,8 +0,0 @@
-/**
- * Anime.js - spring - ESM
- * @version v4.2.0
- * @license MIT
- * @copyright 2025 - Julian Garnier
- */
-
-export { Spring, createSpring } from './spring.js';

package/dist/modules/spring/spring.cjs

@@ -1,133 +0,0 @@
-/**
- * Anime.js - spring - CJS
- * @version v4.2.0
- * @license MIT
- * @copyright 2025 - Julian Garnier
- */
-
-'use strict';
-
-var consts = require('../core/consts.cjs');
-var globals = require('../core/globals.cjs');
-var helpers = require('../core/helpers.cjs');
-var values = require('../core/values.cjs');
-
-/**
- * @import {
- *   EasingFunction,
- *   SpringParams,
- * } from '../types/index.js'
-*/
-
-/*
- * Spring ease solver adapted from https://webkit.org/demos/spring/spring.js
- * (c) 2016 Webkit - Apple Inc
- */
-
-const maxSpringParamValue = consts.K * 10;
-
-class Spring {
-  /**
-   * @param {SpringParams} [parameters]
-   */
-  constructor(parameters = {}) {
-    this.timeStep = .02; // Interval fed to the solver to calculate duration
-    this.restThreshold = .0005; // Values below this threshold are considered resting position
-    this.restDuration = 200; // Duration in ms used to check if the spring is resting after reaching restThreshold
-    this.maxDuration = 60000; // The maximum allowed spring duration in ms (default 1 min)
-    this.maxRestSteps = this.restDuration / this.timeStep / consts.K; // How many steps allowed after reaching restThreshold before stopping the duration calculation
-    this.maxIterations = this.maxDuration / this.timeStep / consts.K; // Calculate the maximum iterations allowed based on maxDuration
-    this.m = helpers.clamp(values.setValue(parameters.mass, 1), 0, maxSpringParamValue);
-    this.s = helpers.clamp(values.setValue(parameters.stiffness, 100), 1, maxSpringParamValue);
-    this.d = helpers.clamp(values.setValue(parameters.damping, 10), .1, maxSpringParamValue);
-    this.v = helpers.clamp(values.setValue(parameters.velocity, 0), -maxSpringParamValue, maxSpringParamValue);
-    this.w0 = 0;
-    this.zeta = 0;
-    this.wd = 0;
-    this.b = 0;
-    this.solverDuration = 0;
-    this.duration = 0;
-    this.compute();
-    /** @type {EasingFunction} */
-    this.ease = t => t === 0 || t === 1 ? t : this.solve(t * this.solverDuration);
-  }
-
-  /** @type {EasingFunction} */
-  solve(time) {
-    const { zeta, w0, wd, b } = this;
-    let t = time;
-    if (zeta < 1) {
-      t = helpers.exp(-t * zeta * w0) * (1 * helpers.cos(wd * t) + b * helpers.sin(wd * t));
-    } else {
-      t = (1 + b * t) * helpers.exp(-t * w0);
-    }
-    return 1 - t;
-  }
-
-  compute() {
-    const { maxRestSteps, maxIterations, restThreshold, timeStep, m, d, s, v } = this;
-    const w0 = this.w0 = helpers.clamp(helpers.sqrt(s / m), consts.minValue, consts.K);
-    const zeta = this.zeta = d / (2 * helpers.sqrt(s * m));
-    const wd = this.wd = zeta < 1 ? w0 * helpers.sqrt(1 - zeta * zeta) : 0;
-    this.b = zeta < 1 ? (zeta * w0 + -v) / wd : -v + w0;
-    let solverTime = 0;
-    let restSteps = 0;
-    let iterations = 0;
-    while (restSteps < maxRestSteps && iterations < maxIterations) {
-      if (helpers.abs(1 - this.solve(solverTime)) < restThreshold) {
-        restSteps++;
-      } else {
-        restSteps = 0;
-      }
-      this.solverDuration = solverTime;
-      solverTime += timeStep;
-      iterations++;
-    }
-    this.duration = helpers.round(this.solverDuration * consts.K, 0) * globals.globals.timeScale;
-  }
-
-  get mass() {
-    return this.m;
-  }
-
-  set mass(v) {
-    this.m = helpers.clamp(values.setValue(v, 1), 0, maxSpringParamValue);
-    this.compute();
-  }
-
-  get stiffness() {
-    return this.s;
-  }
-
-  set stiffness(v) {
-    this.s = helpers.clamp(values.setValue(v, 100), 1, maxSpringParamValue);
-    this.compute();
-  }
-
-  get damping() {
-    return this.d;
-  }
-
-  set damping(v) {
-    this.d = helpers.clamp(values.setValue(v, 10), .1, maxSpringParamValue);
-    this.compute();
-  }
-
-  get velocity() {
-    return this.v;
-  }
-
-  set velocity(v) {
-    this.v = helpers.clamp(values.setValue(v, 0), -maxSpringParamValue, maxSpringParamValue);
-    this.compute();
-  }
-}
-
-/**
- * @param {SpringParams} [parameters]
- * @returns {Spring}
- */
-const createSpring = (parameters) => new Spring(parameters);
-
-exports.Spring = Spring;
-exports.createSpring = createSpring;