animejs 4.1.4 → 4.2.0

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

@@ -0,0 +1,135 @@
+/**
+ * @typedef {Object} ChainablesMap
+ * @property {ChainedClamp} clamp
+ * @property {ChainedRound} round
+ * @property {ChainedSnap} snap
+ * @property {ChainedWrap} wrap
+ * @property {ChainedLerp} lerp
+ * @property {ChainedDamp} damp
+ * @property {ChainedMapRange} mapRange
+ * @property {ChainedRoundPad} roundPad
+ * @property {ChainedPadStart} padStart
+ * @property {ChainedPadEnd} padEnd
+ * @property {ChainedDegToRad} degToRad
+ * @property {ChainedRadToDeg} radToDeg
+ */
+/**
+ * @callback ChainedUtilsResult
+ * @param {Number} value - The value to process through the chained operations
+ * @return {Number} The processed result
+ */
+/**
+ * @typedef {ChainablesMap & ChainedUtilsResult} ChainableUtil
+ */
+/**
+ * @callback ChainedRoundPad
+ * @param {Number} decimalLength - Number of decimal places
+ * @return {ChainableUtil}
+ */
+export const roundPad: typeof numberUtils.roundPad & ChainedRoundPad;
+/**
+ * @callback ChainedPadStart
+ * @param {Number} totalLength - Target length
+ * @param {String} padString - String to pad with
+ * @return {ChainableUtil}
+ */
+export const padStart: typeof numberUtils.padStart & ChainedPadStart;
+/**
+ * @callback ChainedPadEnd
+ * @param {Number} totalLength - Target length
+ * @param {String} padString - String to pad with
+ * @return {ChainableUtil}
+ */
+export const padEnd: typeof numberUtils.padEnd & ChainedPadEnd;
+/**
+ * @callback ChainedWrap
+ * @param {Number} min - Minimum boundary
+ * @param {Number} max - Maximum boundary
+ * @return {ChainableUtil}
+ */
+export const wrap: typeof numberUtils.wrap & ChainedWrap;
+/**
+ * @callback ChainedMapRange
+ * @param {Number} inLow - Input range minimum
+ * @param {Number} inHigh - Input range maximum
+ * @param {Number} outLow - Output range minimum
+ * @param {Number} outHigh - Output range maximum
+ * @return {ChainableUtil}
+ */
+export const mapRange: typeof numberUtils.mapRange & ChainedMapRange;
+/**
+ * @callback ChainedDegToRad
+ * @return {ChainableUtil}
+ */
+export const degToRad: typeof numberUtils.degToRad & ChainedDegToRad;
+/**
+ * @callback ChainedRadToDeg
+ * @return {ChainableUtil}
+ */
+export const radToDeg: typeof numberUtils.radToDeg & ChainedRadToDeg;
+/**
+ * @callback ChainedSnap
+ * @param {Number|Array<Number>} increment - Step size or array of snap points
+ * @return {ChainableUtil}
+ */
+export const snap: typeof numberUtils.snap & ChainedSnap;
+/**
+ * @callback ChainedClamp
+ * @param {Number} min - Minimum boundary
+ * @param {Number} max - Maximum boundary
+ * @return {ChainableUtil}
+ */
+export const clamp: typeof numberUtils.clamp & ChainedClamp;
+/**
+ * @callback ChainedRound
+ * @param {Number} decimalLength - Number of decimal places
+ * @return {ChainableUtil}
+ */
+export const round: typeof numberUtils.round & ChainedRound;
+/**
+ * @callback ChainedLerp
+ * @param {Number} start - Starting value
+ * @param {Number} end - Ending value
+ * @return {ChainableUtil}
+ */
+export const lerp: typeof numberUtils.lerp & ChainedLerp;
+/**
+ * @callback ChainedDamp
+ * @param {Number} start - Starting value
+ * @param {Number} end - Target value
+ * @param {Number} deltaTime - Delta time in ms
+ * @return {ChainableUtil}
+ */
+export const damp: typeof numberUtils.damp & ChainedDamp;
+export type UtilityFunction = (...args: any[]) => number | string;
+export type ChainablesMap = {
+    clamp: ChainedClamp;
+    round: ChainedRound;
+    snap: ChainedSnap;
+    wrap: ChainedWrap;
+    lerp: ChainedLerp;
+    damp: ChainedDamp;
+    mapRange: ChainedMapRange;
+    roundPad: ChainedRoundPad;
+    padStart: ChainedPadStart;
+    padEnd: ChainedPadEnd;
+    degToRad: ChainedDegToRad;
+    radToDeg: ChainedRadToDeg;
+};
+export type ChainedUtilsResult = (value: number) => number;
+export type ChainableUtil = ChainablesMap & ChainedUtilsResult;
+export type ChainedRoundPad = (decimalLength: number) => ChainableUtil;
+export type ChainedPadStart = (totalLength: number, padString: string) => ChainableUtil;
+export type ChainedPadEnd = (totalLength: number, padString: string) => ChainableUtil;
+export type ChainedWrap = (min: number, max: number) => ChainableUtil;
+export type ChainedMapRange = (inLow: number, inHigh: number, outLow: number, outHigh: number) => ChainableUtil;
+export type ChainedDegToRad = () => ChainableUtil;
+export type ChainedRadToDeg = () => ChainableUtil;
+export type ChainedSnap = (increment: number | Array<number>) => ChainableUtil;
+export type ChainedClamp = (min: number, max: number) => ChainableUtil;
+export type ChainedRound = (decimalLength: number) => ChainableUtil;
+export type ChainedLerp = (start: number, end: number) => ChainableUtil;
+export type ChainedDamp = (start: number, end: number, deltaTime: number) => ChainableUtil;
+declare const numberUtils: typeof numberImports;
+import * as numberImports from './number.js';
+export {};

