tsparticles 1.40.2 → 1.41.0

package/umd/Utils/ColorUtils.js

@@ -0,0 +1,486 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./NumberUtils", "../Core", "./Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getHslAnimationFromHsl = exports.getHslFromAnimation = exports.getLinkRandomColor = exports.getLinkColor = exports.colorMix = exports.getStyleFromHsv = exports.getStyleFromHsl = exports.getStyleFromRgb = exports.getRandomRgbColor = exports.rgbaToHsva = exports.rgbToHsv = exports.hsvaToRgba = exports.hsvToRgb = exports.hsvaToHsla = exports.hsvToHsl = exports.hslaToHsva = exports.hslToHsv = exports.hslaToRgba = exports.hslToRgb = exports.stringToRgb = exports.stringToAlpha = exports.rgbToHsl = exports.colorToHsl = exports.colorToRgb = void 0;
+    const NumberUtils_1 = require("./NumberUtils");
+    const Core_1 = require("../Core");
+    const Utils_1 = require("./Utils");
+    function hue2rgb(p, q, t) {
+        let tCalc = t;
+        if (tCalc < 0) {
+            tCalc += 1;
+        }
+        if (tCalc > 1) {
+            tCalc -= 1;
+        }
+        if (tCalc < 1 / 6) {
+            return p + (q - p) * 6 * tCalc;
+        }
+        if (tCalc < 1 / 2) {
+            return q;
+        }
+        if (tCalc < 2 / 3) {
+            return p + (q - p) * (2 / 3 - tCalc) * 6;
+        }
+        return p;
+    }
+    function stringToRgba(input) {
+        if (input.startsWith("rgb")) {
+            const regex = /rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([\d.]+)\s*)?\)/i;
+            const result = regex.exec(input);
+            return result
+                ? {
+                    a: result.length > 4 ? parseFloat(result[5]) : 1,
+                    b: parseInt(result[3], 10),
+                    g: parseInt(result[2], 10),
+                    r: parseInt(result[1], 10),
+                }
+                : undefined;
+        }
+        else if (input.startsWith("hsl")) {
+            const regex = /hsla?\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([\d.]+)\s*)?\)/i;
+            const result = regex.exec(input);
+            return result
+                ? hslaToRgba({
+                    a: result.length > 4 ? parseFloat(result[5]) : 1,
+                    h: parseInt(result[1], 10),
+                    l: parseInt(result[3], 10),
+                    s: parseInt(result[2], 10),
+                })
+                : undefined;
+        }
+        else if (input.startsWith("hsv")) {
+            const regex = /hsva?\(\s*(\d+)°\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(,\s*([\d.]+)\s*)?\)/i;
+            const result = regex.exec(input);
+            return result
+                ? hsvaToRgba({
+                    a: result.length > 4 ? parseFloat(result[5]) : 1,
+                    h: parseInt(result[1], 10),
+                    s: parseInt(result[2], 10),
+                    v: parseInt(result[3], 10),
+                })
+                : undefined;
+        }
+        else {
+            const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])([a-f\d])?$/i;
+            const hexFixed = input.replace(shorthandRegex, (_m, r, g, b, a) => {
+                return r + r + g + g + b + b + (a !== undefined ? a + a : "");
+            });
+            const regex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})?$/i;
+            const result = regex.exec(hexFixed);
+            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),
+                }
+                : undefined;
+        }
+    }
+    function colorToRgb(input, index, useIndex = true) {
+        var _a, _b, _c;
+        if (input === undefined) {
+            return;
+        }
+        const color = typeof input === "string" ? { value: input } : input;
+        let res;
+        if (typeof color.value === "string") {
+            if (color.value === Core_1.Constants.randomColorValue) {
+                res = getRandomRgbColor();
+            }
+            else {
+                res = stringToRgb(color.value);
+            }
+        }
+        else {
+            if (color.value instanceof Array) {
+                const colorSelected = (0, Utils_1.itemFromArray)(color.value, index, useIndex);
+                res = colorToRgb({ value: colorSelected });
+            }
+            else {
+                const colorValue = color.value;
+                const rgbColor = (_a = colorValue.rgb) !== null && _a !== void 0 ? _a : color.value;
+                if (rgbColor.r !== undefined) {
+                    res = rgbColor;
+                }
+                else {
+                    const hslColor = (_b = colorValue.hsl) !== null && _b !== void 0 ? _b : color.value;
+                    if (hslColor.h !== undefined && hslColor.l !== undefined) {
+                        res = hslToRgb(hslColor);
+                    }
+                    else {
+                        const hsvColor = (_c = colorValue.hsv) !== null && _c !== void 0 ? _c : color.value;
+                        if (hsvColor.h !== undefined && hsvColor.v !== undefined) {
+                            res = hsvToRgb(hsvColor);
+                        }
+                    }
+                }
+            }
+        }
+        return res;
+    }
+    exports.colorToRgb = colorToRgb;
+    function colorToHsl(color, index, useIndex = true) {
+        const rgb = colorToRgb(color, index, useIndex);
+        return rgb !== undefined ? rgbToHsl(rgb) : undefined;
+    }
+    exports.colorToHsl = colorToHsl;
+    function rgbToHsl(color) {
+        const r1 = color.r / 255;
+        const g1 = color.g / 255;
+        const b1 = color.b / 255;
+        const max = Math.max(r1, g1, b1);
+        const min = Math.min(r1, g1, b1);
+        const res = {
+            h: 0,
+            l: (max + min) / 2,
+            s: 0,
+        };
+        if (max != min) {
+            res.s = res.l < 0.5 ? (max - min) / (max + min) : (max - min) / (2.0 - 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.l *= 100;
+        res.s *= 100;
+        res.h *= 60;
+        if (res.h < 0) {
+            res.h += 360;
+        }
+        return res;
+    }
+    exports.rgbToHsl = rgbToHsl;
+    function stringToAlpha(input) {
+        var _a;
+        return (_a = stringToRgba(input)) === null || _a === void 0 ? void 0 : _a.a;
+    }
+    exports.stringToAlpha = stringToAlpha;
+    function stringToRgb(input) {
+        return stringToRgba(input);
+    }
+    exports.stringToRgb = stringToRgb;
+    function hslToRgb(hsl) {
+        const result = { b: 0, g: 0, r: 0 };
+        const hslPercent = {
+            h: hsl.h / 360,
+            l: hsl.l / 100,
+            s: hsl.s / 100,
+        };
+        if (hslPercent.s === 0) {
+            result.b = hslPercent.l;
+            result.g = hslPercent.l;
+            result.r = hslPercent.l;
+        }
+        else {
+            const q = hslPercent.l < 0.5
+                ? hslPercent.l * (1 + hslPercent.s)
+                : hslPercent.l + hslPercent.s - hslPercent.l * hslPercent.s;
+            const p = 2 * hslPercent.l - q;
+            result.r = hue2rgb(p, q, hslPercent.h + 1 / 3);
+            result.g = hue2rgb(p, q, hslPercent.h);
+            result.b = hue2rgb(p, q, hslPercent.h - 1 / 3);
+        }
+        result.r = Math.floor(result.r * 255);
+        result.g = Math.floor(result.g * 255);
+        result.b = Math.floor(result.b * 255);
+        return result;
+    }
+    exports.hslToRgb = hslToRgb;
+    function hslaToRgba(hsla) {
+        const rgbResult = hslToRgb(hsla);
+        return {
+            a: hsla.a,
+            b: rgbResult.b,
+            g: rgbResult.g,
+            r: rgbResult.r,
+        };
+    }
+    exports.hslaToRgba = hslaToRgba;
+    function hslToHsv(hsl) {
+        const l = hsl.l / 100, sl = hsl.s / 100;
+        const v = l + sl * Math.min(l, 1 - l), sv = !v ? 0 : 2 * (1 - l / v);
+        return {
+            h: hsl.h,
+            s: sv * 100,
+            v: v * 100,
+        };
+    }
+    exports.hslToHsv = hslToHsv;
+    function hslaToHsva(hsla) {
+        const hsvResult = hslToHsv(hsla);
+        return {
+            a: hsla.a,
+            h: hsvResult.h,
+            s: hsvResult.s,
+            v: hsvResult.v,
+        };
+    }
+    exports.hslaToHsva = hslaToHsva;
+    function hsvToHsl(hsv) {
+        const v = hsv.v / 100, sv = hsv.s / 100;
+        const l = v * (1 - sv / 2), sl = l === 0 || l === 1 ? 0 : (v - l) / Math.min(l, 1 - l);
+        return {
+            h: hsv.h,
+            l: l * 100,
+            s: sl * 100,
+        };
+    }
+    exports.hsvToHsl = hsvToHsl;
+    function hsvaToHsla(hsva) {
+        const hslResult = hsvToHsl(hsva);
+        return {
+            a: hsva.a,
+            h: hslResult.h,
+            l: hslResult.l,
+            s: hslResult.s,
+        };
+    }
+    exports.hsvaToHsla = hsvaToHsla;
+    function hsvToRgb(hsv) {
+        const result = { b: 0, g: 0, r: 0 };
+        const hsvPercent = {
+            h: hsv.h / 60,
+            s: hsv.s / 100,
+            v: hsv.v / 100,
+        };
+        const c = hsvPercent.v * hsvPercent.s, x = c * (1 - Math.abs((hsvPercent.h % 2) - 1));
+        let tempRgb;
+        if (hsvPercent.h >= 0 && hsvPercent.h <= 1) {
+            tempRgb = {
+                r: c,
+                g: x,
+                b: 0,
+            };
+        }
+        else if (hsvPercent.h > 1 && hsvPercent.h <= 2) {
+            tempRgb = {
+                r: x,
+                g: c,
+                b: 0,
+            };
+        }
+        else if (hsvPercent.h > 2 && hsvPercent.h <= 3) {
+            tempRgb = {
+                r: 0,
+                g: c,
+                b: x,
+            };
+        }
+        else if (hsvPercent.h > 3 && hsvPercent.h <= 4) {
+            tempRgb = {
+                r: 0,
+                g: x,
+                b: c,
+            };
+        }
+        else if (hsvPercent.h > 4 && hsvPercent.h <= 5) {
+            tempRgb = {
+                r: x,
+                g: 0,
+                b: c,
+            };
+        }
+        else if (hsvPercent.h > 5 && hsvPercent.h <= 6) {
+            tempRgb = {
+                r: c,
+                g: 0,
+                b: x,
+            };
+        }
+        if (tempRgb) {
+            const m = hsvPercent.v - c;
+            result.r = Math.floor((tempRgb.r + m) * 255);
+            result.g = Math.floor((tempRgb.g + m) * 255);
+            result.b = Math.floor((tempRgb.b + m) * 255);
+        }
+        return result;
+    }
+    exports.hsvToRgb = hsvToRgb;
+    function hsvaToRgba(hsva) {
+        const rgbResult = hsvToRgb(hsva);
+        return {
+            a: hsva.a,
+            b: rgbResult.b,
+            g: rgbResult.g,
+            r: rgbResult.r,
+        };
+    }
+    exports.hsvaToRgba = hsvaToRgba;
+    function rgbToHsv(rgb) {
+        const rgbPercent = {
+            r: rgb.r / 255,
+            g: rgb.g / 255,
+            b: rgb.b / 255,
+        }, xMax = Math.max(rgbPercent.r, rgbPercent.g, rgbPercent.b), xMin = Math.min(rgbPercent.r, rgbPercent.g, rgbPercent.b), v = xMax, c = xMax - xMin;
+        let h = 0;
+        if (v === rgbPercent.r) {
+            h = 60 * ((rgbPercent.g - rgbPercent.b) / c);
+        }
+        else if (v === rgbPercent.g) {
+            h = 60 * (2 + (rgbPercent.b - rgbPercent.r) / c);
+        }
+        else if (v === rgbPercent.b) {
+            h = 60 * (4 + (rgbPercent.r - rgbPercent.g) / c);
+        }
+        const s = !v ? 0 : c / v;
+        return {
+            h,
+            s: s * 100,
+            v: v * 100,
+        };
+    }
+    exports.rgbToHsv = rgbToHsv;
+    function rgbaToHsva(rgba) {
+        const hsvResult = rgbToHsv(rgba);
+        return {
+            a: rgba.a,
+            h: hsvResult.h,
+            s: hsvResult.s,
+            v: hsvResult.v,
+        };
+    }
+    exports.rgbaToHsva = rgbaToHsva;
+    function getRandomRgbColor(min) {
+        const fixedMin = min !== null && min !== void 0 ? min : 0;
+        return {
+            b: Math.floor((0, NumberUtils_1.randomInRange)((0, NumberUtils_1.setRangeValue)(fixedMin, 256))),
+            g: Math.floor((0, NumberUtils_1.randomInRange)((0, NumberUtils_1.setRangeValue)(fixedMin, 256))),
+            r: Math.floor((0, NumberUtils_1.randomInRange)((0, NumberUtils_1.setRangeValue)(fixedMin, 256))),
+        };
+    }
+    exports.getRandomRgbColor = getRandomRgbColor;
+    function getStyleFromRgb(color, opacity) {
+        return `rgba(${color.r}, ${color.g}, ${color.b}, ${opacity !== null && opacity !== void 0 ? opacity : 1})`;
+    }
+    exports.getStyleFromRgb = getStyleFromRgb;
+    function getStyleFromHsl(color, opacity) {
+        return `hsla(${color.h}, ${color.s}%, ${color.l}%, ${opacity !== null && opacity !== void 0 ? opacity : 1})`;
+    }
+    exports.getStyleFromHsl = getStyleFromHsl;
+    function getStyleFromHsv(color, opacity) {
+        return getStyleFromHsl(hsvToHsl(color), opacity);
+    }
+    exports.getStyleFromHsv = getStyleFromHsv;
+    function colorMix(color1, color2, size1, size2) {
+        let rgb1 = color1;
+        let rgb2 = color2;
+        if (rgb1.r === undefined) {
+            rgb1 = hslToRgb(color1);
+        }
+        if (rgb2.r === undefined) {
+            rgb2 = hslToRgb(color2);
+        }
+        return {
+            b: (0, NumberUtils_1.mix)(rgb1.b, rgb2.b, size1, size2),
+            g: (0, NumberUtils_1.mix)(rgb1.g, rgb2.g, size1, size2),
+            r: (0, NumberUtils_1.mix)(rgb1.r, rgb2.r, size1, size2),
+        };
+    }
+    exports.colorMix = colorMix;
+    function getLinkColor(p1, p2, linkColor) {
+        var _a, _b;
+        if (linkColor === Core_1.Constants.randomColorValue) {
+            return getRandomRgbColor();
+        }
+        else if (linkColor === "mid") {
+            const sourceColor = (_a = p1.getFillColor()) !== null && _a !== void 0 ? _a : p1.getStrokeColor();
+            const destColor = (_b = p2 === null || p2 === void 0 ? void 0 : p2.getFillColor()) !== null && _b !== void 0 ? _b : p2 === null || p2 === void 0 ? void 0 : p2.getStrokeColor();
+            if (sourceColor && destColor && p2) {
+                return colorMix(sourceColor, destColor, p1.getRadius(), p2.getRadius());
+            }
+            else {
+                const hslColor = sourceColor !== null && sourceColor !== void 0 ? sourceColor : destColor;
+                if (hslColor) {
+                    return hslToRgb(hslColor);
+                }
+            }
+        }
+        else {
+            return linkColor;
+        }
+    }
+    exports.getLinkColor = getLinkColor;
+    function getLinkRandomColor(optColor, blink, consent) {
+        const color = typeof optColor === "string" ? optColor : optColor.value;
+        if (color === Core_1.Constants.randomColorValue) {
+            if (consent) {
+                return colorToRgb({
+                    value: color,
+                });
+            }
+            else if (blink) {
+                return Core_1.Constants.randomColorValue;
+            }
+            else {
+                return Core_1.Constants.midColorValue;
+            }
+        }
+        else {
+            return colorToRgb({
+                value: color,
+            });
+        }
+    }
+    exports.getLinkRandomColor = getLinkRandomColor;
+    function getHslFromAnimation(animation) {
+        return animation !== undefined
+            ? {
+                h: animation.h.value,
+                s: animation.s.value,
+                l: animation.l.value,
+            }
+            : undefined;
+    }
+    exports.getHslFromAnimation = getHslFromAnimation;
+    function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
+        const resColor = {
+            h: {
+                enable: false,
+                value: hsl.h,
+            },
+            s: {
+                enable: false,
+                value: hsl.s,
+            },
+            l: {
+                enable: false,
+                value: hsl.l,
+            },
+        };
+        if (animationOptions) {
+            setColorAnimation(resColor.h, animationOptions.h, reduceFactor);
+            setColorAnimation(resColor.s, animationOptions.s, reduceFactor);
+            setColorAnimation(resColor.l, animationOptions.l, reduceFactor);
+        }
+        return resColor;
+    }
+    exports.getHslAnimationFromHsl = getHslAnimationFromHsl;
+    function setColorAnimation(colorValue, colorAnimation, reduceFactor) {
+        colorValue.enable = colorAnimation.enable;
+        if (colorValue.enable) {
+            colorValue.velocity = (colorAnimation.speed / 100) * reduceFactor;
+            if (colorAnimation.sync) {
+                return;
+            }
+            colorValue.status = 0;
+            colorValue.velocity *= Math.random();
+            if (colorValue.value) {
+                colorValue.value *= Math.random();
+            }
+        }
+        else {
+            colorValue.velocity = 0;
+        }
+    }
+});

