animejs 4.1.2 → 4.2.0-beta.0

package/dist/modules/draggable/index.cjs

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

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

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

package/dist/modules/draggable/index.js

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

package/dist/modules/easings/cubic-bezier.cjs

@@ -0,0 +1,64 @@
+/**
+ * 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,
+ * } from '../types/index.js'
+*/
+
+/**
+ * Cubic Bezier solver adapted from https://github.com/gre/bezier-easing
+ * (c) 2014 Gaëtan Renaudeau
+ */
+
+/**
+ * @param  {Number} aT
+ * @param  {Number} aA1
+ * @param  {Number} aA2
+ * @return {Number}
+ */
+const calcBezier = (aT, aA1, aA2) => (((1 - 3 * aA2 + 3 * aA1) * aT + (3 * aA2 - 6 * aA1)) * aT + (3 * aA1)) * aT;
+
+/**
+ * @param  {Number} aX
+ * @param  {Number} mX1
+ * @param  {Number} mX2
+ * @return {Number}
+ */
+const binarySubdivide = (aX, mX1, mX2) => {
+  let aA = 0, aB = 1, currentX, currentT, i = 0;
+  do {
+    currentT = aA + (aB - aA) / 2;
+    currentX = calcBezier(currentT, mX1, mX2) - aX;
+    if (currentX > 0) {
+      aB = currentT;
+    } else {
+      aA = currentT;
+    }
+  } while (helpers.abs(currentX) > .0000001 && ++i < 100);
+  return currentT;
+};
+
+/**
+ * @param  {Number} [mX1] The x coordinate of the first point
+ * @param  {Number} [mY1] The y coordinate of the first point
+ * @param  {Number} [mX2] The x coordinate of the second point
+ * @param  {Number} [mY2] The y coordinate of the second point
+ * @return {EasingFunction}
+ */
+
+const cubicBezier = (mX1 = 0.5, mY1 = 0.0, mX2 = 0.5, mY2 = 1.0) => (mX1 === mY1 && mX2 === mY2) ? none.none :
+  t => t === 0 || t === 1 ? t :
+  calcBezier(binarySubdivide(t, mX1, mX2), mY1, mY2);
+
+exports.cubicBezier = cubicBezier;

package/dist/modules/easings/cubic-bezier.d.ts

@@ -0,0 +1,2 @@
+export function cubicBezier(mX1?: number, mY1?: number, mX2?: number, mY2?: number): EasingFunction;
+import type { EasingFunction } from '../types/index.js';

package/dist/modules/easings/cubic-bezier.js

@@ -0,0 +1,62 @@
+/**
+ * Anime.js - easings - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+import { abs } from '../core/helpers.js';
+import { none } from './none.js';
+
+/**
+ * @import {
+ *   EasingFunction,
+ * } from '../types/index.js'
+*/
+
+/**
+ * Cubic Bezier solver adapted from https://github.com/gre/bezier-easing
+ * (c) 2014 Gaëtan Renaudeau
+ */
+
+/**
+ * @param  {Number} aT
+ * @param  {Number} aA1
+ * @param  {Number} aA2
+ * @return {Number}
+ */
+const calcBezier = (aT, aA1, aA2) => (((1 - 3 * aA2 + 3 * aA1) * aT + (3 * aA2 - 6 * aA1)) * aT + (3 * aA1)) * aT;
+
+/**
+ * @param  {Number} aX
+ * @param  {Number} mX1
+ * @param  {Number} mX2
+ * @return {Number}
+ */
+const binarySubdivide = (aX, mX1, mX2) => {
+  let aA = 0, aB = 1, currentX, currentT, i = 0;
+  do {
+    currentT = aA + (aB - aA) / 2;
+    currentX = calcBezier(currentT, mX1, mX2) - aX;
+    if (currentX > 0) {
+      aB = currentT;
+    } else {
+      aA = currentT;
+    }
+  } while (abs(currentX) > .0000001 && ++i < 100);
+  return currentT;
+};
+
+/**
+ * @param  {Number} [mX1] The x coordinate of the first point
+ * @param  {Number} [mY1] The y coordinate of the first point
+ * @param  {Number} [mX2] The x coordinate of the second point
+ * @param  {Number} [mY2] The y coordinate of the second point
+ * @return {EasingFunction}
+ */
+
+const cubicBezier = (mX1 = 0.5, mY1 = 0.0, mX2 = 0.5, mY2 = 1.0) => (mX1 === mY1 && mX2 === mY2) ? none :
+  t => t === 0 || t === 1 ? t :
+  calcBezier(binarySubdivide(t, mX1, mX2), mY1, mY2);
+
+export { cubicBezier };