package/dist/modules/utils/chainable.js

@@ -0,0 +1,177 @@
+/**
+ * Anime.js - utils - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+import { noop } from '../core/consts.js';
+import * as number from './number.js';
+
+// Chain-able utilities
+
+const numberUtils = number; // Needed to keep the import when bundling
+
+const chainables = {};
+
+/**
+ * @callback UtilityFunction
+ * @param {...*} args
+ * @return {Number|String}
+ *
+ * @param {UtilityFunction} fn
+ * @param {Number} [last=0]
+ * @return {function(...(Number|String)): function(Number|String): (Number|String)}
+ */
+const curry = (fn, last = 0) => (...args) => last ? v => fn(...args, v) : v => fn(v, ...args);
+
+/**
+ * @param {Function} fn
+ * @return {function(...(Number|String))}
+ */
+const chain = fn => {
+   return (...args) => {
+    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));
+      })
+    });
+  }
+};
+
+/**
+ * @param {UtilityFunction} fn
+ * @param {String} name
+ * @param {Number} [right]
+ * @return {function(...(Number|String)): UtilityFunction}
+ */
+const makeChainable = (name, fn, right = 0) => {
+  const chained = (...args) => (args.length < fn.length ? chain(curry(fn, right)) : fn)(...args);
+  if (!chainables[name]) chainables[name] = chained;
+  return chained;
+};
+
+/**
+ * @typedef {Object} ChainablesMap
+ * @property {ChainedClamp} clamp
+ * @property {ChainedRound} round
+ * @property {ChainedSnap} snap
+ * @property {ChainedWrap} wrap
+ * @property {ChainedLerp} lerp
+ * @property {ChainedDamp} damp
+ * @property {ChainedMapRange} mapRange
+ * @property {ChainedRoundPad} roundPad
+ * @property {ChainedPadStart} padStart
+ * @property {ChainedPadEnd} padEnd
+ * @property {ChainedDegToRad} degToRad
+ * @property {ChainedRadToDeg} radToDeg
+ */
+
+/**
+ * @callback ChainedUtilsResult
+ * @param {Number} value - The value to process through the chained operations
+ * @return {Number} The processed result
+ */
+
+/**
+ * @typedef {ChainablesMap & ChainedUtilsResult} ChainableUtil
+ */
+
+// Chainable
+
+/**
+ * @callback ChainedRoundPad
+ * @param {Number} decimalLength - Number of decimal places
+ * @return {ChainableUtil}
+ */
+const roundPad = /** @type {typeof numberUtils.roundPad & ChainedRoundPad} */(makeChainable('roundPad', numberUtils.roundPad));
+
+/**
+ * @callback ChainedPadStart
+ * @param {Number} totalLength - Target length
+ * @param {String} padString - String to pad with
+ * @return {ChainableUtil}
+ */
+const padStart = /** @type {typeof numberUtils.padStart & ChainedPadStart} */(makeChainable('padStart', numberUtils.padStart));
+
+/**
+ * @callback ChainedPadEnd
+ * @param {Number} totalLength - Target length
+ * @param {String} padString - String to pad with
+ * @return {ChainableUtil}
+ */
+const padEnd = /** @type {typeof numberUtils.padEnd & ChainedPadEnd} */(makeChainable('padEnd', numberUtils.padEnd));
+
+/**
+ * @callback ChainedWrap
+ * @param {Number} min - Minimum boundary
+ * @param {Number} max - Maximum boundary
+ * @return {ChainableUtil}
+ */
+const wrap = /** @type {typeof numberUtils.wrap & ChainedWrap} */(makeChainable('wrap', numberUtils.wrap));
+
+/**
+ * @callback ChainedMapRange
+ * @param {Number} inLow - Input range minimum
+ * @param {Number} inHigh - Input range maximum
+ * @param {Number} outLow - Output range minimum
+ * @param {Number} outHigh - Output range maximum
+ * @return {ChainableUtil}
+ */
+const mapRange = /** @type {typeof numberUtils.mapRange & ChainedMapRange} */(makeChainable('mapRange', numberUtils.mapRange));
+
+/**
+ * @callback ChainedDegToRad
+ * @return {ChainableUtil}
+ */
+const degToRad = /** @type {typeof numberUtils.degToRad & ChainedDegToRad} */(makeChainable('degToRad', numberUtils.degToRad));
+
+/**
+ * @callback ChainedRadToDeg
+ * @return {ChainableUtil}
+ */
+const radToDeg = /** @type {typeof numberUtils.radToDeg & ChainedRadToDeg} */(makeChainable('radToDeg', numberUtils.radToDeg));
+
+/**
+ * @callback ChainedSnap
+ * @param {Number|Array<Number>} increment - Step size or array of snap points
+ * @return {ChainableUtil}
+ */
+const snap = /** @type {typeof numberUtils.snap & ChainedSnap} */(makeChainable('snap', numberUtils.snap));
+
+/**
+ * @callback ChainedClamp
+ * @param {Number} min - Minimum boundary
+ * @param {Number} max - Maximum boundary
+ * @return {ChainableUtil}
+ */
+const clamp = /** @type {typeof numberUtils.clamp & ChainedClamp} */(makeChainable('clamp', numberUtils.clamp));
+
+/**
+ * @callback ChainedRound
+ * @param {Number} decimalLength - Number of decimal places
+ * @return {ChainableUtil}
+ */
+const round = /** @type {typeof numberUtils.round & ChainedRound} */(makeChainable('round', numberUtils.round));
+
+/**
+ * @callback ChainedLerp
+ * @param {Number} start - Starting value
+ * @param {Number} end - Ending value
+ * @return {ChainableUtil}
+ */
+const lerp = /** @type {typeof numberUtils.lerp & ChainedLerp} */(makeChainable('lerp', numberUtils.lerp, 1));
+
+/**
+ * @callback ChainedDamp
+ * @param {Number} start - Starting value
+ * @param {Number} end - Target value
+ * @param {Number} deltaTime - Delta time in ms
+ * @return {ChainableUtil}
+ */
+const damp = /** @type {typeof numberUtils.damp & ChainedDamp} */(makeChainable('damp', numberUtils.damp, 1));
+
+export { clamp, damp, degToRad, lerp, mapRange, padEnd, padStart, radToDeg, round, roundPad, snap, wrap };