package/umd/Utils/NumberUtils.d.ts

@@ -0,0 +1,23 @@
+import { EasingType, MoveDirection, MoveDirectionAlt } from "../Enums";
+import type { ICoordinates } from "../Core";
+import type { IValueWithRandom } from "../Options/Interfaces/IValueWithRandom";
+import { RangeValue } from "../Types";
+import { Vector } from "../Core";
+export declare function clamp(num: number, min: number, max: number): number;
+export declare function mix(comp1: number, comp2: number, weight1: number, weight2: number): number;
+export declare function randomInRange(r: RangeValue): number;
+export declare function getRangeValue(value: RangeValue): number;
+export declare function getRangeMin(value: RangeValue): number;
+export declare function getRangeMax(value: RangeValue): number;
+export declare function setRangeValue(source: RangeValue, value?: number): RangeValue;
+export declare function getValue(options: IValueWithRandom): number;
+export declare function getDistances(pointA: ICoordinates, pointB: ICoordinates): {
+    dx: number;
+    dy: number;
+    distance: number;
+};
+export declare function getDistance(pointA: ICoordinates, pointB: ICoordinates): number;
+export declare function getParticleDirectionAngle(direction: MoveDirection | keyof typeof MoveDirection | MoveDirectionAlt | number): number;
+export declare function getParticleBaseVelocity(direction: number): Vector;
+export declare function collisionVelocity(v1: Vector, v2: Vector, m1: number, m2: number): Vector;
+export declare function calcEasing(value: number, type: EasingType): number;