package/dist/modules/easings/eases.cjs

@@ -0,0 +1,149 @@
+/**
+ * Anime.js - easings - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var consts = require('../core/consts.cjs');
+var helpers = require('../core/helpers.cjs');
+var parser = require('./parser.cjs');
+var none = require('./none.cjs');
+var cubicBezier = require('./cubic-bezier.cjs');
+var steps = require('./steps.cjs');
+var linear = require('./linear.cjs');
+var irregular = require('./irregular.cjs');
+
+/**
+ * @import {
+ *   EasingFunction,
+ *   EasingFunctionWithParams,
+ *   EasingParam,
+ *   BackEasing,
+ *   ElasticEasing,
+ *   PowerEasing,
+ * } from '../types/index.js'
+*/
+
+/**
+ * Easing functions adapted and simplified from https://robertpenner.com/easing/
+ * (c) 2001 Robert Penner
+ */
+
+const halfPI = helpers.PI / 2;
+const doublePI = helpers.PI * 2;
+
+/** @type {Record<String, EasingFunctionWithParams|EasingFunction>} */
+const easeInFunctions = {
+  [consts.emptyString]: parser.easeInPower,
+  Quad: parser.easeInPower(2),
+  Cubic: parser.easeInPower(3),
+  Quart: parser.easeInPower(4),
+  Quint: parser.easeInPower(5),
+  /** @type {EasingFunction} */
+  Sine: t => 1 - helpers.cos(t * halfPI),
+  /** @type {EasingFunction} */
+  Circ: t => 1 - helpers.sqrt(1 - t * t),
+  /** @type {EasingFunction} */
+  Expo: t => t ? helpers.pow(2, 10 * t - 10) : 0,
+  /** @type {EasingFunction} */
+  Bounce: t => {
+    let pow2, b = 4;
+    while (t < ((pow2 = helpers.pow(2, --b)) - 1) / 11);
+    return 1 / helpers.pow(4, 3 - b) - 7.5625 * helpers.pow((pow2 * 3 - 2) / 22 - t, 2);
+  },
+  /** @type {BackEasing} */
+  Back: (overshoot = 1.70158) => t => (+overshoot + 1) * t * t * t - +overshoot * t * t,
+  /** @type {ElasticEasing} */
+  Elastic: (amplitude = 1, period = .3) => {
+    const a = helpers.clamp(+amplitude, 1, 10);
+    const p = helpers.clamp(+period, consts.minValue, 2);
+    const s = (p / doublePI) * helpers.asin(1 / a);
+    const e = doublePI / p;
+    return t => t === 0 || t === 1 ? t : -a * helpers.pow(2, -10 * (1 - t)) * helpers.sin(((1 - t) - s) * e);
+  }
+};
+
+/**
+ * @typedef  {Object} EasesFunctions
+ * @property {typeof linear} linear
+ * @property {typeof irregular} irregular
+ * @property {typeof steps} steps
+ * @property {typeof cubicBezier} cubicBezier
+ * @property {PowerEasing} in
+ * @property {PowerEasing} out
+ * @property {PowerEasing} inOut
+ * @property {PowerEasing} outIn
+ * @property {EasingFunction} inQuad
+ * @property {EasingFunction} outQuad
+ * @property {EasingFunction} inOutQuad
+ * @property {EasingFunction} outInQuad
+ * @property {EasingFunction} inCubic
+ * @property {EasingFunction} outCubic
+ * @property {EasingFunction} inOutCubic
+ * @property {EasingFunction} outInCubic
+ * @property {EasingFunction} inQuart
+ * @property {EasingFunction} outQuart
+ * @property {EasingFunction} inOutQuart
+ * @property {EasingFunction} outInQuart
+ * @property {EasingFunction} inQuint
+ * @property {EasingFunction} outQuint
+ * @property {EasingFunction} inOutQuint
+ * @property {EasingFunction} outInQuint
+ * @property {EasingFunction} inSine
+ * @property {EasingFunction} outSine
+ * @property {EasingFunction} inOutSine
+ * @property {EasingFunction} outInSine
+ * @property {EasingFunction} inCirc
+ * @property {EasingFunction} outCirc
+ * @property {EasingFunction} inOutCirc
+ * @property {EasingFunction} outInCirc
+ * @property {EasingFunction} inExpo
+ * @property {EasingFunction} outExpo
+ * @property {EasingFunction} inOutExpo
+ * @property {EasingFunction} outInExpo
+ * @property {EasingFunction} inBounce
+ * @property {EasingFunction} outBounce
+ * @property {EasingFunction} inOutBounce
+ * @property {EasingFunction} outInBounce
+ * @property {BackEasing} inBack
+ * @property {BackEasing} outBack
+ * @property {BackEasing} inOutBack
+ * @property {BackEasing} outInBack
+ * @property {ElasticEasing} inElastic
+ * @property {ElasticEasing} outElastic
+ * @property {ElasticEasing} inOutElastic
+ * @property {ElasticEasing} outInElastic
+ */
+
+const eases = (/*#__PURE__ */ (() => {
+  const list = { linear: linear.linear, irregular: irregular.irregular, steps: steps.steps, cubicBezier: cubicBezier.cubicBezier };
+  for (let type in parser.easeTypes) {
+    for (let name in easeInFunctions) {
+      const easeIn = easeInFunctions[name];
+      const easeType = parser.easeTypes[type];
+      list[type + name] = /** @type {EasingFunctionWithParams|EasingFunction} */(
+        name === consts.emptyString || name === 'Back' || name === 'Elastic' ?
+        (a, b) => easeType(/** @type {EasingFunctionWithParams} */(easeIn)(a, b)) :
+        easeType(/** @type {EasingFunction} */(easeIn))
+      );
+    }
+  }
+  return /** @type {EasesFunctions} */(list);
+})());
+
+/** @type {Record<String, EasingFunction>} */
+const JSEasesLookups = { linear: none.none };
+
+/**
+ * @param  {EasingParam} ease
+ * @return {EasingFunction}
+ */
+const parseEase = ease => helpers.isFnc(ease) ? ease :
+  helpers.isStr(ease) ? parser.parseEaseString(/** @type {String} */(ease), eases, JSEasesLookups) :
+  none.none;
+
+exports.eases = eases;
+exports.parseEase = parseEase;

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

