animejs 4.1.4 → 4.2.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/index.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/index.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/index.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/index.cjs

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

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

@@ -0,0 +1 @@
+export { eases } from "./parser.js";

package/dist/modules/easings/eases/index.js

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

package/dist/modules/easings/eases/parser.cjs

@@ -0,0 +1,191 @@
+/**
+ * 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 none = require('../none.cjs');
+
+/**
+ * @import {
+ *   EasingFunction,
+ *   EasingFunctionWithParams,
+ *   EasingParam,
+ *   BackEasing,
+ *   ElasticEasing,
+ *   PowerEasing,
+ * } 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,
+};
+
+/**
+ * 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]: easeInPower,
+  Quad: easeInPower(2),
+  Cubic: easeInPower(3),
+  Quart: easeInPower(4),
+  Quint: 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.7) => 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 none} linear
+ * @property {typeof none} none
+ * @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: none.none, none: none.none };
+  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 === 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 easesLookups = { linear: none.none, none: none.none };
+
+/**
+ * @param  {String} string
+ * @return {EasingFunction}
+ */
+const parseEaseString = (string) => {
+  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} */(eases[string])() : eases[string]);
+    return parsedFn ? easesLookups[string] = parsedFn : none.none;
+  } else {
+    const split = string.slice(0, -1).split('(');
+    const parsedFn = /** @type {EasingFunctionWithParams} */(eases[split[0]]);
+    return parsedFn ? easesLookups[string] = parsedFn(...split[1].split(',')) : none.none;
+  }
+};
+
+const deprecated = ['steps(', 'irregular(', 'linear(', 'cubicBezier('];
+
+/**
+ * @param  {EasingParam} ease
+ * @return {EasingFunction}
+ */
+const parseEase = ease => {
+  if (helpers.isStr(ease)) {
+    for (let i = 0, l = deprecated.length; i < l; i++) {
+      if (helpers.stringStartsWith(ease, deprecated[i])) {
+        console.warn(`String syntax for \`ease: "${ease}"\` has been removed from the core and replaced by importing and passing the easing function directly: \`ease: ${ease}\``);
+        return none.none;
+      }
+    }
+  }
+  const easeFunc = helpers.isFnc(ease) ? ease : helpers.isStr(ease) ? parseEaseString(/** @type {String} */(ease)) : none.none;
+  return easeFunc;
+};
+
+exports.easeInPower = easeInPower;
+exports.easeTypes = easeTypes;
+exports.eases = eases;
+exports.parseEase = parseEase;
+exports.parseEaseString = parseEaseString;

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

@@ -0,0 +1,125 @@
+/**
+ * @import {
+ *   EasingFunction,
+ *   EasingFunctionWithParams,
+ *   EasingParam,
+ *   BackEasing,
+ *   ElasticEasing,
+ *   PowerEasing,
+ * } 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 namespace eases {
+    export let linear: typeof import("../none.js").none;
+    export let none: typeof import("../none.js").none;
+    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 parseEaseString(string: string): EasingFunction;
+export function parseEase(ease: EasingParam): EasingFunction;
+export type EaseType = (Ease: EasingFunction) => EasingFunction;
+export type EasesFunctions = {
+    linear: typeof none;
+    none: typeof none;
+    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 { none as none_1 } from '../none.js';

package/dist/modules/easings/eases/parser.js

@@ -0,0 +1,185 @@
+/**
+ * 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, isStr, stringStartsWith, isFnc, clamp, asin, PI } from '../../core/helpers.js';
+import { none } from '../none.js';
+
+/**
+ * @import {
+ *   EasingFunction,
+ *   EasingFunctionWithParams,
+ *   EasingParam,
+ *   BackEasing,
+ *   ElasticEasing,
+ *   PowerEasing,
+ * } 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,
+};
+
+/**
+ * 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.7) => 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 none} linear
+ * @property {typeof none} none
+ * @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: none, none: none };
+  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 easesLookups = { linear: none, none: none };
+
+/**
+ * @param  {String} string
+ * @return {EasingFunction}
+ */
+const parseEaseString = (string) => {
+  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} */(eases[string])() : eases[string]);
+    return parsedFn ? easesLookups[string] = parsedFn : none;
+  } else {
+    const split = string.slice(0, -1).split('(');
+    const parsedFn = /** @type {EasingFunctionWithParams} */(eases[split[0]]);
+    return parsedFn ? easesLookups[string] = parsedFn(...split[1].split(',')) : none;
+  }
+};
+
+const deprecated = ['steps(', 'irregular(', 'linear(', 'cubicBezier('];
+
+/**
+ * @param  {EasingParam} ease
+ * @return {EasingFunction}
+ */
+const parseEase = ease => {
+  if (isStr(ease)) {
+    for (let i = 0, l = deprecated.length; i < l; i++) {
+      if (stringStartsWith(ease, deprecated[i])) {
+        console.warn(`String syntax for \`ease: "${ease}"\` has been removed from the core and replaced by importing and passing the easing function directly: \`ease: ${ease}\``);
+        return none;
+      }
+    }
+  }
+  const easeFunc = isFnc(ease) ? ease : isStr(ease) ? parseEaseString(/** @type {String} */(ease)) : none;
+  return easeFunc;
+};
+
+export { easeInPower, easeTypes, eases, parseEase, parseEaseString };