package/dist/modules/utils/index.cjs

@@ -0,0 +1,43 @@
+/**
+ * Anime.js - utils - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var chainable = require('./chainable.cjs');
+var random = require('./random.cjs');
+var time = require('./time.cjs');
+var target = require('./target.cjs');
+var stagger = require('./stagger.cjs');
+var styles = require('../core/styles.cjs');
+var targets = require('../core/targets.cjs');
+
+
+
+exports.clamp = chainable.clamp;
+exports.damp = chainable.damp;
+exports.degToRad = chainable.degToRad;
+exports.lerp = chainable.lerp;
+exports.mapRange = chainable.mapRange;
+exports.padEnd = chainable.padEnd;
+exports.padStart = chainable.padStart;
+exports.radToDeg = chainable.radToDeg;
+exports.round = chainable.round;
+exports.roundPad = chainable.roundPad;
+exports.snap = chainable.snap;
+exports.wrap = chainable.wrap;
+exports.createSeededRandom = random.createSeededRandom;
+exports.random = random.random;
+exports.randomPick = random.randomPick;
+exports.shuffle = random.shuffle;
+exports.keepTime = time.keepTime;
+exports.sync = time.sync;
+exports.get = target.get;
+exports.remove = target.remove;
+exports.set = target.set;
+exports.stagger = stagger.stagger;
+exports.cleanInlineStyles = styles.cleanInlineStyles;
+exports.$ = targets.registerTargets;

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

@@ -0,0 +1,5 @@
+export * from "./chainable.js";
+export * from "./random.js";
+export * from "./time.js";
+export * from "./target.js";
+export * from "./stagger.js";

package/dist/modules/utils/index.js

@@ -0,0 +1,14 @@
+/**
+ * Anime.js - utils - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+export { clamp, damp, degToRad, lerp, mapRange, padEnd, padStart, radToDeg, round, roundPad, snap, wrap } from './chainable.js';
+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 { cleanInlineStyles } from '../core/styles.js';
+export { registerTargets as $ } from '../core/targets.js';

package/dist/modules/utils/number.cjs

@@ -0,0 +1,97 @@
+/**
+ * Anime.js - utils - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var helpers = require('../core/helpers.cjs');
+
+/**
+ * Rounds a number to fixed decimal places
+ * @param  {Number|String} v - Value to round
+ * @param  {Number} decimalLength - Number of decimal places
+ * @return {String}
+ */
+const roundPad = (v, decimalLength) => (+v).toFixed(decimalLength);
+
+/**
+ * Pads the start of a value with a string
+ * @param  {Number} v - Value to pad
+ * @param  {Number} totalLength - Target length
+ * @param  {String} padString - String to pad with
+ * @return {String}
+ */
+const padStart = (v, totalLength, padString) => `${v}`.padStart(totalLength, padString);
+
+/**
+ * Pads the end of a value with a string
+ * @param  {Number} v - Value to pad
+ * @param  {Number} totalLength - Target length
+ * @param  {String} padString - String to pad with
+ * @return {String}
+ */
+const padEnd = (v, totalLength, padString) => `${v}`.padEnd(totalLength, padString);
+
+/**
+ * Wraps a value within a range
+ * @param  {Number} v - Value to wrap
+ * @param  {Number} min - Minimum boundary
+ * @param  {Number} max - Maximum boundary
+ * @return {Number}
+ */
+const wrap = (v, min, max) => (((v - min) % (max - min) + (max - min)) % (max - min)) + min;
+
+/**
+ * Maps a value from one range to another
+ * @param  {Number} value - Input value
+ * @param  {Number} inLow - Input range minimum
+ * @param  {Number} inHigh - Input range maximum
+ * @param  {Number} outLow - Output range minimum
+ * @param  {Number} outHigh - Output range maximum
+ * @return {Number}
+ */
+const mapRange = (value, inLow, inHigh, outLow, outHigh) => outLow + ((value - inLow) / (inHigh - inLow)) * (outHigh - outLow);
+
+/**
+ * Converts degrees to radians
+ * @param  {Number} degrees - Angle in degrees
+ * @return {Number}
+ */
+const degToRad = degrees => degrees * Math.PI / 180;
+
+/**
+ * Converts radians to degrees
+ * @param  {Number} radians - Angle in radians
+ * @return {Number}
+ */
+const radToDeg = radians => radians * 180 / Math.PI;
+
+/**
+ * Frame rate independent damped lerp
+ * Based on: https://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
+ *
+ * @param  {Number} start - Starting value
+ * @param  {Number} end - Target value
+ * @param  {Number} deltaTime - Delta time in ms
+ * @param  {Number} factor - Interpolation factor in the range [0, 1]
+ * @return {Number} The interpolated value
+ */
+const damp = (start, end, deltaTime, factor) => {
+  return !factor ? start : factor === 1 ? end : helpers.lerp(start, end, 1 - Math.exp(-factor * deltaTime * .1));
+};
+
+exports.clamp = helpers.clamp;
+exports.lerp = helpers.lerp;
+exports.round = helpers.round;
+exports.snap = helpers.snap;
+exports.damp = damp;
+exports.degToRad = degToRad;
+exports.mapRange = mapRange;
+exports.padEnd = padEnd;
+exports.padStart = padStart;
+exports.radToDeg = radToDeg;
+exports.roundPad = roundPad;
+exports.wrap = wrap;

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

