@tsparticles/engine 3.9.0 → 4.0.0-alpha.0

package/cjs/Utils/ColorUtils.js

@@ -1,50 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rangeColorToRgb = rangeColorToRgb;
-exports.colorToRgb = colorToRgb;
-exports.colorToHsl = colorToHsl;
-exports.rangeColorToHsl = rangeColorToHsl;
-exports.rgbToHsl = rgbToHsl;
-exports.stringToAlpha = stringToAlpha;
-exports.stringToRgb = stringToRgb;
-exports.hslToRgb = hslToRgb;
-exports.hslaToRgba = hslaToRgba;
-exports.getRandomRgbColor = getRandomRgbColor;
-exports.getStyleFromRgb = getStyleFromRgb;
-exports.getStyleFromHsl = getStyleFromHsl;
-exports.colorMix = colorMix;
-exports.getLinkColor = getLinkColor;
-exports.getLinkRandomColor = getLinkRandomColor;
-exports.getHslFromAnimation = getHslFromAnimation;
-exports.getHslAnimationFromHsl = getHslAnimationFromHsl;
-exports.updateColorValue = updateColorValue;
-exports.updateColor = updateColor;
-const NumberUtils_js_1 = require("./NumberUtils.js");
-const Constants_js_1 = require("../Core/Utils/Constants.js");
-const TypeUtils_js_1 = require("./TypeUtils.js");
-const AnimationStatus_js_1 = require("../Enums/AnimationStatus.js");
-const Utils_js_1 = require("./Utils.js");
+import { clamp, getRandom, getRandomInRange, getRangeMax, getRangeMin, getRangeValue, mix, randomInRangeValue, setRangeValue, } from "./MathUtils.js";
+import { decayOffset, defaultLoops, defaultOpacity, defaultRgbMin, defaultTime, defaultVelocity, double, hMax, hMin, hPhase, half, identity, lMax, lMin, midColorValue, millisecondsToSeconds, percentDenominator, phaseNumerator, randomColorValue, rgbMax, sMax, sMin, sNormalizedOffset, sextuple, triple, } from "../Core/Utils/Constants.js";
+import { isArray, isString } from "./TypeUtils.js";
+import { AnimationStatus } from "../Enums/AnimationStatus.js";
+import { itemFromArray } from "./Utils.js";
 function stringToRgba(engine, input) {
     if (!input) {
         return;
     }
     for (const manager of engine.colorManagers.values()) {
-        if (input.startsWith(manager.stringPrefix)) {
+        if (manager.accepts(input)) {
             return manager.parseString(input);
         }
     }
+    return undefined;
 }
-function rangeColorToRgb(engine, input, index, useIndex = true) {
+export function rangeColorToRgb(engine, input, index, useIndex = true) {
     if (!input) {
         return;
     }
-    const color = (0, TypeUtils_js_1.isString)(input) ? { value: input } : input;
-    if ((0, TypeUtils_js_1.isString)(color.value)) {
+    const color = isString(input) ? { value: input } : input;
+    if (isString(color.value)) {
         return colorToRgb(engine, color.value, index, useIndex);
     }
-    if ((0, TypeUtils_js_1.isArray)(color.value)) {
+    if (isArray(color.value)) {
+        const value = itemFromArray(color.value, index, useIndex);
+        if (!value) {
+            return;
+        }
         return rangeColorToRgb(engine, {
-            value: (0, Utils_js_1.itemFromArray)(color.value, index, useIndex),
+            value,
         });
     }
     for (const manager of engine.colorManagers.values()) {
@@ -53,18 +37,23 @@ function rangeColorToRgb(engine, input, index, useIndex = true) {
             return res;
         }
     }
+    return undefined;
 }
-function colorToRgb(engine, input, index, useIndex = true) {
+export function colorToRgb(engine, input, index, useIndex = true) {
     if (!input) {
         return;
     }
-    const color = (0, TypeUtils_js_1.isString)(input) ? { value: input } : input;
-    if ((0, TypeUtils_js_1.isString)(color.value)) {
-        return color.value === Constants_js_1.randomColorValue ? getRandomRgbColor() : stringToRgb(engine, color.value);
+    const color = isString(input) ? { value: input } : input;
+    if (isString(color.value)) {
+        return color.value === randomColorValue ? getRandomRgbColor() : stringToRgb(engine, color.value);
     }
-    if ((0, TypeUtils_js_1.isArray)(color.value)) {
+    if (isArray(color.value)) {
+        const value = itemFromArray(color.value, index, useIndex);
+        if (!value) {
+            return;
+        }
         return colorToRgb(engine, {
-            value: (0, Utils_js_1.itemFromArray)(color.value, index, useIndex),
+            value,
         });
     }
     for (const manager of engine.colorManagers.values()) {
@@ -73,49 +62,55 @@ function colorToRgb(engine, input, index, useIndex = true) {
             return res;
         }
     }
+    return undefined;
 }
-function colorToHsl(engine, color, index, useIndex = true) {
+export function colorToHsl(engine, color, index, useIndex = true) {
     const rgb = colorToRgb(engine, color, index, useIndex);
     return rgb ? rgbToHsl(rgb) : undefined;
 }
-function rangeColorToHsl(engine, color, index, useIndex = true) {
+export function rangeColorToHsl(engine, color, index, useIndex = true) {
     const rgb = rangeColorToRgb(engine, color, index, useIndex);
     return rgb ? rgbToHsl(rgb) : undefined;
 }
-function rgbToHsl(color) {
-    const r1 = color.r / Constants_js_1.rgbMax, g1 = color.g / Constants_js_1.rgbMax, b1 = color.b / Constants_js_1.rgbMax, max = Math.max(r1, g1, b1), min = Math.min(r1, g1, b1), res = {
-        h: Constants_js_1.hMin,
-        l: (max + min) * Constants_js_1.half,
-        s: Constants_js_1.sMin,
+export function rgbToHsl(color) {
+    const 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 < Constants_js_1.half ? (max - min) / (max + min) : (max - min) / (Constants_js_1.double - max - min);
-        res.h =
-            r1 === max
-                ? (g1 - b1) / (max - min)
-                : (res.h = g1 === max ? Constants_js_1.double + (b1 - r1) / (max - min) : Constants_js_1.double * Constants_js_1.double + (r1 - g1) / (max - min));
+        res.s = res.l < half ? (max - min) / (max + min) : (max - min) / (double - max - min);
+        if (r1 === max) {
+            res.h = (g1 - b1) / (max - min);
+        }
+        else if (g1 === max) {
+            res.h = double + (b1 - r1) / (max - min);
+        }
+        else {
+            res.h = double * double + (r1 - g1) / (max - min);
+        }
     }
-    res.l *= Constants_js_1.lMax;
-    res.s *= Constants_js_1.sMax;
-    res.h *= Constants_js_1.hPhase;
-    if (res.h < Constants_js_1.hMin) {
-        res.h += Constants_js_1.hMax;
+    res.l *= lMax;
+    res.s *= sMax;
+    res.h *= hPhase;
+    if (res.h < hMin) {
+        res.h += hMax;
     }
-    if (res.h >= Constants_js_1.hMax) {
-        res.h -= Constants_js_1.hMax;
+    if (res.h >= hMax) {
+        res.h -= hMax;
     }
     return res;
 }
-function stringToAlpha(engine, input) {
+export function stringToAlpha(engine, input) {
     return stringToRgba(engine, input)?.a;
 }
-function stringToRgb(engine, input) {
+export function stringToRgb(engine, input) {
     return stringToRgba(engine, input);
 }
-function hslToRgb(hsl) {
-    const h = ((hsl.h % Constants_js_1.hMax) + Constants_js_1.hMax) % Constants_js_1.hMax, s = Math.max(Constants_js_1.sMin, Math.min(Constants_js_1.sMax, hsl.s)), l = Math.max(Constants_js_1.lMin, Math.min(Constants_js_1.lMax, hsl.l)), hNormalized = h / Constants_js_1.hMax, sNormalized = s / Constants_js_1.sMax, lNormalized = l / Constants_js_1.lMax;
-    if (s === Constants_js_1.sMin) {
-        const grayscaleValue = Math.round(lNormalized * Constants_js_1.rgbFactor);
+export function hslToRgb(hsl) {
+    const 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;
+    if (s === sMin) {
+        const grayscaleValue = Math.round(lNormalized * rgbMax);
         return { r: grayscaleValue, g: grayscaleValue, b: grayscaleValue };
     }
     const channel = (temp1, temp2, temp3) => {
@@ -126,23 +121,23 @@ function hslToRgb(hsl) {
         if (temp3 > temp3Max) {
             temp3--;
         }
-        if (temp3 * Constants_js_1.sextuple < temp3Max) {
-            return temp1 + (temp2 - temp1) * Constants_js_1.sextuple * temp3;
+        if (temp3 * sextuple < temp3Max) {
+            return temp1 + (temp2 - temp1) * sextuple * temp3;
         }
-        if (temp3 * Constants_js_1.double < temp3Max) {
+        if (temp3 * double < temp3Max) {
             return temp2;
         }
-        if (temp3 * Constants_js_1.triple < temp3Max * Constants_js_1.double) {
-            const temp3Offset = Constants_js_1.double / Constants_js_1.triple;
-            return temp1 + (temp2 - temp1) * (temp3Offset - temp3) * Constants_js_1.sextuple;
+        if (temp3 * triple < temp3Max * double) {
+            const temp3Offset = double / triple;
+            return temp1 + (temp2 - temp1) * (temp3Offset - temp3) * sextuple;
         }
         return temp1;
-    }, temp1 = lNormalized < Constants_js_1.half
-        ? lNormalized * (Constants_js_1.sNormalizedOffset + sNormalized)
-        : lNormalized + sNormalized - lNormalized * sNormalized, temp2 = Constants_js_1.double * lNormalized - temp1, phaseThird = Constants_js_1.phaseNumerator / Constants_js_1.triple, red = Math.min(Constants_js_1.rgbFactor, Constants_js_1.rgbFactor * channel(temp2, temp1, hNormalized + phaseThird)), green = Math.min(Constants_js_1.rgbFactor, Constants_js_1.rgbFactor * channel(temp2, temp1, hNormalized)), blue = Math.min(Constants_js_1.rgbFactor, Constants_js_1.rgbFactor * channel(temp2, temp1, hNormalized - phaseThird));
+    }, temp1 = lNormalized < half
+        ? lNormalized * (sNormalizedOffset + sNormalized)
+        : lNormalized + sNormalized - lNormalized * sNormalized, temp2 = double * lNormalized - temp1, phaseThird = phaseNumerator / triple, red = Math.min(rgbMax, rgbMax * channel(temp2, temp1, hNormalized + phaseThird)), green = Math.min(rgbMax, rgbMax * channel(temp2, temp1, hNormalized)), blue = Math.min(rgbMax, rgbMax * channel(temp2, temp1, hNormalized - phaseThird));
     return { r: Math.round(red), g: Math.round(green), b: Math.round(blue) };
 }
-function hslaToRgba(hsla) {
+export function hslaToRgba(hsla) {
     const rgbResult = hslToRgb(hsla);
     return {
         a: hsla.a,
@@ -151,39 +146,51 @@ function hslaToRgba(hsla) {
         r: rgbResult.r,
     };
 }
-function getRandomRgbColor(min) {
-    const fixedMin = min ?? Constants_js_1.defaultRgbMin, fixedMax = Constants_js_1.rgbMax + Constants_js_1.identity;
+export function getRandomRgbColor(min) {
+    const fixedMin = min ?? defaultRgbMin, fixedMax = rgbMax + identity, getRgbInRangeValue = () => Math.floor(getRandomInRange(fixedMin, fixedMax));
     return {
-        b: Math.floor((0, NumberUtils_js_1.randomInRange)((0, NumberUtils_js_1.setRangeValue)(fixedMin, fixedMax))),
-        g: Math.floor((0, NumberUtils_js_1.randomInRange)((0, NumberUtils_js_1.setRangeValue)(fixedMin, fixedMax))),
-        r: Math.floor((0, NumberUtils_js_1.randomInRange)((0, NumberUtils_js_1.setRangeValue)(fixedMin, fixedMax))),
+        b: getRgbInRangeValue(),
+        g: getRgbInRangeValue(),
+        r: getRgbInRangeValue(),
     };
 }
-function getStyleFromRgb(color, opacity) {
-    return `rgba(${color.r}, ${color.g}, ${color.b}, ${opacity ?? Constants_js_1.defaultOpacity})`;
+export function getStyleFromRgb(color, hdr, opacity) {
+    return hdr ? getHdrStyleFromRgb(color, opacity) : getSdrStyleFromRgb(color, opacity);
+}
+function getHdrStyleFromRgb(color, opacity) {
+    return `color(display-p3 ${(color.r / rgbMax).toString()} ${(color.g / rgbMax).toString()} ${(color.b / rgbMax).toString()} / ${(opacity ?? defaultOpacity).toString()})`;
+}
+function getSdrStyleFromRgb(color, opacity) {
+    return `rgba(${color.r.toString()}, ${color.g.toString()}, ${color.b.toString()}, ${(opacity ?? defaultOpacity).toString()})`;
 }
-function getStyleFromHsl(color, opacity) {
-    return `hsla(${color.h}, ${color.s}%, ${color.l}%, ${opacity ?? Constants_js_1.defaultOpacity})`;
+export function getStyleFromHsl(color, hdr, opacity) {
+    return hdr ? getHdrStyleFromHsl(color, opacity) : getSdrStyleFromHsl(color, opacity);
 }
-function colorMix(color1, color2, size1, size2) {
+function getHdrStyleFromHsl(color, opacity) {
+    return getHdrStyleFromRgb(hslToRgb(color), opacity);
+}
+function getSdrStyleFromHsl(color, opacity) {
+    return `hsla(${color.h.toString()}, ${color.s.toString()}%, ${color.l.toString()}%, ${(opacity ?? defaultOpacity).toString()})`;
+}
+export function colorMix(color1, color2, size1, size2) {
     let rgb1 = color1, rgb2 = color2;
-    if (rgb1.r === undefined) {
+    if (!Object.hasOwn(rgb1, "r")) {
         rgb1 = hslToRgb(color1);
     }
-    if (rgb2.r === undefined) {
+    if (!Object.hasOwn(rgb2, "r")) {
         rgb2 = hslToRgb(color2);
     }
     return {
-        b: (0, NumberUtils_js_1.mix)(rgb1.b, rgb2.b, size1, size2),
-        g: (0, NumberUtils_js_1.mix)(rgb1.g, rgb2.g, size1, size2),
-        r: (0, NumberUtils_js_1.mix)(rgb1.r, rgb2.r, size1, size2),
+        b: mix(rgb1.b, rgb2.b, size1, size2),
+        g: mix(rgb1.g, rgb2.g, size1, size2),
+        r: mix(rgb1.r, rgb2.r, size1, size2),
     };
 }
-function getLinkColor(p1, p2, linkColor) {
-    if (linkColor === Constants_js_1.randomColorValue) {
+export function getLinkColor(p1, p2, linkColor) {
+    if (linkColor === randomColorValue) {
         return getRandomRgbColor();
     }
-    else if (linkColor === Constants_js_1.midColorValue) {
+    else if (linkColor === midColorValue) {
         const sourceColor = p1.getFillColor() ?? p1.getStrokeColor(), destColor = p2?.getFillColor() ?? p2?.getStrokeColor();
         if (sourceColor && destColor && p2) {
             return colorMix(sourceColor, destColor, p1.getRadius(), p2.getRadius());
@@ -198,22 +205,23 @@ function getLinkColor(p1, p2, linkColor) {
     else {
         return linkColor;
     }
+    return undefined;
 }
-function getLinkRandomColor(engine, optColor, blink, consent) {
-    const color = (0, TypeUtils_js_1.isString)(optColor) ? optColor : optColor.value;
-    if (color === Constants_js_1.randomColorValue) {
+export function getLinkRandomColor(engine, optColor, blink, consent) {
+    const color = isString(optColor) ? optColor : optColor.value;
+    if (color === randomColorValue) {
         if (consent) {
             return rangeColorToRgb(engine, {
                 value: color,
             });
         }
         if (blink) {
-            return Constants_js_1.randomColorValue;
+            return randomColorValue;
         }
-        return Constants_js_1.midColorValue;
+        return midColorValue;
     }
-    else if (color === Constants_js_1.midColorValue) {
-        return Constants_js_1.midColorValue;
+    else if (color === midColorValue) {
+        return midColorValue;
     }
     else {
         return rangeColorToRgb(engine, {
@@ -221,7 +229,7 @@ function getLinkRandomColor(engine, optColor, blink, consent) {
         });
     }
 }
-function getHslFromAnimation(animation) {
+export function getHslFromAnimation(animation) {
     return animation !== undefined
         ? {
             h: animation.h.value,
@@ -230,7 +238,7 @@ function getHslFromAnimation(animation) {
         }
         : undefined;
 }
-function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
+export function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
     const resColor = {
         h: {
             enable: false,
@@ -255,50 +263,45 @@ function getHslAnimationFromHsl(hsl, animationOptions, reduceFactor) {
 function setColorAnimation(colorValue, colorAnimation, reduceFactor) {
     colorValue.enable = colorAnimation.enable;
     if (colorValue.enable) {
-        colorValue.velocity = ((0, NumberUtils_js_1.getRangeValue)(colorAnimation.speed) / Constants_js_1.percentDenominator) * reduceFactor;
-        colorValue.decay = Constants_js_1.decayOffset - (0, NumberUtils_js_1.getRangeValue)(colorAnimation.decay);
-        colorValue.status = AnimationStatus_js_1.AnimationStatus.increasing;
-        colorValue.loops = Constants_js_1.defaultLoops;
-        colorValue.maxLoops = (0, NumberUtils_js_1.getRangeValue)(colorAnimation.count);
-        colorValue.time = Constants_js_1.defaultTime;
-        colorValue.delayTime = (0, NumberUtils_js_1.getRangeValue)(colorAnimation.delay) * Constants_js_1.millisecondsToSeconds;
+        colorValue.velocity = (getRangeValue(colorAnimation.speed) / percentDenominator) * reduceFactor;
+        colorValue.decay = decayOffset - getRangeValue(colorAnimation.decay);
+        colorValue.status = AnimationStatus.increasing;
+        colorValue.loops = defaultLoops;
+        colorValue.maxLoops = getRangeValue(colorAnimation.count);
+        colorValue.time = defaultTime;
+        colorValue.delayTime = getRangeValue(colorAnimation.delay) * millisecondsToSeconds;
         if (!colorAnimation.sync) {
-            colorValue.velocity *= (0, NumberUtils_js_1.getRandom)();
-            colorValue.value *= (0, NumberUtils_js_1.getRandom)();
+            colorValue.velocity *= getRandom();
+            colorValue.value *= getRandom();
         }
         colorValue.initialValue = colorValue.value;
-        colorValue.offset = (0, NumberUtils_js_1.setRangeValue)(colorAnimation.offset);
+        colorValue.offset = setRangeValue(colorAnimation.offset);
     }
     else {
-        colorValue.velocity = Constants_js_1.defaultVelocity;
+        colorValue.velocity = defaultVelocity;
     }
 }
-function updateColorValue(data, range, decrease, delta) {
+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 ||
+    if (!data.enable ||
         ((data.maxLoops ?? minLoops) > minLoops && (data.loops ?? minLoops) > (data.maxLoops ?? minLoops))) {
         return;
     }
-    if (!data.time) {
-        data.time = 0;
-    }
+    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 ? (0, NumberUtils_js_1.randomInRange)(data.offset) : minOffset, velocity = (data.velocity ?? minVelocity) * delta.factor + offset * velocityFactor, decay = data.decay ?? identity, max = (0, NumberUtils_js_1.getRangeMax)(range), min = (0, NumberUtils_js_1.getRangeMin)(range);
-    if (!decrease || data.status === AnimationStatus_js_1.AnimationStatus.increasing) {
+    const offset = data.offset ? randomInRangeValue(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 === AnimationStatus.increasing) {
         data.value += velocity;
         if (data.value > max) {
-            if (!data.loops) {
-                data.loops = 0;
-            }
+            data.loops ??= 0;
             data.loops++;
             if (decrease) {
-                data.status = AnimationStatus_js_1.AnimationStatus.decreasing;
+                data.status = AnimationStatus.decreasing;
             }
             else {
                 data.value -= max;
@@ -309,34 +312,26 @@ function updateColorValue(data, range, decrease, delta) {
         data.value -= velocity;
         const minValue = 0;
         if (data.value < minValue) {
-            if (!data.loops) {
-                data.loops = 0;
-            }
+            data.loops ??= 0;
             data.loops++;
-            data.status = AnimationStatus_js_1.AnimationStatus.increasing;
+            data.status = AnimationStatus.increasing;
         }
     }
     if (data.velocity && decay !== identity) {
         data.velocity *= decay;
     }
-    data.value = (0, NumberUtils_js_1.clamp)(data.value, min, max);
+    data.value = clamp(data.value, min, max);
 }
-function updateColor(color, delta) {
+export function updateColor(color, delta) {
     if (!color) {
         return;
     }
     const { h, s, l } = color, ranges = {
-        h: { min: 0, max: 360 },
-        s: { min: 0, max: 100 },
-        l: { min: 0, max: 100 },
+        h: { min: hMin, max: hMax },
+        s: { min: sMin, max: sMax },
+        l: { min: lMin, max: lMax },
     };
-    if (h) {
-        updateColorValue(h, ranges.h, false, delta);
-    }
-    if (s) {
-        updateColorValue(s, ranges.s, true, delta);
-    }
-    if (l) {
-        updateColorValue(l, ranges.l, true, delta);
-    }
+    updateColorValue(h, ranges.h, false, delta);
+    updateColorValue(s, ranges.s, true, delta);
+    updateColorValue(l, ranges.l, true, delta);
 }

package/cjs/Utils/EventDispatcher.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventDispatcher = void 0;
-const Constants_js_1 = require("../Core/Utils/Constants.js");
-class EventDispatcher {
+import { deleteCount, minIndex } from "../Core/Utils/Constants.js";
+export class EventDispatcher {
     constructor() {
         this._listeners = new Map();
     }
@@ -17,7 +14,9 @@ class EventDispatcher {
     }
     dispatchEvent(type, args) {
         const listeners = this._listeners.get(type);
-        listeners?.forEach(handler => handler(args));
+        listeners?.forEach(handler => {
+            handler(args);
+        });
     }
     hasEventListener(type) {
         return !!this._listeners.get(type);
@@ -36,15 +35,14 @@ class EventDispatcher {
             return;
         }
         const length = arr.length, idx = arr.indexOf(listener);
-        if (idx < Constants_js_1.minIndex) {
+        if (idx < minIndex) {
             return;
         }
-        if (length === Constants_js_1.deleteCount) {
+        if (length === deleteCount) {
             this._listeners.delete(type);
         }
         else {
-            arr.splice(idx, Constants_js_1.deleteCount);
+            arr.splice(idx, deleteCount);
         }
     }
 }
-exports.EventDispatcher = EventDispatcher;

package/cjs/Utils/LogUtils.js

@@ -0,0 +1,22 @@
+const errorPrefix = "tsParticles - Error";
+const _logger = {
+    debug: console.debug,
+    error: (message, optionalParams) => {
+        console.error(`${errorPrefix} - ${message}`, optionalParams);
+    },
+    info: console.info,
+    log: console.log,
+    verbose: console.log,
+    warning: console.warn,
+};
+export function setLogger(logger) {
+    _logger.debug = logger.debug;
+    _logger.error = logger.error;
+    _logger.info = logger.info;
+    _logger.log = logger.log;
+    _logger.verbose = logger.verbose;
+    _logger.warning = logger.warning;
+}
+export function getLogger() {
+    return _logger;
+}

package/{esm/Utils/NumberUtils.js → cjs/Utils/MathUtils.js}

@@ -2,10 +2,13 @@ import { MoveDirection } from "../Enums/Directions/MoveDirection.js";
 import { double, doublePI, empty, half, percentDenominator, quarter, threeQuarter } from "../Core/Utils/Constants.js";
 import { Vector } from "../Core/Utils/Vectors.js";
 import { isNumber } from "./TypeUtils.js";
+const piDeg = 180, degToRadFactor = Math.PI / piDeg;
 let _random = Math.random;
 const _animationLoop = {
     nextFrame: (cb) => requestAnimationFrame(cb),
-    cancel: (idx) => cancelAnimationFrame(idx),
+    cancel: (idx) => {
+        cancelAnimationFrame(idx);
+    },
 };
 export function setRandom(rnd = Math.random) {
     _random = rnd;
@@ -14,9 +17,14 @@ export function getRandom() {
     const min = 0, max = 1;
     return clamp(_random(), min, max - Number.EPSILON);
 }
+export function getRandomInRange(min, max) {
+    return getRandom() * (max - min) + min;
+}
 export function setAnimationFunctions(nextFrame, cancel) {
     _animationLoop.nextFrame = (callback) => nextFrame(callback);
-    _animationLoop.cancel = (handle) => cancel(handle);
+    _animationLoop.cancel = (handle) => {
+        cancel(handle);
+    };
 }
 export function animate(fn) {
     return _animationLoop.nextFrame(fn);
@@ -30,16 +38,16 @@ export function clamp(num, min, max) {
 export function mix(comp1, comp2, weight1, weight2) {
     return Math.floor((comp1 * weight1 + comp2 * weight2) / (weight1 + weight2));
 }
-export function randomInRange(r) {
+export function randomInRangeValue(r) {
     const max = getRangeMax(r), minOffset = 0;
     let min = getRangeMin(r);
     if (max === min) {
         min = minOffset;
     }
-    return getRandom() * (max - min) + min;
+    return getRandomInRange(min, max);
 }
 export function getRangeValue(value) {
-    return isNumber(value) ? value : randomInRange(value);
+    return isNumber(value) ? value : randomInRangeValue(value);
 }
 export function getRangeMin(value) {
     return isNumber(value) ? value : value.min;
@@ -67,8 +75,7 @@ export function getDistance(pointA, pointB) {
     return getDistances(pointA, pointB).distance;
 }
 export function degToRad(degrees) {
-    const PIDeg = 180;
-    return (degrees * Math.PI) / PIDeg;
+    return degrees * degToRadFactor;
 }
 export function getParticleDirectionAngle(direction, position, center) {
     if (isNumber(direction)) {

package/cjs/Utils/OptionsUtils.js

@@ -1,15 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadOptions = loadOptions;
-exports.loadParticlesOptions = loadParticlesOptions;
-const ParticlesOptions_js_1 = require("../Options/Classes/Particles/ParticlesOptions.js");
-function loadOptions(options, ...sourceOptionsArr) {
+import { ParticlesOptions } from "../Options/Classes/Particles/ParticlesOptions.js";
+export function loadOptions(options, ...sourceOptionsArr) {
     for (const sourceOptions of sourceOptionsArr) {
         options.load(sourceOptions);
     }
 }
-function loadParticlesOptions(engine, container, ...sourceOptionsArr) {
-    const options = new ParticlesOptions_js_1.ParticlesOptions(engine, container);
+export function loadParticlesOptions(engine, container, ...sourceOptionsArr) {
+    const options = new ParticlesOptions(engine, container);
     loadOptions(options, ...sourceOptionsArr);
     return options;
 }

package/cjs/Utils/TypeUtils.js

@@ -1,30 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBoolean = isBoolean;
-exports.isString = isString;
-exports.isNumber = isNumber;
-exports.isFunction = isFunction;
-exports.isObject = isObject;
-exports.isArray = isArray;
-exports.isNull = isNull;
-function isBoolean(arg) {
+export function isBoolean(arg) {
     return typeof arg === "boolean";
 }
-function isString(arg) {
+export function isString(arg) {
     return typeof arg === "string";
 }
-function isNumber(arg) {
+export function isNumber(arg) {
     return typeof arg === "number";
 }
-function isFunction(arg) {
+export function isFunction(arg) {
     return typeof arg === "function";
 }
-function isObject(arg) {
+export function isObject(arg) {
     return typeof arg === "object" && arg !== null;
 }
-function isArray(arg) {
+export function isArray(arg) {
     return Array.isArray(arg);
 }
-function isNull(arg) {
+export function isNull(arg) {
     return arg === null || arg === undefined;
 }