package/umd/Utils/NumberUtils.js

@@ -0,0 +1,138 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../Core"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.calcEasing = exports.collisionVelocity = exports.getParticleBaseVelocity = exports.getParticleDirectionAngle = exports.getDistance = exports.getDistances = exports.getValue = exports.setRangeValue = exports.getRangeMax = exports.getRangeMin = exports.getRangeValue = exports.randomInRange = exports.mix = exports.clamp = void 0;
+    const Core_1 = require("../Core");
+    function clamp(num, min, max) {
+        return Math.min(Math.max(num, min), max);
+    }
+    exports.clamp = clamp;
+    function mix(comp1, comp2, weight1, weight2) {
+        return Math.floor((comp1 * weight1 + comp2 * weight2) / (weight1 + weight2));
+    }
+    exports.mix = mix;
+    function randomInRange(r) {
+        const max = getRangeMax(r);
+        let min = getRangeMin(r);
+        if (max === min) {
+            min = 0;
+        }
+        return Math.random() * (max - min) + min;
+    }
+    exports.randomInRange = randomInRange;
+    function getRangeValue(value) {
+        return typeof value === "number" ? value : randomInRange(value);
+    }
+    exports.getRangeValue = getRangeValue;
+    function getRangeMin(value) {
+        return typeof value === "number" ? value : value.min;
+    }
+    exports.getRangeMin = getRangeMin;
+    function getRangeMax(value) {
+        return typeof value === "number" ? value : value.max;
+    }
+    exports.getRangeMax = getRangeMax;
+    function setRangeValue(source, value) {
+        if (source === value || (value === undefined && typeof source === "number")) {
+            return source;
+        }
+        const min = getRangeMin(source), max = getRangeMax(source);
+        return value !== undefined
+            ? {
+                min: Math.min(min, value),
+                max: Math.max(max, value),
+            }
+            : setRangeValue(min, max);
+    }
+    exports.setRangeValue = setRangeValue;
+    function getValue(options) {
+        const random = options.random;
+        const { enable, minimumValue } = typeof random === "boolean" ? { enable: random, minimumValue: 0 } : random;
+        return enable ? getRangeValue(setRangeValue(options.value, minimumValue)) : getRangeValue(options.value);
+    }
+    exports.getValue = getValue;
+    function getDistances(pointA, pointB) {
+        const dx = pointA.x - pointB.x;
+        const dy = pointA.y - pointB.y;
+        return { dx: dx, dy: dy, distance: Math.sqrt(dx * dx + dy * dy) };
+    }
+    exports.getDistances = getDistances;
+    function getDistance(pointA, pointB) {
+        return getDistances(pointA, pointB).distance;
+    }
+    exports.getDistance = getDistance;
+    function getParticleDirectionAngle(direction) {
+        if (typeof direction === "number") {
+            return (direction * Math.PI) / 180;
+        }
+        else {
+            switch (direction) {
+                case "top":
+                    return -Math.PI / 2;
+                case "top-right":
+                    return -Math.PI / 4;
+                case "right":
+                    return 0;
+                case "bottom-right":
+                    return Math.PI / 4;
+                case "bottom":
+                    return Math.PI / 2;
+                case "bottom-left":
+                    return (3 * Math.PI) / 4;
+                case "left":
+                    return Math.PI;
+                case "top-left":
+                    return (-3 * Math.PI) / 4;
+                case "none":
+                default:
+                    return Math.random() * Math.PI * 2;
+            }
+        }
+    }
+    exports.getParticleDirectionAngle = getParticleDirectionAngle;
+    function getParticleBaseVelocity(direction) {
+        const baseVelocity = Core_1.Vector.origin;
+        baseVelocity.length = 1;
+        baseVelocity.angle = direction;
+        return baseVelocity;
+    }
+    exports.getParticleBaseVelocity = getParticleBaseVelocity;
+    function collisionVelocity(v1, v2, m1, m2) {
+        return Core_1.Vector.create((v1.x * (m1 - m2)) / (m1 + m2) + (v2.x * 2 * m2) / (m1 + m2), v1.y);
+    }
+    exports.collisionVelocity = collisionVelocity;
+    function calcEasing(value, type) {
+        switch (type) {
+            case "ease-out-quad":
+                return 1 - (1 - value) ** 2;
+            case "ease-out-cubic":
+                return 1 - (1 - value) ** 3;
+            case "ease-out-quart":
+                return 1 - (1 - value) ** 4;
+            case "ease-out-quint":
+                return 1 - (1 - value) ** 5;
+            case "ease-out-expo":
+                return value === 1 ? 1 : 1 - Math.pow(2, -10 * value);
+            case "ease-out-sine":
+                return Math.sin((value * Math.PI) / 2);
+            case "ease-out-back": {
+                const c1 = 1.70158;
+                const c3 = c1 + 1;
+                return 1 + c3 * Math.pow(value - 1, 3) + c1 * Math.pow(value - 1, 2);
+            }
+            case "ease-out-circ":
+                return Math.sqrt(1 - Math.pow(value - 1, 2));
+            default:
+                return value;
+        }
+    }
+    exports.calcEasing = calcEasing;
+});