@@ -0,0 +1,111 @@
+export namespace eases {
+    export let linear: typeof import("./linear.js").linear;
+    export let irregular: typeof import("./irregular.js").irregular;
+    export let steps: typeof import("./steps.js").steps;
+    export let cubicBezier: typeof import("./cubic-bezier.js").cubicBezier;
+    let _in: PowerEasing;
+    export { _in as in };
+    export let out: PowerEasing;
+    export let inOut: PowerEasing;
+    export let outIn: PowerEasing;
+    export let inQuad: EasingFunction;
+    export let outQuad: EasingFunction;
+    export let inOutQuad: EasingFunction;
+    export let outInQuad: EasingFunction;
+    export let inCubic: EasingFunction;
+    export let outCubic: EasingFunction;
+    export let inOutCubic: EasingFunction;
+    export let outInCubic: EasingFunction;
+    export let inQuart: EasingFunction;
+    export let outQuart: EasingFunction;
+    export let inOutQuart: EasingFunction;
+    export let outInQuart: EasingFunction;
+    export let inQuint: EasingFunction;
+    export let outQuint: EasingFunction;
+    export let inOutQuint: EasingFunction;
+    export let outInQuint: EasingFunction;
+    export let inSine: EasingFunction;
+    export let outSine: EasingFunction;
+    export let inOutSine: EasingFunction;
+    export let outInSine: EasingFunction;
+    export let inCirc: EasingFunction;
+    export let outCirc: EasingFunction;
+    export let inOutCirc: EasingFunction;
+    export let outInCirc: EasingFunction;
+    export let inExpo: EasingFunction;
+    export let outExpo: EasingFunction;
+    export let inOutExpo: EasingFunction;
+    export let outInExpo: EasingFunction;
+    export let inBounce: EasingFunction;
+    export let outBounce: EasingFunction;
+    export let inOutBounce: EasingFunction;
+    export let outInBounce: EasingFunction;
+    export let inBack: BackEasing;
+    export let outBack: BackEasing;
+    export let inOutBack: BackEasing;
+    export let outInBack: BackEasing;
+    export let inElastic: ElasticEasing;
+    export let outElastic: ElasticEasing;
+    export let inOutElastic: ElasticEasing;
+    export let outInElastic: ElasticEasing;
+}
+export function parseEase(ease: EasingParam): EasingFunction;
+export type EasesFunctions = {
+    linear: typeof linear;
+    irregular: typeof irregular;
+    steps: typeof steps;
+    cubicBezier: typeof cubicBezier;
+    in: PowerEasing;
+    out: PowerEasing;
+    inOut: PowerEasing;
+    outIn: PowerEasing;
+    inQuad: EasingFunction;
+    outQuad: EasingFunction;
+    inOutQuad: EasingFunction;
+    outInQuad: EasingFunction;
+    inCubic: EasingFunction;
+    outCubic: EasingFunction;
+    inOutCubic: EasingFunction;
+    outInCubic: EasingFunction;
+    inQuart: EasingFunction;
+    outQuart: EasingFunction;
+    inOutQuart: EasingFunction;
+    outInQuart: EasingFunction;
+    inQuint: EasingFunction;
+    outQuint: EasingFunction;
+    inOutQuint: EasingFunction;
+    outInQuint: EasingFunction;
+    inSine: EasingFunction;
+    outSine: EasingFunction;
+    inOutSine: EasingFunction;
+    outInSine: EasingFunction;
+    inCirc: EasingFunction;
+    outCirc: EasingFunction;
+    inOutCirc: EasingFunction;
+    outInCirc: EasingFunction;
+    inExpo: EasingFunction;
+    outExpo: EasingFunction;
+    inOutExpo: EasingFunction;
+    outInExpo: EasingFunction;
+    inBounce: EasingFunction;
+    outBounce: EasingFunction;
+    inOutBounce: EasingFunction;
+    outInBounce: EasingFunction;
+    inBack: BackEasing;
+    outBack: BackEasing;
+    inOutBack: BackEasing;
+    outInBack: BackEasing;
+    inElastic: ElasticEasing;
+    outElastic: ElasticEasing;
+    inOutElastic: ElasticEasing;
+    outInElastic: ElasticEasing;
+};
+import type { PowerEasing } from '../types/index.js';
+import type { EasingFunction } from '../types/index.js';
+import type { BackEasing } from '../types/index.js';
+import type { ElasticEasing } from '../types/index.js';
+import type { EasingParam } from '../types/index.js';
+import { linear as linear_1 } from './linear.js';
+import { irregular as irregular_1 } from './irregular.js';
+import { steps as steps_1 } from './steps.js';
+import { cubicBezier as cubicBezier_1 } from './cubic-bezier.js';

