animejs 4.3.6 → 4.4.1

package/dist/modules/timeline/timeline.js

@@ -1,6 +1,6 @@
 /**
  * Anime.js - timeline - ESM
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -11,10 +11,10 @@ import { isUnd, mergeObjects, isObj, isFnc, isStr, normalizeTime, forEachChildre
 import { setValue } from '../core/values.js';
 import { parseTargets } from '../core/targets.js';
 import { tick } from '../core/render.js';
-import { cleanInlineStyles } from '../core/styles.js';
+import { revertValues } from '../core/styles.js';
+import { Timer } from '../timer/timer.js';
 import { removeTargetsFromRenderable } from '../animation/composition.js';
 import { JSAnimation } from '../animation/animation.js';
-import { Timer } from '../timer/timer.js';
 import { parseEase } from '../easings/eases/parser.js';
 import { parseTimelinePosition } from './position.js';
 
@@ -31,6 +31,7 @@ import { parseTimelinePosition } from './position.js';
  *   DefaultsParams,
  *   TimelinePosition,
  *   StaggerFunction,
+ *   TargetsArray,
  * } from '../types/index.js'
 */
 
@@ -40,6 +41,8 @@ import { parseTimelinePosition } from './position.js';
  * } from '../waapi/waapi.js'
 */
 
+/** @import {TweakRegister} from 'tweaks' */
+
 /**
  * @param {Timeline} tl
  * @return {Number}
@@ -61,7 +64,7 @@ function getTimelineTotalDuration(tl) {
  * @param  {Number} timePosition
  * @param  {TargetsParam} targets
  * @param  {Number} [index]
- * @param  {Number} [length]
+ * @param  {TargetsArray} [allTargets]
  * @return {Timeline}
  *
  * @param  {TimerParams|AnimationParams} childParams
@@ -69,15 +72,15 @@ function getTimelineTotalDuration(tl) {
  * @param  {Number} timePosition
  * @param  {TargetsParam} [targets]
  * @param  {Number} [index]
- * @param  {Number} [length]
+ * @param  {TargetsArray} [allTargets]
  */