package/umd/Utils/Utils.d.ts

@@ -0,0 +1,38 @@
+import { DivMode, OutModeDirection } from "../Enums";
+import type { IBounds, ICircleBouncer, ICoordinates, IDimension, IParticle } from "../Core";
+import { DivEvent } from "../Options/Classes/Interactivity/Events/DivEvent";
+import type { ICharacterShape } from "../Options/Interfaces/Particles/Shape/ICharacterShape";
+import type { IModeDiv } from "../Options/Interfaces/Interactivity/Modes/IModeDiv";
+import type { SingleOrMultiple } from "../Types";
+declare global {
+    interface Window {
+        customRequestAnimationFrame: (callback: FrameRequestCallback) => number;
+        mozRequestAnimationFrame: (callback: FrameRequestCallback) => number;
+        oRequestAnimationFrame: (callback: FrameRequestCallback) => number;
+        msRequestAnimationFrame: (callback: FrameRequestCallback) => number;
+        webkitRequestAnimationFrame: (callback: FrameRequestCallback) => number;
+        customCancelRequestAnimationFrame: (handle: number) => void;
+        webkitCancelRequestAnimationFrame: (handle: number) => void;
+        mozCancelRequestAnimationFrame: (handle: number) => void;
+        oCancelRequestAnimationFrame: (handle: number) => void;
+        msCancelRequestAnimationFrame: (handle: number) => void;
+    }
+}
+export declare function isSsr(): boolean;
+export declare function animate(): (callback: FrameRequestCallback) => number;
+export declare function cancelAnimation(): (handle: number) => void;
+export declare function isInArray<T>(value: T, array: SingleOrMultiple<T>): boolean;
+export declare function loadFont(character: ICharacterShape): Promise<void>;
+export declare function arrayRandomIndex<T>(array: T[]): number;
+export declare function itemFromArray<T>(array: T[], index?: number, useIndex?: boolean): T;
+export declare function isPointInside(point: ICoordinates, size: IDimension, radius?: number, direction?: OutModeDirection): boolean;
+export declare function areBoundsInside(bounds: IBounds, size: IDimension, direction?: OutModeDirection): boolean;
+export declare function calculateBounds(point: ICoordinates, radius: number): IBounds;
+export declare function deepExtend(destination: unknown, ...sources: unknown[]): unknown;
+export declare function isDivModeEnabled(mode: DivMode, divs: SingleOrMultiple<DivEvent>): boolean;
+export declare function divModeExecute(mode: DivMode, divs: SingleOrMultiple<DivEvent>, callback: (id: string, div: DivEvent) => void): void;
+export declare function singleDivModeExecute(div: DivEvent, callback: (selector: string, div: DivEvent) => void): void;
+export declare function divMode<T extends IModeDiv>(divs?: SingleOrMultiple<T>, element?: HTMLElement): T | undefined;
+export declare function circleBounceDataFromParticle(p: IParticle): ICircleBouncer;
+export declare function circleBounce(p1: ICircleBouncer, p2: ICircleBouncer): void;
+export declare function rectBounce(particle: IParticle, divBounds: IBounds): void;