package/dist/modules/easings/eases.js

@@ -0,0 +1,146 @@
+/**
+ * Anime.js - easings - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+import { emptyString, minValue } from '../core/consts.js';
+import { pow, sin, sqrt, cos, isFnc, isStr, clamp, asin, PI } from '../core/helpers.js';
+import { easeTypes, easeInPower, parseEaseString } from './parser.js';
+import { none } from './none.js';
+import { cubicBezier } from './cubic-bezier.js';
+import { steps } from './steps.js';
+import { linear } from './linear.js';
+import { irregular } from './irregular.js';
+
+/**
+ * @import {
+ *   EasingFunction,
+ *   EasingFunctionWithParams,
+ *   EasingParam,
+ *   BackEasing,
+ *   ElasticEasing,
+ *   PowerEasing,
+ * } from '../types/index.js'
+*/
+
+/**
+ * Easing functions adapted and simplified from https://robertpenner.com/easing/
+ * (c) 2001 Robert Penner
+ */
+
+const halfPI = PI / 2;
+const doublePI = PI * 2;
+
+/** @type {Record<String, EasingFunctionWithParams|EasingFunction>} */
+const easeInFunctions = {
+  [emptyString]: easeInPower,
+  Quad: easeInPower(2),
+  Cubic: easeInPower(3),
+  Quart: easeInPower(4),
+  Quint: easeInPower(5),
+  /** @type {EasingFunction} */
+  Sine: t => 1 - cos(t * halfPI),
+  /** @type {EasingFunction} */
+  Circ: t => 1 - sqrt(1 - t * t),
+  /** @type {EasingFunction} */
+  Expo: t => t ? pow(2, 10 * t - 10) : 0,
+  /** @type {EasingFunction} */
+  Bounce: t => {
+    let pow2, b = 4;
+    while (t < ((pow2 = pow(2, --b)) - 1) / 11);
+    return 1 / pow(4, 3 - b) - 7.5625 * pow((pow2 * 3 - 2) / 22 - t, 2);
+  },
+  /** @type {BackEasing} */
+  Back: (overshoot = 1.70158) => t => (+overshoot + 1) * t * t * t - +overshoot * t * t,
+  /** @type {ElasticEasing} */
+  Elastic: (amplitude = 1, period = .3) => {
+    const a = clamp(+amplitude, 1, 10);
+    const p = clamp(+period, minValue, 2);
+    const s = (p / doublePI) * asin(1 / a);
+    const e = doublePI / p;
+    return t => t === 0 || t === 1 ? t : -a * pow(2, -10 * (1 - t)) * sin(((1 - t) - s) * e);
+  }
+};
+
+/**
+ * @typedef  {Object} EasesFunctions
+ * @property {typeof linear} linear
+ * @property {typeof irregular} irregular
+ * @property {typeof steps} steps
+ * @property {typeof cubicBezier} cubicBezier
+ * @property {PowerEasing} in
+ * @property {PowerEasing} out
+ * @property {PowerEasing} inOut
+ * @property {PowerEasing} outIn
+ * @property {EasingFunction} inQuad
+ * @property {EasingFunction} outQuad
+ * @property {EasingFunction} inOutQuad
+ * @property {EasingFunction} outInQuad
+ * @property {EasingFunction} inCubic
+ * @property {EasingFunction} outCubic
+ * @property {EasingFunction} inOutCubic
+ * @property {EasingFunction} outInCubic
+ * @property {EasingFunction} inQuart
+ * @property {EasingFunction} outQuart
+ * @property {EasingFunction} inOutQuart
+ * @property {EasingFunction} outInQuart
+ * @property {EasingFunction} inQuint
+ * @property {EasingFunction} outQuint
+ * @property {EasingFunction} inOutQuint
+ * @property {EasingFunction} outInQuint
+ * @property {EasingFunction} inSine
+ * @property {EasingFunction} outSine
+ * @property {EasingFunction} inOutSine
+ * @property {EasingFunction} outInSine
+ * @property {EasingFunction} inCirc
+ * @property {EasingFunction} outCirc
+ * @property {EasingFunction} inOutCirc
+ * @property {EasingFunction} outInCirc
+ * @property {EasingFunction} inExpo
+ * @property {EasingFunction} outExpo
+ * @property {EasingFunction} inOutExpo
+ * @property {EasingFunction} outInExpo
+ * @property {EasingFunction} inBounce
+ * @property {EasingFunction} outBounce
+ * @property {EasingFunction} inOutBounce
+ * @property {EasingFunction} outInBounce
+ * @property {BackEasing} inBack
+ * @property {BackEasing} outBack
+ * @property {BackEasing} inOutBack
+ * @property {BackEasing} outInBack
+ * @property {ElasticEasing} inElastic
+ * @property {ElasticEasing} outElastic
+ * @property {ElasticEasing} inOutElastic
+ * @property {ElasticEasing} outInElastic
+ */
+
+const eases = (/*#__PURE__ */ (() => {
+  const list = { linear, irregular, steps, cubicBezier };
+  for (let type in easeTypes) {
+    for (let name in easeInFunctions) {
+      const easeIn = easeInFunctions[name];
+      const easeType = easeTypes[type];
+      list[type + name] = /** @type {EasingFunctionWithParams|EasingFunction} */(
+        name === emptyString || name === 'Back' || name === 'Elastic' ?
+        (a, b) => easeType(/** @type {EasingFunctionWithParams} */(easeIn)(a, b)) :
+        easeType(/** @type {EasingFunction} */(easeIn))
+      );
+    }
+  }
+  return /** @type {EasesFunctions} */(list);
+})());
+
+/** @type {Record<String, EasingFunction>} */
+const JSEasesLookups = { linear: none };
+
+/**
+ * @param  {EasingParam} ease
+ * @return {EasingFunction}
+ */
+const parseEase = ease => isFnc(ease) ? ease :
+  isStr(ease) ? parseEaseString(/** @type {String} */(ease), eases, JSEasesLookups) :
+  none;
+
+export { eases, parseEase };