-function addTlChild(childParams, tl, timePosition, targets, index, length) {
+function addTlChild(childParams, tl, timePosition, targets, index, allTargets) {
   const isSetter = isNum(childParams.duration) && /** @type {Number} */(childParams.duration) <= minValue;
   // Offset the tl position with -minValue for 0 duration animations or .set() calls in order to align their end value with the defined position
   const adjustedPosition = isSetter ? timePosition - minValue : timePosition;
   if (tl.composition) tick(tl, adjustedPosition, 1, 1, tickModes.AUTO);
   const tlChild = targets ?
-    new JSAnimation(targets,/** @type {AnimationParams} */(childParams), tl, adjustedPosition, false, index, length) :
+    new JSAnimation(targets,/** @type {AnimationParams} */(childParams), tl, adjustedPosition, false, index, allTargets) :
     new Timer(/** @type {TimerParams} */(childParams), tl, adjustedPosition);
   if (tl.composition) tlChild.init(true);
   // TODO: Might be better to insert at a position relative to startTime?
@@ -125,7 +128,7 @@ class Timeline extends Timer {
    * @overload
    * @param {TargetsParam} a1
    * @param {AnimationParams} a2
-   * @param {TimelinePosition|StaggerFunction<Number|String>} [a3]
+   * @param {TimelinePosition|StaggerFunction<Number|String>|TweakRegister} [a3]
    * @return {this}
    *
    * @overload
@@ -135,7 +138,7 @@ class Timeline extends Timer {
    *
    * @param {TargetsParam|TimerParams} a1
    * @param {TimelinePosition|AnimationParams} a2
-   * @param {TimelinePosition|StaggerFunction<Number|String>} [a3]
+   * @param {TimelinePosition|StaggerFunction<Number|String>|TweakRegister} [a3]
    */
   add(a1, a2, a3) {
     const isAnim = isObj(a2);
@@ -144,9 +147,11 @@ class Timeline extends Timer {
       this._hasChildren = true;
       if (isAnim) {
         const childParams = /** @type {AnimationParams} */(a2);
-        // Check for function for children stagger positions
-        if (isFnc(a3)) {
-          const staggeredPosition = a3;
+        const editorHook = globals.editor && globals.editor.addTimelineChild;
+        const isStaggerType = a3 && /** @type {TweakRegister} */(a3).type === 'Stagger' && globals.editor;
+        // Check for function or Stagger type children positions
+        const staggeredPosition = isFnc(a3) ? a3 : null;
+        if (staggeredPosition || isStaggerType) {
           const parsedTargetsArray = parseTargets(/** @type {TargetsParam} */(a1));
           // Store initial duration before adding new children that will change the duration
           const tlDuration = this.duration;
@@ -157,28 +162,36 @@ class Timeline extends Timer {
           let i = 0;
           /** @type {Number} */
           const parsedLength = (parsedTargetsArray.length);
+          // Call editor hook once for the entire stagger group instead of per target
+          const resolvedParams = editorHook ? editorHook(/** @type {TargetsParam} */(a1), childParams, this.id, a3, parsedLength) : null;
+          // Resolve stagger AFTER editor hook so tweaked position value (a3.defaultValue) is used
+          const staggerFn = staggeredPosition || globals.editor.resolveStagger(/** @type {TweakRegister} */(a3).defaultValue);
           parsedTargetsArray.forEach((/** @type {Target} */target) => {
             // Create a new parameter object for each staggered children
-            const staggeredChildParams = { ...childParams };
+            const staggeredChildParams = { ...(resolvedParams || childParams) };
             // Reset the duration of the timeline iteration before each stagger to prevent wrong start value calculation
             this.duration = tlDuration;
             this.iterationDuration = tlIterationDuration;
             if (!isUnd(id)) staggeredChildParams.id = id + '-' + i;
+            const staggeredTimePosition = parseTimelinePosition(this, staggerFn(target, i, parsedTargetsArray, null, this));
             addTlChild(
               staggeredChildParams,
               this,
-              parseTimelinePosition(this, staggeredPosition(target, i, parsedLength, this)),
+              staggeredTimePosition,
               target,
               i,
-              parsedLength
+              parsedTargetsArray,
             );
             i++;
           });
         } else {
+          // Call editor hook before resolving position so tweaked values are applied
+          const resolvedChildParams = editorHook ? editorHook(/** @type {TargetsParam} */(a1), childParams, this.id, a3) : childParams;
+          const resolvedPosition = a3 && /** @type {*} */(a3).type ? /** @type {*} */(a3).defaultValue : a3;
           addTlChild(
-            childParams,
+            resolvedChildParams,
             this,
-            parseTimelinePosition(this, a3),
+            parseTimelinePosition(this, resolvedPosition),
             /** @type {TargetsParam} */(a1),
           );
         }
@@ -300,7 +313,7 @@ class Timeline extends Timer {
   revert() {
     super.revert();
     forEachChildren(this, (/** @type {JSAnimation|Timer} */child) => child.revert, true);
-    return cleanInlineStyles(this);
+    return revertValues(this);
   }
 
   /**
@@ -320,6 +333,11 @@ class Timeline extends Timer {
  * @param {TimelineParams} [parameters]
  * @return {Timeline}
  */
-const createTimeline = parameters => new Timeline(parameters).init();
+const createTimeline = parameters => {
+  if (globals.editor) {
+    return /** @type {Timeline} */(/** @type {unknown} */(globals.editor.addTimeline(parameters)));
+  }
+  return new Timeline(parameters).init();
+};
 
 export { Timeline, createTimeline };

package/dist/modules/timer/index.cjs

@@ -1,6 +1,6 @@
 /**
  * Anime.js - timer - CJS
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */

package/dist/modules/timer/index.js

@@ -1,6 +1,6 @@
 /**
  * Anime.js - timer - ESM
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */

package/dist/modules/timer/timer.cjs

@@ -1,6 +1,6 @@
 /**
  * Anime.js - timer - CJS
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -69,6 +69,9 @@ const reviveTimer = timer => {
 
 let timerId = 0;
 
+/** @param {Timer} prev @param {Timer} child */
+const sortByPriority = (prev, child) => prev._priority > child._priority;
+
 /**
  * Base class used to create Timers, Animations and Timelines
  */
@@ -95,6 +98,7 @@ class Timer extends clock.Clock {
       autoplay,
       frameRate,
       playbackRate,
+      priority,
       onComplete,
       onLoop,
       onPause,
@@ -116,16 +120,6 @@ class Timer extends clock.Clock {
                               /** @type {Number} */(timerLoop) < 0 ? Infinity :
                               /** @type {Number} */(timerLoop) + 1;
 
-    if (globals.devTools) {
-      const isInfinite = timerIterationCount === Infinity;
-      const registered = globals.devTools.register(this, parameters, isInfinite);
-      if (registered && isInfinite) {
-        const minIterations = alternate ? 2 : 1;
-        const iterations = parent ? globals.devTools.maxNestedInfiniteLoops : globals.devTools.maxInfiniteLoops;
-        timerIterationCount = Math.max(iterations, minIterations);
-      }
-    }
-
     let offsetPosition = 0;
 
     if (parent) {
@@ -209,6 +203,8 @@ class Timer extends clock.Clock {
     this._fps = values.setValue(frameRate, timerDefaults.frameRate);
     /** @type {Number} */
     this._speed = values.setValue(playbackRate, timerDefaults.playbackRate);
+    /** @type {Number} */
+    this._priority = +values.setValue(priority, 1);
   }
 
   get cancelled() {
@@ -353,7 +349,7 @@ class Timer extends clock.Clock {
       render.tick(this, consts.minValue, 0, 0, consts.tickModes.FORCE);
     } else {
       if (!this._running) {
-        helpers.addChild(engine.engine, this);
+        helpers.addChild(engine.engine, this, sortByPriority);
         engine.engine._hasChildren = true;
         this._running = true;
       }

package/dist/modules/timer/timer.d.ts

@@ -65,6 +65,8 @@ export class Timer extends Clock {
     _prev: Renderable;
     /** @type {Renderable} */
     _next: Renderable;
+    /** @type {Number} */
+    _priority: number;
     set cancelled(cancelled: boolean);
     get cancelled(): boolean;
     set currentTime(time: number);

package/dist/modules/timer/timer.js

@@ -1,13 +1,13 @@
 /**
  * Anime.js - timer - ESM
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
 
 import { minValue, noop, maxValue, compositionTypes, tickModes } from '../core/consts.js';
 import { isFnc, isUnd, now, clampInfinity, clamp, round, forEachChildren, addChild, normalizeTime, floor } from '../core/helpers.js';
-import { globals, devTools, scope } from '../core/globals.js';
+import { globals, scope } from '../core/globals.js';
 import { setValue } from '../core/values.js';
 import { tick } from '../core/render.js';
 import { removeTweenSliblings, composeTween, getTweenSiblings } from '../animation/composition.js';
@@ -67,6 +67,9 @@ const reviveTimer = timer => {
 
 let timerId = 0;
 
+/** @param {Timer} prev @param {Timer} child */
+const sortByPriority = (prev, child) => prev._priority > child._priority;
+
 /**
  * Base class used to create Timers, Animations and Timelines
  */
@@ -93,6 +96,7 @@ class Timer extends Clock {
       autoplay,
       frameRate,
       playbackRate,
+      priority,
       onComplete,
       onLoop,
       onPause,
@@ -114,16 +118,6 @@ class Timer extends Clock {
                               /** @type {Number} */(timerLoop) < 0 ? Infinity :
                               /** @type {Number} */(timerLoop) + 1;
 
-    if (devTools) {
-      const isInfinite = timerIterationCount === Infinity;
-      const registered = devTools.register(this, parameters, isInfinite);
-      if (registered && isInfinite) {
-        const minIterations = alternate ? 2 : 1;
-        const iterations = parent ? devTools.maxNestedInfiniteLoops : devTools.maxInfiniteLoops;
-        timerIterationCount = Math.max(iterations, minIterations);
-      }
-    }
-
     let offsetPosition = 0;
 
     if (parent) {
@@ -207,6 +201,8 @@ class Timer extends Clock {
     this._fps = setValue(frameRate, timerDefaults.frameRate);
     /** @type {Number} */
     this._speed = setValue(playbackRate, timerDefaults.playbackRate);
+    /** @type {Number} */
+    this._priority = +setValue(priority, 1);
   }
 
   get cancelled() {
@@ -351,7 +347,7 @@ class Timer extends Clock {
       tick(this, minValue, 0, 0, tickModes.FORCE);
     } else {
       if (!this._running) {
-        addChild(engine, this);
+        addChild(engine, this, sortByPriority);
         engine._hasChildren = true;
         this._running = true;
       }

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

@@ -27,12 +27,12 @@ export type Renderable = JSAnimation | Timeline;
 export type Tickable = Timer | Renderable;
 export type CallbackArgument = Timer & JSAnimation & Timeline;
 export type Revertible = Animatable | Tickable | WAAPIAnimation | Draggable | ScrollObserver | TextSplitter | Scope | AutoLayout;
-export type StaggerFunction<T> = (target?: Target, index?: number, length?: number, tl?: Timeline) => T;
+export type StaggerFunction<T> = (target?: Target, index?: number, targets?: TargetsArray, prevTween?: Tween | null, tl?: Timeline) => T;
 export type StaggerParams = {
     start?: number | string;
-    from?: number | "first" | "center" | "last" | "random";
+    from?: number | "first" | "center" | "last" | "random" | Array<number>;
     reversed?: boolean;
-    grid?: Array<number>;
+    grid?: Array<number> | boolean;
     axis?: ("x" | "y");
     use?: string | ((target: Target, i: number, length: number) => number);
     total?: number;
@@ -57,8 +57,8 @@ export type PowerEasing = (power?: number | string) => EasingFunction;
 export type BackEasing = (overshoot?: number | string) => EasingFunction;
 export type ElasticEasing = (amplitude?: number | string, period?: number | string) => EasingFunction;
 export type EasingFunctionWithParams = PowerEasing | BackEasing | ElasticEasing;
-export type EasingParam = (string & {}) | EaseStringParamNames | EasingFunction | Spring;
-export type WAAPIEasingParam = (string & {}) | EaseStringParamNames | WAAPIEaseStringParamNames | EasingFunction | Spring;
+export type EasingParam = (string & {}) | EaseStringParamNames | EasingFunction | Spring | TweakRegister;
+export type WAAPIEasingParam = (string & {}) | EaseStringParamNames | WAAPIEaseStringParamNames | EasingFunction | Spring | TweakRegister;
 export type SpringParams = {
     /**
      * - Mass, default 1
@@ -112,9 +112,10 @@ export type TimerOptions = {
     autoplay?: boolean | ScrollObserver;
     frameRate?: number;
     playbackRate?: number;
+    priority?: number;
 };
 export type TimerParams = TimerOptions & TickableCallbacks<Timer>;
-export type FunctionValue = (target: Target, index: number, length: number) => number | string | TweenObjectValue | EasingParam | Array<number | string | TweenObjectValue>;
+export type FunctionValue = (target?: Target, index?: number, targets?: TargetsArray, prevTween?: Tween | null) => number | string | TweenObjectValue | EasingParam | Array<number | string | TweenObjectValue>;
 export type TweenModifier = (value: number) => number | string;
 export type ColorArray = [number, number, number, number];
 export type Tween = {
@@ -246,7 +247,7 @@ export type TimelinePosition = number | `+=${number}` | `-=${number}` | `*=${num
  * - `'label'` - Label: Position animation at a named label position (e.g., `'My Label'`)<br>
  * - `stagger(String|Nummber)` - Stagger multi-elements animation positions (e.g., 10, 20, 30...)
  */
-export type TimelineAnimationPosition = TimelinePosition | StaggerFunction<number | string>;
+export type TimelineAnimationPosition = TimelinePosition | StaggerFunction<number | string> | TweakRegister;
 export type TimelineOptions = {
     defaults?: DefaultsParams;
     playbackEase?: EasingParam;
@@ -254,7 +255,7 @@ export type TimelineOptions = {
 };
 export type TimelineParams = TimerOptions & TimelineOptions & TickableCallbacks<Timeline> & RenderableCallbacks<Timeline>;
 export type WAAPITweenValue = string | number | Array<string> | Array<number>;
-export type WAAPIFunctionValue = (target: DOMTarget, index: number, length: number) => WAAPITweenValue | WAAPIEasingParam;
+export type WAAPIFunctionValue = (target: DOMTarget, index: number, targets: DOMTargetsArray) => WAAPITweenValue | WAAPIEasingParam;
 export type WAAPIKeyframeValue = WAAPITweenValue | WAAPIFunctionValue | Array<string | number | WAAPIFunctionValue>;
 export type WAAPITweenOptions = {
     to?: WAAPIKeyframeValue;
@@ -392,6 +393,72 @@ export type TextSplitterParams = {
     includeSpaces?: boolean;
     debug?: boolean;
 };
+export type ScrambleTextParams = {
+    /**
+     * - the text to transition to, otherwise uses the original text
+     */
+    text?: string | ((arg0: Target, arg1: number, arg2: TargetsArray) => string);
+    /**
+     * - the characters used for scramble; named sets: 'lowercase', 'uppercase', 'numbers', 'symbols', 'braille', 'blocks', 'shades'; range syntax: 'A-Z', 'a-z0-9'; defaults to 'a-zA-Z0-9!%#_'
+     */
+    chars?: string | ((arg0: Target, arg1: number, arg2: TargetsArray) => string);
+    /**
+     * - the easing applied to the scramble animation
+     */
+    ease?: EasingParam;
+    /**
+     * - where the reveal wave starts from, 'auto' (default) uses 'left' when text grows and 'right' when it shrinks
+     */
+    from?: number | "left" | "center" | "right" | "random" | "auto";
+    /**
+     * - reverses the reveal order, so 'center' reveals from edges inward instead of center outward
+     */
+    reversed?: boolean;
+    /**
+     * - characters displayed at the leading edge of the reveal wave; true uses '_', a number is a char code, a string is used directly
+     */
+    cursor?: boolean | number | string;
+    /**
+     * - adds random timing offsets to each character's start and end, creating a more organic reveal
+     */
+    perturbation?: number;
+    /**
+     * - a seed for the random number generator to produce reproducible scramble sequences
+     */
+    seed?: number;
+    /**
+     * - controls the starting appearance: false shows original text, true scrambles it (default), '' starts from blank, ' ' replaces characters with spaces, a custom string (supports range syntax like 'A-Z') uses its characters as scramble set
+     */
+    override?: boolean | string;
+    /**
+     * - characters per second entering the active zone; higher values make the reveal wave move faster (default: 60)
+     */
+    revealRate?: number;
+    /**
+     * - time in ms each character spends scrambling before settling into its final glyph (default: 300)
+     */
+    settleDuration?: number;
+    /**
+     * - how many times per second scramble characters cycle in the active zone (default: 30)
+     */
+    settleRate?: number;
+    /**
+     * - if set to a value greater than 0, overrides the computed duration from interval and settle; if unset or 0, duration is calculated automatically from text length and timing parameters
+     */
+    duration?: number | ((arg0: Target, arg1: number, arg2: TargetsArray) => number);
+    /**
+     * - delay in ms before the reveal wave starts within the scramble animation
+     */
+    revealDelay?: number | ((arg0: Target, arg1: number, arg2: TargetsArray) => number);
+    /**
+     * - delay in ms before the entire scramble animation starts
+     */
+    delay?: number | ((arg0: Target, arg1: number, arg2: TargetsArray) => number);
+    /**
+     * - callback fired each time a character changes during scramble; receives the current scrambled text and the eased progress (0-1)
+     */
+    onChange?: (arg0: string, arg1: number) => void;
+};
 export type DrawableSVGGeometry = SVGGeometryElement & {
     setAttribute(name: "draw", value: `${number} ${number}`): void;
     draw: `${number} ${number}`;
@@ -408,5 +475,6 @@ import type { TextSplitter } from '../text/split.js';
 import type { Scope } from '../scope/scope.js';
 import type { AutoLayout } from '../layout/layout.js';
 import type { Spring } from '../easings/spring/index.js';
+import type { TweakRegister } from 'tweaks';
 import type { tweenTypes } from '../core/consts.js';
 import type { valueTypes } from '../core/consts.js';

package/dist/modules/utils/chainable.cjs

@@ -1,6 +1,6 @@
 /**
  * Anime.js - utils - CJS
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -36,10 +36,13 @@ const chain = fn => {
     const result = fn(...args);
     return new Proxy(consts.noop, {
       apply: (_, __, [v]) => result(v),
-      get: (_, prop) => chain(/**@param {...Number|String} nextArgs */(...nextArgs) => {
-        const nextResult = chainables[prop](...nextArgs);
-        return (/**@type {Number|String} */v) => nextResult(result(v));
-      })
+      get: (_, prop) => {
+        if (!chainables[prop]) return undefined;
+        return chain(/**@param {...Number|String} nextArgs */(...nextArgs) => {
+          const nextResult = chainables[prop](...nextArgs);
+          return (/**@type {Number|String} */v) => nextResult(result(v));
+        })
+      }
     });
   }
 };

package/dist/modules/utils/chainable.js

@@ -1,6 +1,6 @@
 /**
  * Anime.js - utils - ESM
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -34,10 +34,13 @@ const chain = fn => {
     const result = fn(...args);
     return new Proxy(noop, {
       apply: (_, __, [v]) => result(v),
-      get: (_, prop) => chain(/**@param {...Number|String} nextArgs */(...nextArgs) => {
-        const nextResult = chainables[prop](...nextArgs);
-        return (/**@type {Number|String} */v) => nextResult(result(v));
-      })
+      get: (_, prop) => {
+        if (!chainables[prop]) return undefined;
+        return chain(/**@param {...Number|String} nextArgs */(...nextArgs) => {
+          const nextResult = chainables[prop](...nextArgs);
+          return (/**@type {Number|String} */v) => nextResult(result(v));
+        })
+      }
     });
   }
 };

package/dist/modules/utils/index.cjs

@@ -1,6 +1,6 @@
 /**
  * Anime.js - utils - CJS
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -12,6 +12,7 @@ var random = require('./random.cjs');
 var time = require('./time.cjs');
 var target = require('./target.cjs');
 var stagger = require('./stagger.cjs');
+var helpers = require('../core/helpers.cjs');
 var styles = require('../core/styles.cjs');
 var targets = require('../core/targets.cjs');
 
@@ -39,5 +40,8 @@ exports.get = target.get;
 exports.remove = target.remove;
 exports.set = target.set;
 exports.stagger = stagger.stagger;
+exports.addChild = helpers.addChild;
+exports.forEachChildren = helpers.forEachChildren;
+exports.removeChild = helpers.removeChild;
 exports.cleanInlineStyles = styles.cleanInlineStyles;
 exports.$ = targets.registerTargets;

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

@@ -3,3 +3,4 @@ export * from "./random.js";
 export * from "./time.js";
 export * from "./target.js";
 export * from "./stagger.js";
+export { forEachChildren, addChild, removeChild } from "../core/helpers.js";

package/dist/modules/utils/index.js

@@ -1,6 +1,6 @@
 /**
  * Anime.js - utils - ESM
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -10,5 +10,6 @@ export { createSeededRandom, random, randomPick, shuffle } from './random.js';
 export { keepTime, sync } from './time.js';
 export { get, remove, set } from './target.js';
 export { stagger } from './stagger.js';
+export { addChild, forEachChildren, removeChild } from '../core/helpers.js';
 export { cleanInlineStyles } from '../core/styles.js';
 export { registerTargets as $ } from '../core/targets.js';

package/dist/modules/utils/number.cjs

@@ -1,6 +1,6 @@
 /**
  * Anime.js - utils - CJS
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */

package/dist/modules/utils/number.js

@@ -1,6 +1,6 @@
 /**
  * Anime.js - utils - ESM
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */

package/dist/modules/utils/random.cjs

@@ -1,6 +1,6 @@
 /**
  * Anime.js - utils - CJS
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */

package/dist/modules/utils/random.js

@@ -1,6 +1,6 @@
 /**
  * Anime.js - utils - ESM
- * @version v4.3.6
+ * @version v4.4.1
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */