@tsparticles/engine 3.0.3 → 3.1.0

package/browser/Utils/ColorUtils.js

@@ -1,5 +1,6 @@
-import { getRandom, getRangeValue, mix, randomInRange, setRangeValue } from "./NumberUtils.js";
+import { clamp, getRandom, getRangeMax, getRangeMin, getRangeValue, mix, randomInRange, setRangeValue, } from "./NumberUtils.js";
 import { isArray, isString, itemFromArray } from "./Utils.js";
+import { millisecondsToSeconds, percentDenominator } from "../Core/Utils/Constants.js";
 const randomColorValue = "random", midColorValue = "mid", colorManagers = new Map();
 export function addColorManager(manager) {
     colorManagers.set(manager.key, manager);
@@ -12,13 +13,15 @@ function stringToRgba(input) {
     }
     const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])([a-f\d])?$/i, hexFixed = input.replace(shorthandRegex, (_, r, g, b, a) => {
         return r + r + g + g + b + b + (a !== undefined ? a + a : "");
-    }), regex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i, result = regex.exec(hexFixed);
+    }), regex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i, result = regex.exec(hexFixed), radix = 16, defaultAlpha = 1, alphaFactor = 0xff;
     return result
         ? {
-            a: result[4] !== undefined ? parseInt(result[4], 16) / 0xff : 1,
-            b: parseInt(result[3], 16),
-            g: parseInt(result[2], 16),
-            r: parseInt(result[1], 16),
+            a: result[4] !== undefined
+                ? parseInt(result[4], radix) / alphaFactor
+                : defaultAlpha,
+            b: parseInt(result[3], radix),
+            g: parseInt(result[2], radix),
+            r: parseInt(result[1], radix),
         }
         : undefined;
 }