@@ -0,0 +1,9 @@
+export function roundPad(v: number | string, decimalLength: number): string;
+export function padStart(v: number, totalLength: number, padString: string): string;
+export function padEnd(v: number, totalLength: number, padString: string): string;
+export function wrap(v: number, min: number, max: number): number;
+export function mapRange(value: number, inLow: number, inHigh: number, outLow: number, outHigh: number): number;
+export function degToRad(degrees: number): number;
+export function radToDeg(radians: number): number;
+export function damp(start: number, end: number, deltaTime: number, factor: number): number;
+export { snap, clamp, round, lerp } from "../core/helpers.js";

package/dist/modules/utils/number.js

@@ -0,0 +1,85 @@
+/**
+ * Anime.js - utils - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+import { lerp } from '../core/helpers.js';
+export { clamp, round, snap } from '../core/helpers.js';
+
+/**
+ * Rounds a number to fixed decimal places
+ * @param  {Number|String} v - Value to round
+ * @param  {Number} decimalLength - Number of decimal places
+ * @return {String}
+ */
+const roundPad = (v, decimalLength) => (+v).toFixed(decimalLength);
+
+/**
+ * Pads the start of a value with a string
+ * @param  {Number} v - Value to pad
+ * @param  {Number} totalLength - Target length
+ * @param  {String} padString - String to pad with
+ * @return {String}
+ */
+const padStart = (v, totalLength, padString) => `${v}`.padStart(totalLength, padString);
+
+/**
+ * Pads the end of a value with a string
+ * @param  {Number} v - Value to pad
+ * @param  {Number} totalLength - Target length
+ * @param  {String} padString - String to pad with
+ * @return {String}
+ */
+const padEnd = (v, totalLength, padString) => `${v}`.padEnd(totalLength, padString);
+
+/**
+ * Wraps a value within a range
+ * @param  {Number} v - Value to wrap
+ * @param  {Number} min - Minimum boundary
+ * @param  {Number} max - Maximum boundary
+ * @return {Number}
+ */
+const wrap = (v, min, max) => (((v - min) % (max - min) + (max - min)) % (max - min)) + min;
+
+/**
+ * Maps a value from one range to another
+ * @param  {Number} value - Input value
+ * @param  {Number} inLow - Input range minimum
+ * @param  {Number} inHigh - Input range maximum
+ * @param  {Number} outLow - Output range minimum
+ * @param  {Number} outHigh - Output range maximum
+ * @return {Number}
+ */
+const mapRange = (value, inLow, inHigh, outLow, outHigh) => outLow + ((value - inLow) / (inHigh - inLow)) * (outHigh - outLow);
+
+/**
+ * Converts degrees to radians
+ * @param  {Number} degrees - Angle in degrees
+ * @return {Number}
+ */
+const degToRad = degrees => degrees * Math.PI / 180;
+
+/**
+ * Converts radians to degrees
+ * @param  {Number} radians - Angle in radians
+ * @return {Number}
+ */
+const radToDeg = radians => radians * 180 / Math.PI;
+
+/**
+ * Frame rate independent damped lerp
+ * Based on: https://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
+ *
+ * @param  {Number} start - Starting value
+ * @param  {Number} end - Target value
+ * @param  {Number} deltaTime - Delta time in ms
+ * @param  {Number} factor - Interpolation factor in the range [0, 1]
+ * @return {Number} The interpolated value
+ */
+const damp = (start, end, deltaTime, factor) => {
+  return !factor ? start : factor === 1 ? end : lerp(start, end, 1 - Math.exp(-factor * deltaTime * .1));
+};
+
+export { damp, degToRad, lerp, mapRange, padEnd, padStart, radToDeg, roundPad, wrap };