package/dist/modules/easings/index.cjs

@@ -0,0 +1,24 @@
+/**
+ * Anime.js - easings - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var none = require('./none.cjs');
+var cubicBezier = require('./cubic-bezier.cjs');
+var steps = require('./steps.cjs');
+var linear = require('./linear.cjs');
+var irregular = require('./irregular.cjs');
+var eases = require('./eases.cjs');
+
+
+
+exports.none = none.none;
+exports.cubicBezier = cubicBezier.cubicBezier;
+exports.steps = steps.steps;
+exports.linear = linear.linear;
+exports.irregular = irregular.irregular;
+exports.eases = eases.eases;

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

@@ -0,0 +1,6 @@
+export { none } from "./none.js";
+export { cubicBezier } from "./cubic-bezier.js";
+export { steps } from "./steps.js";
+export { linear } from "./linear.js";
+export { irregular } from "./irregular.js";
+export { eases } from "./eases.js";

package/dist/modules/easings/index.js

@@ -0,0 +1,13 @@
+/**
+ * Anime.js - easings - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+export { none } from './none.js';
+export { cubicBezier } from './cubic-bezier.js';
+export { steps } from './steps.js';
+export { linear } from './linear.js';
+export { irregular } from './irregular.js';
+export { eases } from './eases.js';

package/dist/modules/easings/irregular.cjs

@@ -0,0 +1,41 @@
+/**
+ * Anime.js - easings - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var helpers = require('../core/helpers.cjs');
+var linear = require('./linear.cjs');
+
+/**
+ * @import {
+ *   EasingFunction,
+ * } from '../types/index.js'
+*/
+
+/**
+ * Generate random steps
+ * @param  {Number} [length] - The number of steps
+ * @param  {Number} [randomness] - How strong the randomness is
+ * @return {EasingFunction}
+ */
+const irregular = (length = 10, randomness = 1) => {
+  const values = [0];
+  const total = length - 1;
+  for (let i = 1; i < total; i++) {
+    const previousValue = values[i - 1];
+    const spacing = i / total;
+    const segmentEnd = (i + 1) / total;
+    const randomVariation = spacing + (segmentEnd - spacing) * Math.random();
+    // Mix the even spacing and random variation based on the randomness parameter
+    const randomValue = spacing * (1 - randomness) + randomVariation * randomness;
+    values.push(helpers.clamp(randomValue, previousValue, 1));
+  }
+  values.push(1);
+  return linear.linear(...values);
+};
+
+exports.irregular = irregular;

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

@@ -0,0 +1,2 @@
+export function irregular(length?: number, randomness?: number): EasingFunction;
+import type { EasingFunction } from '../types/index.js';