@@ -71,26 +74,26 @@ export function rangeColorToHsl(color, index, useIndex = true) {
     return rgb ? rgbToHsl(rgb) : undefined;
 }
 export function rgbToHsl(color) {
-    const r1 = color.r / 255, g1 = color.g / 255, b1 = color.b / 255, max = Math.max(r1, g1, b1), min = Math.min(r1, g1, b1), res = {
-        h: 0,
-        l: (max + min) * 0.5,
-        s: 0,
+    const rgbMax = 255, hMax = 360, sMax = 100, lMax = 100, hMin = 0, sMin = 0, hPhase = 60, half = 0.5, double = 2, r1 = color.r / rgbMax, g1 = color.g / rgbMax, b1 = color.b / rgbMax, max = Math.max(r1, g1, b1), min = Math.min(r1, g1, b1), res = {
+        h: hMin,
+        l: (max + min) * half,
+        s: sMin,
     };
     if (max !== min) {
-        res.s = res.l < 0.5 ? (max - min) / (max + min) : (max - min) / (2.0 - max - min);
+        res.s = res.l < half ? (max - min) / (max + min) : (max - min) / (double - max - min);
         res.h =
             r1 === max
                 ? (g1 - b1) / (max - min)
-                : (res.h = g1 === max ? 2.0 + (b1 - r1) / (max - min) : 4.0 + (r1 - g1) / (max - min));
+                : (res.h = g1 === max ? double + (b1 - r1) / (max - min) : double * double + (r1 - g1) / (max - min));
     }
-    res.l *= 100;
-    res.s *= 100;
-    res.h *= 60;
-    if (res.h < 0) {
-        res.h += 360;
+    res.l *= lMax;
+    res.s *= sMax;
+    res.h *= hPhase;
+    if (res.h < hMin) {
+        res.h += hMax;
     }
-    if (res.h >= 360) {
-        res.h -= 360;
+    if (res.h >= hMax) {
+        res.h -= hMax;
     }
     return res;
 }
@@ -101,29 +104,33 @@ export function stringToRgb(input) {
     return stringToRgba(input);
 }
 export function hslToRgb(hsl) {
-    const h = ((hsl.h % 360) + 360) % 360, s = Math.max(0, Math.min(100, hsl.s)), l = Math.max(0, Math.min(100, hsl.l)), hNormalized = h / 360, sNormalized = s / 100, lNormalized = l / 100;
-    if (s === 0) {
-        const grayscaleValue = Math.round(lNormalized * 255);
+    const hMax = 360, sMax = 100, lMax = 100, sMin = 0, lMin = 0, h = ((hsl.h % hMax) + hMax) % hMax, s = Math.max(sMin, Math.min(sMax, hsl.s)), l = Math.max(lMin, Math.min(lMax, hsl.l)), hNormalized = h / hMax, sNormalized = s / sMax, lNormalized = l / lMax, rgbFactor = 255, triple = 3;
+    if (s === sMin) {
+        const grayscaleValue = Math.round(lNormalized * rgbFactor);
         return { r: grayscaleValue, g: grayscaleValue, b: grayscaleValue };
     }
-    const channel = (temp1, temp2, temp3) => {
-        if (temp3 < 0) {
-            temp3 += 1;
+    const half = 0.5, double = 2, channel = (temp1, temp2, temp3) => {
+        const temp3Min = 0, temp3Max = 1, sextuple = 6;
+        if (temp3 < temp3Min) {
+            temp3++;
         }
-        if (temp3 > 1) {
-            temp3 -= 1;
+        if (temp3 > temp3Max) {
+            temp3--;
         }
-        if (temp3 * 6 < 1) {
-            return temp1 + (temp2 - temp1) * 6 * temp3;
+        if (temp3 * sextuple < temp3Max) {
+            return temp1 + (temp2 - temp1) * sextuple * temp3;
         }
-        if (temp3 * 2 < 1) {
+        if (temp3 * double < temp3Max) {
             return temp2;
         }
-        if (temp3 * 3 < 2) {
-            return temp1 + (temp2 - temp1) * (2 / 3 - temp3) * 6;
+        if (temp3 * triple < temp3Max * double) {
+            const temp3Offset = double / triple;
+            return temp1 + (temp2 - temp1) * (temp3Offset - temp3) * sextuple;
         }
         return temp1;
-    }, temp1 = lNormalized < 0.5 ? lNormalized * (1 + sNormalized) : lNormalized + sNormalized - lNormalized * sNormalized, temp2 = 2 * lNormalized - temp1, red = Math.min(255, 255 * channel(temp2, temp1, hNormalized + 1 / 3)), green = Math.min(255, 255 * channel(temp2, temp1, hNormalized)), blue = Math.min(255, 255 * channel(temp2, temp1, hNormalized - 1 / 3));
+    }, sNormalizedOffset = 1, temp1 = lNormalized < half
+        ? lNormalized * (sNormalizedOffset + sNormalized)
+        : lNormalized + sNormalized - lNormalized * sNormalized, temp2 = double * lNormalized - temp1, phaseNumerator = 1, phaseThird = phaseNumerator / triple, red = Math.min(rgbFactor, rgbFactor * channel(temp2, temp1, hNormalized + phaseThird)), green = Math.min(rgbFactor, rgbFactor * channel(temp2, temp1, hNormalized)), blue = Math.min(rgbFactor, rgbFactor * channel(temp2, temp1, hNormalized - phaseThird));
     return { r: Math.round(red), g: Math.round(green), b: Math.round(blue) };
 }
 export function hslaToRgba(hsla) {
@@ -136,18 +143,20 @@ export function hslaToRgba(hsla) {
     };
 }
 export function getRandomRgbColor(min) {
-    const fixedMin = min ?? 0;
+    const defaultMin = 0, fixedMin = min ?? defaultMin, rgbMax = 256;
     return {
-        b: Math.floor(randomInRange(setRangeValue(fixedMin, 256))),
-        g: Math.floor(randomInRange(setRangeValue(fixedMin, 256))),
-        r: Math.floor(randomInRange(setRangeValue(fixedMin, 256))),
+        b: Math.floor(randomInRange(setRangeValue(fixedMin, rgbMax))),
+        g: Math.floor(randomInRange(setRangeValue(fixedMin, rgbMax))),
+        r: Math.floor(randomInRange(setRangeValue(fixedMin, rgbMax))),
     };
 }
 export function getStyleFromRgb(color, opacity) {
-    return `rgba(${color.r}, ${color.g}, ${color.b}, ${opacity ?? 1})`;
+    const defaultOpacity = 1;
+    return `rgba(${color.r}, ${color.g}, ${color.b}, ${opacity ?? defaultOpacity})`;
 }
 export function getStyleFromHsl(color, opacity) {
-    return `hsla(${color.h}, ${color.s}%, ${color.l}%, ${opacity ?? 1})`;
+    const defaultOpacity = 1;
+    return `hsla(${color.h}, ${color.s}%, ${color.l}%, ${opacity ?? defaultOpacity})`;
 }
 export function colorMix(color1, color2, size1, size2) {
     let rgb1 = color1, rgb2 = color2;
@@ -238,21 +247,91 @@ export function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
 }
 function setColorAnimation(colorValue, colorAnimation, reduceFactor) {
     colorValue.enable = colorAnimation.enable;
+    const defaultVelocity = 0, decayOffset = 1, defaultLoops = 0, defaultTime = 0;
     if (colorValue.enable) {
-        colorValue.velocity = (getRangeValue(colorAnimation.speed) / 100) * reduceFactor;
-        colorValue.decay = 1 - getRangeValue(colorAnimation.decay);
+        colorValue.velocity = (getRangeValue(colorAnimation.speed) / percentDenominator) * reduceFactor;
+        colorValue.decay = decayOffset - getRangeValue(colorAnimation.decay);
         colorValue.status = "increasing";
-        colorValue.loops = 0;
+        colorValue.loops = defaultLoops;
         colorValue.maxLoops = getRangeValue(colorAnimation.count);
-        colorValue.time = 0;
-        colorValue.delayTime = getRangeValue(colorAnimation.delay) * 1000;
+        colorValue.time = defaultTime;
+        colorValue.delayTime = getRangeValue(colorAnimation.delay) * millisecondsToSeconds;
         if (!colorAnimation.sync) {
             colorValue.velocity *= getRandom();
             colorValue.value *= getRandom();
         }
         colorValue.initialValue = colorValue.value;
+        colorValue.offset = setRangeValue(colorAnimation.offset);
     }
     else {
-        colorValue.velocity = 0;
+        colorValue.velocity = defaultVelocity;
+    }
+}
+export function updateColorValue(data, range, decrease, delta) {
+    const minLoops = 0, minDelay = 0, identity = 1, minVelocity = 0, minOffset = 0, velocityFactor = 3.6;
+    if (!data ||
+        !data.enable ||
+        ((data.maxLoops ?? minLoops) > minLoops && (data.loops ?? minLoops) > (data.maxLoops ?? minLoops))) {
+        return;
+    }
+    if (!data.time) {
+        data.time = 0;
+    }
+    if ((data.delayTime ?? minDelay) > minDelay && data.time < (data.delayTime ?? minDelay)) {
+        data.time += delta.value;
+    }
+    if ((data.delayTime ?? minDelay) > minDelay && data.time < (data.delayTime ?? minDelay)) {
+        return;
+    }
+    const offset = data.offset ? randomInRange(data.offset) : minOffset, velocity = (data.velocity ?? minVelocity) * delta.factor + offset * velocityFactor, decay = data.decay ?? identity, max = getRangeMax(range), min = getRangeMin(range);
+    if (!decrease || data.status === "increasing") {
+        data.value += velocity;
+        if (data.value > max) {
+            if (!data.loops) {
+                data.loops = 0;
+            }
+            data.loops++;
+            if (decrease) {
+                data.status = "decreasing";
+            }
+            else {
+                data.value -= max;
+            }
+        }
+    }
+    else {
+        data.value -= velocity;
+        const minValue = 0;
+        if (data.value < minValue) {
+            if (!data.loops) {
+                data.loops = 0;
+            }
+            data.loops++;
+            data.status = "increasing";
+        }
+    }
+    if (data.velocity && decay !== identity) {
+        data.velocity *= decay;
+    }
+    data.value = clamp(data.value, min, max);
+}
+export function updateColor(color, delta) {
+    if (!color) {
+        return;
+    }
+    const { h, s, l } = color;
+    const ranges = {
+        h: { min: 0, max: 360 },
+        s: { min: 0, max: 100 },
+        l: { min: 0, max: 100 },
+    };
+    if (h) {
+        updateColorValue(h, ranges.h, false, delta);
+    }
+    if (s) {
+        updateColorValue(s, ranges.s, true, delta);
+    }
+    if (l) {
+        updateColorValue(l, ranges.l, true, delta);
     }
 }

package/browser/Utils/EventDispatcher.js

@@ -13,7 +13,7 @@ export class EventDispatcher {
     }
     dispatchEvent(type, args) {
         const listeners = this._listeners.get(type);
-        listeners && listeners.forEach((handler) => handler(args));
+        listeners?.forEach((handler) => handler(args));
     }
     hasEventListener(type) {
         return !!this._listeners.get(type);
@@ -31,15 +31,16 @@ export class EventDispatcher {
         if (!arr) {
             return;
         }
-        const length = arr.length, idx = arr.indexOf(listener);
-        if (idx < 0) {
+        const length = arr.length, idx = arr.indexOf(listener), minIndex = 0;
+        if (idx < minIndex) {
             return;
         }
-        if (length === 1) {
+        const deleteCount = 1;
+        if (length === deleteCount) {
             this._listeners.delete(type);
         }
         else {
-            arr.splice(idx, 1);
+            arr.splice(idx, deleteCount);
         }
     }
 }

package/browser/Utils/HslColorManager.js

@@ -25,13 +25,13 @@ export class HslColorManager {
         if (!input.startsWith("hsl")) {
             return;
         }
-        const regex = /hsla?\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([\d.%]+)\s*)?\)/i, result = regex.exec(input);
+        const regex = /hsla?\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([\d.%]+)\s*)?\)/i, result = regex.exec(input), minLength = 4, defaultAlpha = 1, radix = 10;
         return result
             ? hslaToRgba({
-                a: result.length > 4 ? parseAlpha(result[5]) : 1,
-                h: parseInt(result[1], 10),
-                l: parseInt(result[3], 10),
-                s: parseInt(result[2], 10),
+                a: result.length > minLength ? parseAlpha(result[5]) : defaultAlpha,
+                h: parseInt(result[1], radix),
+                l: parseInt(result[3], radix),
+                s: parseInt(result[2], radix),
             })
             : undefined;
     }

package/browser/Utils/NumberUtils.js

@@ -1,7 +1,8 @@
 import { Vector } from "../Core/Utils/Vector.js";
 import { isNumber } from "./Utils.js";
+import { percentDenominator } from "../Core/Utils/Constants.js";
 let _random = Math.random;
-const easings = new Map();
+const easings = new Map(), double = 2, doublePI = Math.PI * double;
 export function addEasing(name, easing) {
     if (easings.get(name)) {
         return;
@@ -9,13 +10,14 @@ export function addEasing(name, easing) {
     easings.set(name, easing);
 }
 export function getEasing(name) {
-    return easings.get(name) || ((value) => value);
+    return easings.get(name) ?? ((value) => value);
 }
 export function setRandom(rnd = Math.random) {
     _random = rnd;
 }
 export function getRandom() {
-    return clamp(_random(), 0, 1 - 1e-16);
+    const min = 0, max = 1;
+    return clamp(_random(), min, max - Number.EPSILON);
 }
 export function clamp(num, min, max) {
     return Math.min(Math.max(num, min), max);
@@ -24,10 +26,10 @@ export function mix(comp1, comp2, weight1, weight2) {
     return Math.floor((comp1 * weight1 + comp2 * weight2) / (weight1 + weight2));
 }
 export function randomInRange(r) {
-    const max = getRangeMax(r);
+    const max = getRangeMax(r), minOffset = 0;
     let min = getRangeMin(r);
     if (max === min) {
-        min = 0;
+        min = minOffset;
     }
     return getRandom() * (max - min) + min;
 }
@@ -53,39 +55,44 @@ export function setRangeValue(source, value) {
         : setRangeValue(min, max);
 }
 export function getDistances(pointA, pointB) {
-    const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y;
-    return { dx: dx, dy: dy, distance: Math.sqrt(dx ** 2 + dy ** 2) };
+    const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y, squareExp = 2;
+    return { dx: dx, dy: dy, distance: Math.sqrt(dx ** squareExp + dy ** squareExp) };
 }
 export function getDistance(pointA, pointB) {
     return getDistances(pointA, pointB).distance;
 }
+export function degToRad(degrees) {
+    const PIDeg = 180;
+    return (degrees * Math.PI) / PIDeg;
+}
 export function getParticleDirectionAngle(direction, position, center) {
     if (isNumber(direction)) {
-        return (direction * Math.PI) / 180;
+        return degToRad(direction);
     }
+    const empty = 0, half = 0.5, quarter = 0.25, threeQuarter = half + quarter;
     switch (direction) {
         case "top":
-            return -Math.PI * 0.5;
+            return -Math.PI * half;
         case "top-right":
-            return -Math.PI * 0.25;
+            return -Math.PI * quarter;
         case "right":
-            return 0;
+            return empty;
         case "bottom-right":
-            return Math.PI * 0.25;
+            return Math.PI * quarter;
         case "bottom":
-            return Math.PI * 0.5;
+            return Math.PI * half;
         case "bottom-left":
-            return Math.PI * 0.75;
+            return Math.PI * threeQuarter;
         case "left":
             return Math.PI;
         case "top-left":
-            return -Math.PI * 0.75;
+            return -Math.PI * threeQuarter;
         case "inside":
             return Math.atan2(center.y - position.y, center.x - position.x);
         case "outside":
             return Math.atan2(position.y - center.y, position.x - center.x);
         default:
-            return getRandom() * Math.PI * 2;
+            return getRandom() * doublePI;
     }
 }
 export function getParticleBaseVelocity(direction) {
@@ -95,20 +102,21 @@ export function getParticleBaseVelocity(direction) {
     return baseVelocity;
 }
 export function collisionVelocity(v1, v2, m1, m2) {
-    return Vector.create((v1.x * (m1 - m2)) / (m1 + m2) + (v2.x * 2 * m2) / (m1 + m2), v1.y);
+    const double = 2;
+    return Vector.create((v1.x * (m1 - m2)) / (m1 + m2) + (v2.x * double * m2) / (m1 + m2), v1.y);
 }
 export function calcPositionFromSize(data) {
-    return data.position && data.position.x !== undefined && data.position.y !== undefined
+    return data.position?.x !== undefined && data.position.y !== undefined
         ? {
-            x: (data.position.x * data.size.width) / 100,
-            y: (data.position.y * data.size.height) / 100,
+            x: (data.position.x * data.size.width) / percentDenominator,
+            y: (data.position.y * data.size.height) / percentDenominator,
         }
         : undefined;
 }
 export function calcPositionOrRandomFromSize(data) {
     return {
-        x: ((data.position?.x ?? getRandom() * 100) * data.size.width) / 100,
-        y: ((data.position?.y ?? getRandom() * 100) * data.size.height) / 100,
+        x: ((data.position?.x ?? getRandom() * percentDenominator) * data.size.width) / percentDenominator,
+        y: ((data.position?.y ?? getRandom() * percentDenominator) * data.size.height) / percentDenominator,
     };
 }
 export function calcPositionOrRandomFromSizeRanged(data) {
@@ -132,5 +140,9 @@ export function calcExactPositionOrRandomFromSizeRanged(data) {
     return calcExactPositionOrRandomFromSize({ size: data.size, position });
 }
 export function parseAlpha(input) {
-    return input ? (input.endsWith("%") ? parseFloat(input) / 100 : parseFloat(input)) : 1;
+    const defaultAlpha = 1;
+    if (!input) {
+        return defaultAlpha;
+    }
+    return input.endsWith("%") ? parseFloat(input) / percentDenominator : parseFloat(input);
 }

package/browser/Utils/RgbColorManager.js

@@ -24,13 +24,13 @@ export class RgbColorManager {
         if (!input.startsWith(this.stringPrefix)) {
             return;
         }
-        const regex = /rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([\d.%]+)\s*)?\)/i, result = regex.exec(input);
+        const regex = /rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([\d.%]+)\s*)?\)/i, result = regex.exec(input), radix = 10, minLength = 4, defaultAlpha = 1;
         return result
             ? {
-                a: result.length > 4 ? parseAlpha(result[5]) : 1,
-                b: parseInt(result[3], 10),
-                g: parseInt(result[2], 10),
-                r: parseInt(result[1], 10),
+                a: result.length > minLength ? parseAlpha(result[5]) : defaultAlpha,
+                b: parseInt(result[3], radix),
+                g: parseInt(result[2], radix),
+                r: parseInt(result[1], radix),
             }
             : undefined;
     }

package/browser/Utils/Utils.js

@@ -1,4 +1,5 @@
-import { collisionVelocity, getDistances, getRandom, getRangeMax, getRangeMin, getRangeValue, randomInRange, } from "./NumberUtils.js";
+import { clamp, collisionVelocity, getDistances, getRandom, getRangeMax, getRangeMin, getRangeValue, randomInRange, } from "./NumberUtils.js";
+import { halfRandom, millisecondsToSeconds, percentDenominator } from "../Core/Utils/Constants.js";
 import { Vector } from "../Core/Utils/Vector.js";
 const _logger = {
     debug: console.debug,
@@ -20,15 +21,15 @@ export function getLogger() {
     return _logger;
 }
 function rectSideBounce(data) {
-    const res = { bounced: false }, { pSide, pOtherSide, rectSide, rectOtherSide, velocity, factor } = data;
+    const res = { bounced: false }, { pSide, pOtherSide, rectSide, rectOtherSide, velocity, factor } = data, half = 0.5, minVelocity = 0;
     if (pOtherSide.min < rectOtherSide.min ||
         pOtherSide.min > rectOtherSide.max ||
         pOtherSide.max < rectOtherSide.min ||
         pOtherSide.max > rectOtherSide.max) {
         return res;
     }
-    if ((pSide.max >= rectSide.min && pSide.max <= (rectSide.max + rectSide.min) * 0.5 && velocity > 0) ||
-        (pSide.min <= rectSide.max && pSide.min > (rectSide.max + rectSide.min) * 0.5 && velocity < 0)) {
+    if ((pSide.max >= rectSide.min && pSide.max <= (rectSide.max + rectSide.min) * half && velocity > minVelocity) ||
+        (pSide.min <= rectSide.max && pSide.min > (rectSide.max + rectSide.min) * half && velocity < minVelocity)) {
         res.velocity = velocity * -factor;
         res.bounced = true;
     }
@@ -65,7 +66,8 @@ export function safeMutationObserver(callback) {
     return new MutationObserver(callback);
 }
 export function isInArray(value, array) {
-    return value === array || (isArray(array) && array.indexOf(value) > -1);
+    const invalidIndex = -1;
+    return value === array || (isArray(array) && array.indexOf(value) > invalidIndex);
 }
 export async function loadFont(font, weight) {
     try {
@@ -81,7 +83,8 @@ export function itemFromArray(array, index, useIndex = true) {
     return array[index !== undefined && useIndex ? index % array.length : arrayRandomIndex(array)];
 }
 export function isPointInside(point, size, offset, radius, direction) {
-    return areBoundsInside(calculateBounds(point, radius ?? 0), size, offset, direction);
+    const minRadius = 0;
+    return areBoundsInside(calculateBounds(point, radius ?? minRadius), size, offset, direction);
 }
 export function areBoundsInside(bounds, size, offset, direction) {
     let inside = true;
@@ -171,8 +174,8 @@ export function circleBounceDataFromParticle(p) {
     };
 }
 export function circleBounce(p1, p2) {
-    const { x: xVelocityDiff, y: yVelocityDiff } = p1.velocity.sub(p2.velocity), [pos1, pos2] = [p1.position, p2.position], { dx: xDist, dy: yDist } = getDistances(pos2, pos1);
-    if (xVelocityDiff * xDist + yVelocityDiff * yDist < 0) {
+    const { x: xVelocityDiff, y: yVelocityDiff } = p1.velocity.sub(p2.velocity), [pos1, pos2] = [p1.position, p2.position], { dx: xDist, dy: yDist } = getDistances(pos2, pos1), minimumDistance = 0;
+    if (xVelocityDiff * xDist + yVelocityDiff * yDist < minimumDistance) {
         return;
     }
     const angle = -Math.atan2(yDist, xDist), m1 = p1.mass, m2 = p2.mass, u1 = p1.velocity.rotate(angle), u2 = p2.velocity.rotate(angle), v1 = collisionVelocity(u1, u2, m1, m2), v2 = collisionVelocity(u2, u1, m1, m2), vFinal1 = v1.rotate(-angle), vFinal2 = v2.rotate(-angle);
@@ -240,17 +243,22 @@ export function rectBounce(particle, divBounds) {
     }
 }
 export function executeOnSingleOrMultiple(obj, callback) {
-    return isArray(obj) ? obj.map((item, index) => callback(item, index)) : callback(obj, 0);
+    const defaultIndex = 0;
+    return isArray(obj) ? obj.map((item, index) => callback(item, index)) : callback(obj, defaultIndex);
 }
 export function itemFromSingleOrMultiple(obj, index, useIndex) {
     return isArray(obj) ? itemFromArray(obj, index, useIndex) : obj;
 }
 export function findItemFromSingleOrMultiple(obj, callback) {
-    return isArray(obj) ? obj.find((t, index) => callback(t, index)) : callback(obj, 0) ? obj : undefined;
+    if (isArray(obj)) {
+        return obj.find((t, index) => callback(t, index));
+    }
+    const defaultIndex = 0;
+    return callback(obj, defaultIndex) ? obj : undefined;
 }
 export function initParticleNumericAnimationValue(options, pxRatio) {
     const valueRange = options.value, animationOptions = options.animation, res = {
-        delayTime: getRangeValue(animationOptions.delay) * 1000,
+        delayTime: getRangeValue(animationOptions.delay) * millisecondsToSeconds,
         enable: animationOptions.enable,
         value: getRangeValue(options.value) * pxRatio,
         max: getRangeMax(valueRange) * pxRatio,
@@ -258,9 +266,9 @@ export function initParticleNumericAnimationValue(options, pxRatio) {
         loops: 0,
         maxLoops: getRangeValue(animationOptions.count),
         time: 0,
-    };
+    }, decayOffset = 1;
     if (animationOptions.enable) {
-        res.decay = 1 - getRangeValue(animationOptions.decay);
+        res.decay = decayOffset - getRangeValue(animationOptions.decay);
         switch (animationOptions.mode) {
             case "increase":
                 res.status = "increasing";
@@ -269,7 +277,7 @@ export function initParticleNumericAnimationValue(options, pxRatio) {
                 res.status = "decreasing";
                 break;
             case "random":
-                res.status = getRandom() >= 0.5 ? "increasing" : "decreasing";
+                res.status = getRandom() >= halfRandom ? "increasing" : "decreasing";
                 break;
         }
         const autoStatus = animationOptions.mode === "auto";
@@ -290,7 +298,7 @@ export function initParticleNumericAnimationValue(options, pxRatio) {
             default:
                 res.value = randomInRange(res);
                 if (autoStatus) {
-                    res.status = getRandom() >= 0.5 ? "increasing" : "decreasing";
+                    res.status = getRandom() >= halfRandom ? "increasing" : "decreasing";
                 }
                 break;
         }
@@ -307,14 +315,14 @@ function getPositionOrSize(positionOrSize, canvasSize) {
     const isPosition = "x" in positionOrSize;
     if (isPosition) {
         return {
-            x: (positionOrSize.x / 100) * canvasSize.width,
-            y: (positionOrSize.y / 100) * canvasSize.height,
+            x: (positionOrSize.x / percentDenominator) * canvasSize.width,
+            y: (positionOrSize.y / percentDenominator) * canvasSize.height,
         };
     }
     else {
         return {
-            width: (positionOrSize.width / 100) * canvasSize.width,
-            height: (positionOrSize.height / 100) * canvasSize.height,
+            width: (positionOrSize.width / percentDenominator) * canvasSize.width,
+            height: (positionOrSize.height / percentDenominator) * canvasSize.height,
         };
     }
 }
@@ -342,3 +350,78 @@ export function isObject(arg) {
 export function isArray(arg) {
     return Array.isArray(arg);
 }
+function checkDestroy(particle, destroyType, value, minValue, maxValue) {
+    switch (destroyType) {
+        case "max":
+            if (value >= maxValue) {
+                particle.destroy();
+            }
+            break;
+        case "min":
+            if (value <= minValue) {
+                particle.destroy();
+            }
+            break;
+    }
+}
+export function updateAnimation(particle, data, changeDirection, destroyType, delta) {
+    const minLoops = 0, minDelay = 0, identity = 1, minVelocity = 0, minDecay = 1;
+    if (particle.destroyed ||
+        !data ||
+        !data.enable ||
+        ((data.maxLoops ?? minLoops) > minLoops && (data.loops ?? minLoops) > (data.maxLoops ?? minLoops))) {
+        return;
+    }
+    const velocity = (data.velocity ?? minVelocity) * delta.factor, minValue = data.min, maxValue = data.max, decay = data.decay ?? minDecay;
+    if (!data.time) {
+        data.time = 0;
+    }
+    if ((data.delayTime ?? minDelay) > minDelay && data.time < (data.delayTime ?? minDelay)) {
+        data.time += delta.value;
+    }
+    if ((data.delayTime ?? minDelay) > minDelay && data.time < (data.delayTime ?? minDelay)) {
+        return;
+    }
+    switch (data.status) {
+        case "increasing":
+            if (data.value >= maxValue) {
+                if (changeDirection) {
+                    data.status = "decreasing";
+                }
+                else {
+                    data.value -= maxValue;
+                }
+                if (!data.loops) {
+                    data.loops = minLoops;
+                }
+                data.loops++;
+            }
+            else {
+                data.value += velocity;
+            }
+            break;
+        case "decreasing":
+            if (data.value <= minValue) {
+                if (changeDirection) {
+                    data.status = "increasing";
+                }
+                else {
+                    data.value += maxValue;
+                }
+                if (!data.loops) {
+                    data.loops = minLoops;
+                }
+                data.loops++;
+            }
+            else {
+                data.value -= velocity;
+            }
+    }
+    if (data.velocity && decay !== identity) {
+        data.velocity *= decay;
+    }
+    checkDestroy(particle, destroyType, data.value, minValue, maxValue);
+    if (!particle.destroyed) {
+        data.value = clamp(data.value, minValue, maxValue);
+    }
+}