package/dist/modules/utils/random.cjs

@@ -0,0 +1,77 @@
+/**
+ * Anime.js - utils - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+/**
+ * Generate a random number between optional min and max (inclusive) and decimal precision
+ *
+ * @callback RandomNumberGenerator
+ * @param    {Number} [min=0] - The minimum value (inclusive)
+ * @param    {Number} [max=1] - The maximum value (inclusive)
+ * @param    {Number} [decimalLength=0] - Number of decimal places to round to
+ * @return   {Number} A random number between min and max
+ */
+
+/**
+ * Generates a random number between min and max (inclusive) with optional decimal precision
+ *
+ * @type {RandomNumberGenerator}
+ */
+const random = (min = 0, max = 1, decimalLength = 0) => {
+  const m = 10 ** decimalLength;
+  return Math.floor((Math.random() * (max - min + (1 / m)) + min) * m) / m;
+};
+
+let _seed = 0;
+
+/**
+ * Creates a seeded pseudorandom number generator function
+ *
+ * @param  {Number} [seed] - The seed value for the random number generator
+ * @param  {Number} [seededMin=0] - The minimum default value (inclusive) of the returned function
+ * @param  {Number} [seededMax=1] - The maximum default value (inclusive) of the returned function
+ * @param  {Number} [seededDecimalLength=0] - Default number of decimal places to round to of the returned function
+ * @return {RandomNumberGenerator} A function to generate a random number between optional min and max (inclusive) and decimal precision
+ */
+const createSeededRandom = (seed, seededMin = 0, seededMax = 1, seededDecimalLength = 0) => {
+  let t = seed === undefined ? _seed++ : seed;
+  return (min = seededMin, max = seededMax, decimalLength = seededDecimalLength) => {
+    t += 0x6D2B79F5;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    const m = 10 ** decimalLength;
+    return Math.floor(((((t ^ t >>> 14) >>> 0) / 4294967296) * (max - min + (1 / m)) + min) * m) / m;
+  }
+};
+
+/**
+ * Picks a random element from an array or a string
+ *
+ * @template T
+ * @param    {String|Array<T>} items - The array or string to pick from
+ * @return   {String|T} A random element from the array or character from the string
+ */
+const randomPick = items => items[random(0, items.length - 1)];
+
+/**
+ * Shuffles an array in-place using the Fisher-Yates algorithm
+ * Adapted from https://bost.ocks.org/mike/shuffle/
+ *
+ * @param  {Array} items - The array to shuffle (will be modified in-place)
+ * @return {Array} The same array reference, now shuffled
+ */
+const shuffle = items => {
+  let m = items.length, t, i;
+  while (m) { i = random(0, --m); t = items[m]; items[m] = items[i]; items[i] = t; }
+  return items;
+};
+
+exports.createSeededRandom = createSeededRandom;
+exports.random = random;
+exports.randomPick = randomPick;
+exports.shuffle = shuffle;

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

@@ -0,0 +1,22 @@
+/**
+ * Generate a random number between optional min and max (inclusive) and decimal precision
+ *
+ * @callback RandomNumberGenerator
+ * @param    {Number} [min=0] - The minimum value (inclusive)
+ * @param    {Number} [max=1] - The maximum value (inclusive)
+ * @param    {Number} [decimalLength=0] - Number of decimal places to round to
+ * @return   {Number} A random number between min and max
+ */
+/**
+ * Generates a random number between min and max (inclusive) with optional decimal precision
+ *
+ * @type {RandomNumberGenerator}
+ */
+export const random: RandomNumberGenerator;
+export function createSeededRandom(seed?: number, seededMin?: number, seededMax?: number, seededDecimalLength?: number): RandomNumberGenerator;
+export function randomPick<T>(items: string | Array<T>): string | T;
+export function shuffle(items: any[]): any[];
+/**
+ * Generate a random number between optional min and max (inclusive) and decimal precision
+ */
+export type RandomNumberGenerator = (min?: number, max?: number, decimalLength?: number) => number;