tsparticles 1.34.1 → 1.35.0

package/Core/Particle.js

@@ -7,9 +7,19 @@ const Enums_1 = require("../Enums");
 const Utils_1 = require("../Utils");
 const Vector_1 = require("./Particle/Vector");
 const Vector3d_1 = require("./Particle/Vector3d");
+const fixOutMode = (data) => {
+    if ((0, Utils_1.isInArray)(data.outMode, data.checkModes) || (0, Utils_1.isInArray)(data.outMode, data.checkModes)) {
+        if (data.coord > data.maxCoord - data.radius * 2) {
+            data.setCb(-data.radius);
+        }
+        else if (data.coord < data.radius * 2) {
+            data.setCb(data.radius);
+        }
+    }
+};
 class Particle {
     constructor(id, container, position, overrideOptions, group) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         this.id = id;
         this.container = container;
         this.group = group;
@@ -20,20 +30,22 @@ class Particle {
         this.unbreakable = false;
         this.splitCount = 0;
         this.misplaced = false;
-        this.maxDistance = {};
+        this.retina = {
+            maxDistance: {},
+        };
         const pxRatio = container.retina.pixelRatio;
-        const options = container.actualOptions;
+        const mainOptions = container.actualOptions;
         const particlesOptions = new ParticlesOptions_1.ParticlesOptions();
-        particlesOptions.load(options.particles);
+        particlesOptions.load(mainOptions.particles);
         const shapeType = particlesOptions.shape.type;
         const reduceDuplicates = particlesOptions.reduceDuplicates;
-        this.shape = shapeType instanceof Array ? Utils_1.itemFromArray(shapeType, this.id, reduceDuplicates) : shapeType;
+        this.shape = shapeType instanceof Array ? (0, Utils_1.itemFromArray)(shapeType, this.id, reduceDuplicates) : shapeType;
         if (overrideOptions === null || overrideOptions === void 0 ? void 0 : overrideOptions.shape) {
             if (overrideOptions.shape.type) {
                 const overrideShapeType = overrideOptions.shape.type;
                 this.shape =
                     overrideShapeType instanceof Array
-                        ? Utils_1.itemFromArray(overrideShapeType, this.id, reduceDuplicates)
+                        ? (0, Utils_1.itemFromArray)(overrideShapeType, this.id, reduceDuplicates)
                         : overrideShapeType;
             }
             const shapeOptions = new Shape_1.Shape();
@@ -54,18 +66,15 @@ class Particle {
         this.fill = (_d = (_c = this.shapeData) === null || _c === void 0 ? void 0 : _c.fill) !== null && _d !== void 0 ? _d : this.fill;
         this.close = (_f = (_e = this.shapeData) === null || _e === void 0 ? void 0 : _e.close) !== null && _f !== void 0 ? _f : this.close;
         this.options = particlesOptions;
-        const zIndexValue = Utils_1.getRangeValue(this.options.zIndex.value);
-        this.pathDelay = Utils_1.getValue(this.options.move.path.delay) * 1000;
-        this.wobbleDistance = 0;
+        this.pathDelay = (0, Utils_1.getValue)(this.options.move.path.delay) * 1000;
+        const zIndexValue = (0, Utils_1.getRangeValue)(this.options.zIndex.value);
         container.retina.initParticle(this);
-        const sizeOptions = this.options.size;
-        const sizeValue = Utils_1.getValue(sizeOptions) * container.retina.pixelRatio;
-        const sizeRange = sizeOptions.value;
+        const sizeOptions = this.options.size, sizeRange = sizeOptions.value;
         this.size = {
             enable: sizeOptions.animation.enable,
-            value: sizeValue,
-            max: Utils_1.getRangeMax(sizeRange) * pxRatio,
-            min: Utils_1.getRangeMin(sizeRange) * pxRatio,
+            value: (0, Utils_1.getValue)(sizeOptions) * container.retina.pixelRatio,
+            max: (0, Utils_1.getRangeMax)(sizeRange) * pxRatio,
+            min: (0, Utils_1.getRangeMin)(sizeRange) * pxRatio,
             loops: 0,
             maxLoops: sizeOptions.animation.count,
         };
@@ -78,7 +87,7 @@ class Particle {
                     this.size.status = Enums_1.AnimationStatus.increasing;
                     break;
                 case Enums_1.StartValueType.random:
-                    this.size.value = Utils_1.randomInRange(this.size) * pxRatio;
+                    this.size.value = (0, Utils_1.randomInRange)(this.size) * pxRatio;
                     this.size.status = Math.random() >= 0.5 ? Enums_1.AnimationStatus.increasing : Enums_1.AnimationStatus.decreasing;
                     break;
                 case Enums_1.StartValueType.max:
@@ -88,229 +97,26 @@ class Particle {
                     break;
             }
             this.size.velocity =
-                (((_g = this.sizeAnimationSpeed) !== null && _g !== void 0 ? _g : container.retina.sizeAnimationSpeed) / 100) *
+                (((_g = this.retina.sizeAnimationSpeed) !== null && _g !== void 0 ? _g : container.retina.sizeAnimationSpeed) / 100) *
                     container.retina.reduceFactor;
             if (!sizeAnimation.sync) {
                 this.size.velocity *= Math.random();
             }
         }
-        this.direction = Utils_1.getParticleDirectionAngle(this.options.move.direction);
+        this.direction = (0, Utils_1.getParticleDirectionAngle)(this.options.move.direction);
         this.bubble = {
             inRange: false,
         };
         this.initialVelocity = this.calculateVelocity();
         this.velocity = this.initialVelocity.copy();
-        const rotateOptions = this.options.rotate;
-        this.rotate = {
-            enable: rotateOptions.animation.enable,
-            value: (Utils_1.getRangeValue(rotateOptions.value) * Math.PI) / 180,
-        };
-        let rotateDirection = rotateOptions.direction;
-        if (rotateDirection === Enums_1.RotateDirection.random) {
-            const index = Math.floor(Math.random() * 2);
-            rotateDirection = index > 0 ? Enums_1.RotateDirection.counterClockwise : Enums_1.RotateDirection.clockwise;
-        }
-        switch (rotateDirection) {
-            case Enums_1.RotateDirection.counterClockwise:
-            case "counterClockwise":
-                this.rotate.status = Enums_1.AnimationStatus.decreasing;
-                break;
-            case Enums_1.RotateDirection.clockwise:
-                this.rotate.status = Enums_1.AnimationStatus.increasing;
-                break;
-        }
-        const rotateAnimation = this.options.rotate.animation;
-        if (rotateAnimation.enable) {
-            this.rotate.velocity = (rotateAnimation.speed / 360) * container.retina.reduceFactor;
-            if (!rotateAnimation.sync) {
-                this.rotate.velocity *= Math.random();
-            }
-        }
-        const tiltOptions = this.options.tilt;
-        this.tilt = {
-            enable: tiltOptions.enable,
-            value: (Utils_1.getRangeValue(tiltOptions.value) * Math.PI) / 180,
-            sinDirection: Math.random() >= 0.5 ? 1 : -1,
-            cosDirection: Math.random() >= 0.5 ? 1 : -1,
-        };
-        let tiltDirection = tiltOptions.direction;
-        if (tiltDirection === Enums_1.TiltDirection.random) {
-            const index = Math.floor(Math.random() * 2);
-            tiltDirection = index > 0 ? Enums_1.TiltDirection.counterClockwise : Enums_1.TiltDirection.clockwise;
-        }
-        switch (tiltDirection) {
-            case Enums_1.TiltDirection.counterClockwise:
-            case "counterClockwise":
-                this.tilt.status = Enums_1.AnimationStatus.decreasing;
-                break;
-            case Enums_1.TiltDirection.clockwise:
-                this.tilt.status = Enums_1.AnimationStatus.increasing;
-                break;
-        }
-        const tiltAnimation = this.options.tilt.animation;
-        if (tiltAnimation.enable) {
-            this.tilt.velocity = (tiltAnimation.speed / 360) * container.retina.reduceFactor;
-            if (!tiltAnimation.sync) {
-                this.tilt.velocity *= Math.random();
-            }
-        }
-        const orbitOptions = particlesOptions.orbit;
-        if (orbitOptions.enable) {
-            this.orbitRotation = Utils_1.getRangeValue(orbitOptions.rotation.value);
-            this.orbitColor = Utils_1.colorToHsl(orbitOptions.color);
-        }
-        const hslColor = Utils_1.colorToHsl(this.options.color, this.id, reduceDuplicates);
-        if (hslColor) {
-            this.color = Utils_1.getHslAnimationFromHsl(hslColor, this.options.color.animation, container.retina.reduceFactor);
-        }
-        const gradient = this.options.gradient instanceof Array ? Utils_1.itemFromArray(this.options.gradient) : this.options.gradient;
-        if (gradient) {
-            this.gradient = {
-                angle: {
-                    value: gradient.angle.value,
-                    enable: gradient.angle.animation.enable,
-                    velocity: (gradient.angle.animation.speed / 360) * container.retina.reduceFactor,
-                },
-                type: gradient.type,
-                colors: [],
-            };
-            let rotateDirection = gradient.angle.direction;
-            if (rotateDirection === Enums_1.RotateDirection.random) {
-                const index = Math.floor(Math.random() * 2);
-                rotateDirection = index > 0 ? Enums_1.RotateDirection.counterClockwise : Enums_1.RotateDirection.clockwise;
-            }
-            switch (rotateDirection) {
-                case Enums_1.RotateDirection.counterClockwise:
-                case "counterClockwise":
-                    this.gradient.angle.status = Enums_1.AnimationStatus.decreasing;
-                    break;
-                case Enums_1.RotateDirection.clockwise:
-                    this.gradient.angle.status = Enums_1.AnimationStatus.increasing;
-                    break;
-            }
-            for (const grColor of gradient.colors) {
-                const grHslColor = Utils_1.colorToHsl(grColor.value, this.id, reduceDuplicates);
-                if (grHslColor) {
-                    const grHslAnimation = Utils_1.getHslAnimationFromHsl(grHslColor, grColor.value.animation, container.retina.reduceFactor);
-                    const addColor = {
-                        stop: grColor.stop,
-                        value: grHslAnimation,
-                        opacity: grColor.opacity
-                            ? {
-                                enable: grColor.opacity.animation.enable,
-                                max: Utils_1.getRangeMax(grColor.opacity.value),
-                                min: Utils_1.getRangeMin(grColor.opacity.value),
-                                status: Enums_1.AnimationStatus.increasing,
-                                value: Utils_1.getRangeValue(grColor.opacity.value),
-                                velocity: (grColor.opacity.animation.speed / 100) * container.retina.reduceFactor,
-                            }
-                            : undefined,
-                    };
-                    if (grColor.opacity && addColor.opacity) {
-                        const opacityRange = grColor.opacity.value;
-                        addColor.opacity.min = Utils_1.getRangeMin(opacityRange);
-                        addColor.opacity.max = Utils_1.getRangeMax(opacityRange);
-                        const opacityAnimation = grColor.opacity.animation;
-                        switch (opacityAnimation.startValue) {
-                            case Enums_1.StartValueType.min:
-                                addColor.opacity.value = addColor.opacity.min;
-                                addColor.opacity.status = Enums_1.AnimationStatus.increasing;
-                                break;
-                            case Enums_1.StartValueType.random:
-                                addColor.opacity.value = Utils_1.randomInRange(addColor.opacity);
-                                addColor.opacity.status =
-                                    Math.random() >= 0.5 ? Enums_1.AnimationStatus.increasing : Enums_1.AnimationStatus.decreasing;
-                                break;
-                            case Enums_1.StartValueType.max:
-                            default:
-                                addColor.opacity.value = addColor.opacity.max;
-                                addColor.opacity.status = Enums_1.AnimationStatus.decreasing;
-                                break;
-                        }
-                    }
-                    this.gradient.colors.push(addColor);
-                }
-            }
-        }
-        const rollOpt = this.options.roll;
-        if (rollOpt.enable) {
-            if (this.color) {
-                if (rollOpt.backColor) {
-                    this.backColor = Utils_1.colorToHsl(rollOpt.backColor);
-                }
-                else if (rollOpt.darken.enable && rollOpt.enlighten.enable) {
-                    this.alterType = Math.random() >= 0.5 ? Enums_1.AlterType.darken : Enums_1.AlterType.enlighten;
-                    this.alterValue =
-                        this.alterType === Enums_1.AlterType.darken ? rollOpt.darken.value : rollOpt.enlighten.value;
-                }
-                else if (rollOpt.darken.enable) {
-                    this.alterType = Enums_1.AlterType.darken;
-                    this.alterValue = rollOpt.darken.value;
-                }
-                else if (rollOpt.enlighten.enable) {
-                    this.alterType = Enums_1.AlterType.enlighten;
-                    this.alterValue = rollOpt.enlighten.value;
-                }
-            }
-            this.rollAngle = Math.random() * Math.PI * 2;
-            this.rollSpeed = Utils_1.getRangeValue(rollOpt.speed) / 360;
-        }
-        else {
-            this.rollAngle = 0;
-            this.rollSpeed = 0;
-        }
-        const wobbleOpt = this.options.wobble;
-        if (wobbleOpt.enable) {
-            this.wobbleAngle = Math.random() * Math.PI * 2;
-            this.wobbleSpeed = Utils_1.getRangeValue(wobbleOpt.speed) / 360;
-        }
-        else {
-            this.wobbleAngle = 0;
-            this.wobbleSpeed = 0;
-        }
-        this.position = this.calcPosition(container, position, Utils_1.clamp(zIndexValue, 0, container.zLayers));
+        this.moveDecay = 1 - (0, Utils_1.getRangeValue)(this.options.move.decay);
+        this.position = this.calcPosition(container, position, (0, Utils_1.clamp)(zIndexValue, 0, container.zLayers));
         this.initialPosition = this.position.copy();
         this.offset = Vector_1.Vector.origin;
         const particles = container.particles;
         particles.needsSort = particles.needsSort || particles.lastZIndex < this.position.z;
         particles.lastZIndex = this.position.z;
         this.zIndexFactor = this.position.z / container.zLayers;
-        const opacityOptions = this.options.opacity;
-        this.opacity = {
-            enable: opacityOptions.animation.enable,
-            max: Utils_1.getRangeMax(opacityOptions.value),
-            min: Utils_1.getRangeMin(opacityOptions.value),
-            value: Utils_1.getRangeValue(opacityOptions.value),
-            loops: 0,
-            maxLoops: opacityOptions.animation.count,
-        };
-        const opacityAnimation = opacityOptions.animation;
-        if (opacityAnimation.enable) {
-            this.opacity.status = Enums_1.AnimationStatus.increasing;
-            const opacityRange = opacityOptions.value;
-            this.opacity.min = Utils_1.getRangeMin(opacityRange);
-            this.opacity.max = Utils_1.getRangeMax(opacityRange);
-            switch (opacityAnimation.startValue) {
-                case Enums_1.StartValueType.min:
-                    this.opacity.value = this.opacity.min;
-                    this.opacity.status = Enums_1.AnimationStatus.increasing;
-                    break;
-                case Enums_1.StartValueType.random:
-                    this.opacity.value = Utils_1.randomInRange(this.opacity);
-                    this.opacity.status =
-                        Math.random() >= 0.5 ? Enums_1.AnimationStatus.increasing : Enums_1.AnimationStatus.decreasing;
-                    break;
-                case Enums_1.StartValueType.max:
-                default:
-                    this.opacity.value = this.opacity.max;
-                    this.opacity.status = Enums_1.AnimationStatus.decreasing;
-                    break;
-            }
-            this.opacity.velocity = (opacityAnimation.speed / 100) * container.retina.reduceFactor;
-            if (!opacityAnimation.sync) {
-                this.opacity.velocity *= Math.random();
-            }
-        }
         this.sides = 24;
         let drawer = container.drawers.get(this.shape);
         if (!drawer) {
@@ -326,34 +132,30 @@ class Particle {
         if (sideCountFunc) {
             this.sides = sideCountFunc(this);
         }
-        this.stroke =
-            this.options.stroke instanceof Array
-                ? Utils_1.itemFromArray(this.options.stroke, this.id, reduceDuplicates)
-                : this.options.stroke;
-        this.strokeWidth = this.stroke.width * container.retina.pixelRatio;
-        const strokeHslColor = (_h = Utils_1.colorToHsl(this.stroke.color)) !== null && _h !== void 0 ? _h : this.getFillColor();
-        if (strokeHslColor) {
-            this.strokeColor = Utils_1.getHslAnimationFromHsl(strokeHslColor, (_j = this.stroke.color) === null || _j === void 0 ? void 0 : _j.animation, container.retina.reduceFactor);
-        }
         this.life = this.loadLife();
         this.spawning = this.life.delay > 0;
         if (this.options.move.spin.enable) {
-            const spinPos = (_k = this.options.move.spin.position) !== null && _k !== void 0 ? _k : { x: 50, y: 50 };
+            const spinPos = (_h = this.options.move.spin.position) !== null && _h !== void 0 ? _h : { x: 50, y: 50 };
             const spinCenter = {
                 x: (spinPos.x / 100) * container.canvas.size.width,
                 y: (spinPos.y / 100) * container.canvas.size.height,
             };
             const pos = this.getPosition();
-            const distance = Utils_1.getDistance(pos, spinCenter);
+            const distance = (0, Utils_1.getDistance)(pos, spinCenter);
             this.spin = {
                 center: spinCenter,
                 direction: this.velocity.x >= 0 ? Enums_1.RotateDirection.clockwise : Enums_1.RotateDirection.counterClockwise,
                 angle: this.velocity.angle,
                 radius: distance,
-                acceleration: Utils_1.getRangeValue(this.options.move.spin.acceleration),
+                acceleration: (_j = this.retina.spinAcceleration) !== null && _j !== void 0 ? _j : (0, Utils_1.getRangeValue)(this.options.move.spin.acceleration),
             };
         }
-        this.shadowColor = Utils_1.colorToRgb(this.options.shadow.color);
+        this.shadowColor = (0, Utils_1.colorToRgb)(this.options.shadow.color);
+        for (const updater of container.particles.updaters) {
+            if (updater.init) {
+                updater.init(this);
+            }
+        }
         if (drawer && drawer.particleInit) {
             drawer.particleInit(container, this);
         }
@@ -389,29 +191,23 @@ class Particle {
         };
     }
     getRadius() {
-        return this.bubble.radius || this.size.value;
+        var _a;
+        return (_a = this.bubble.radius) !== null && _a !== void 0 ? _a : this.size.value;
     }
     getMass() {
-        const radius = this.getRadius();
-        return (Math.pow(radius, 2) * Math.PI) / 2;
+        return (this.getRadius() ** 2 * Math.PI) / 2;
     }
     getFillColor() {
-        if (this.bubble.color) {
-            return this.bubble.color;
-        }
-        const color = Utils_1.getHslFromAnimation(this.color);
-        if (color && (this.backColor || (this.alterType && this.alterValue !== undefined))) {
-            const rolled = Math.floor(this.rollAngle / (Math.PI / 2)) % 2;
+        var _a, _b, _c;
+        const color = (_a = this.bubble.color) !== null && _a !== void 0 ? _a : (0, Utils_1.getHslFromAnimation)(this.color);
+        if (color && this.roll && (this.backColor || this.roll.alter)) {
+            const rolled = Math.floor(((_c = (_b = this.roll) === null || _b === void 0 ? void 0 : _b.angle) !== null && _c !== void 0 ? _c : 0) / (Math.PI / 2)) % 2;
             if (rolled) {
                 if (this.backColor) {
                     return this.backColor;
                 }
-                else if (this.alterType && this.alterValue !== undefined) {
-                    return {
-                        h: color.h,
-                        s: color.s,
-                        l: color.l + (this.alterType === Enums_1.AlterType.darken ? -1 : 1) * this.alterValue,
-                    };
+                if (this.roll.alter) {
+                    return (0, Utils_1.alterHsl)(color, this.roll.alter.type, this.roll.alter.value);
                 }
             }
         }
@@ -419,7 +215,7 @@ class Particle {
     }
     getStrokeColor() {
         var _a, _b;
-        return (_b = (_a = this.bubble.color) !== null && _a !== void 0 ? _a : Utils_1.getHslFromAnimation(this.strokeColor)) !== null && _b !== void 0 ? _b : this.getFillColor();
+        return (_b = (_a = this.bubble.color) !== null && _a !== void 0 ? _a : (0, Utils_1.getHslFromAnimation)(this.strokeColor)) !== null && _b !== void 0 ? _b : this.getFillColor();
     }
     destroy(override) {
         this.destroyed = true;
@@ -443,7 +239,9 @@ class Particle {
         }
     }
     reset() {
-        this.opacity.loops = 0;
+        if (this.opacity) {
+            this.opacity.loops = 0;
+        }
         this.size.loops = 0;
     }
     split() {
@@ -451,7 +249,7 @@ class Particle {
         if (splitOptions.count >= 0 && this.splitCount++ > splitOptions.count) {
             return;
         }
-        const rate = Utils_1.getRangeValue(splitOptions.rate.value);
+        const rate = (0, Utils_1.getRangeValue)(splitOptions.rate.value);
         for (let i = 0; i < rate; i++) {
             this.container.particles.addSplitParticle(this);
         }
@@ -467,26 +265,24 @@ class Particle {
         const canvasSize = container.canvas.size;
         const pos = Vector3d_1.Vector3d.create((_a = position === null || position === void 0 ? void 0 : position.x) !== null && _a !== void 0 ? _a : Math.random() * canvasSize.width, (_b = position === null || position === void 0 ? void 0 : position.y) !== null && _b !== void 0 ? _b : Math.random() * canvasSize.height, zIndex);
         const radius = this.getRadius();
-        const outModes = this.options.move.outModes;
-        const fixHorizontal = (outMode) => {
-            if (Utils_1.isInArray(outMode, Enums_1.OutMode.bounce) || Utils_1.isInArray(outMode, Enums_1.OutMode.bounceHorizontal)) {
-                if (pos.x > container.canvas.size.width - radius * 2) {
-                    pos.x -= radius;
-                }
-                else if (pos.x < radius * 2) {
-                    pos.x += radius;
-                }
-            }
-        };
-        const fixVertical = (outMode) => {
-            if (Utils_1.isInArray(outMode, Enums_1.OutMode.bounce) || Utils_1.isInArray(outMode, Enums_1.OutMode.bounceVertical)) {
-                if (pos.y > container.canvas.size.height - radius * 2) {
-                    pos.y -= radius;
-                }
-                else if (pos.y < radius * 2) {
-                    pos.y += radius;
-                }
-            }
+        const outModes = this.options.move.outModes, fixHorizontal = (outMode) => {
+            fixOutMode({
+                outMode,
+                checkModes: [Enums_1.OutMode.bounce, Enums_1.OutMode.bounceHorizontal],
+                coord: pos.x,
+                maxCoord: container.canvas.size.width,
+                setCb: (value) => (pos.x += value),
+                radius,
+            });
+        }, fixVertical = (outMode) => {
+            fixOutMode({
+                outMode,
+                checkModes: [Enums_1.OutMode.bounce, Enums_1.OutMode.bounceVertical],
+                coord: pos.y,
+                maxCoord: container.canvas.size.height,
+                setCb: (value) => (pos.y += value),
+                radius,
+            });
         };
         fixHorizontal((_c = outModes.left) !== null && _c !== void 0 ? _c : outModes.default);
         fixHorizontal((_d = outModes.right) !== null && _d !== void 0 ? _d : outModes.default);
@@ -513,7 +309,7 @@ class Particle {
         }
         let overlaps = false;
         for (const particle of this.container.particles.array) {
-            if (Utils_1.getDistance(pos, particle.position) < radius + particle.getRadius()) {
+            if ((0, Utils_1.getDistance)(pos, particle.position) < radius + particle.getRadius()) {
                 overlaps = true;
                 break;
             }
@@ -521,7 +317,7 @@ class Particle {
         return overlaps;
     }
     calculateVelocity() {
-        const baseVelocity = Utils_1.getParticleBaseVelocity(this.direction);
+        const baseVelocity = (0, Utils_1.getParticleBaseVelocity)(this.direction);
         const res = baseVelocity.copy();
         const moveOptions = this.options.move;
         const rad = (Math.PI / 180) * moveOptions.angle.value;
@@ -531,7 +327,7 @@ class Particle {
             right: radOffset + rad / 2,
         };
         if (!moveOptions.straight) {
-            res.angle += Utils_1.randomInRange(Utils_1.setRangeValue(range.left, range.right));
+            res.angle += (0, Utils_1.randomInRange)((0, Utils_1.setRangeValue)(range.left, range.right));
         }
         if (moveOptions.random && typeof moveOptions.speed === "number") {
             res.length *= Math.random();
@@ -541,7 +337,7 @@ class Particle {
     loadShapeData(shapeOptions, reduceDuplicates) {
         const shapeData = shapeOptions.options[this.shape];
         if (shapeData) {
-            return Utils_1.deepExtend({}, shapeData instanceof Array ? Utils_1.itemFromArray(shapeData, this.id, reduceDuplicates) : shapeData);
+            return (0, Utils_1.deepExtend)({}, shapeData instanceof Array ? (0, Utils_1.itemFromArray)(shapeData, this.id, reduceDuplicates) : shapeData);
         }
     }
     loadLife() {
@@ -550,13 +346,13 @@ class Particle {
         const lifeOptions = particlesOptions.life;
         const life = {
             delay: container.retina.reduceFactor
-                ? ((Utils_1.getRangeValue(lifeOptions.delay.value) * (lifeOptions.delay.sync ? 1 : Math.random())) /
+                ? (((0, Utils_1.getRangeValue)(lifeOptions.delay.value) * (lifeOptions.delay.sync ? 1 : Math.random())) /
                     container.retina.reduceFactor) *
                     1000
                 : 0,
             delayTime: 0,
             duration: container.retina.reduceFactor
-                ? ((Utils_1.getRangeValue(lifeOptions.duration.value) * (lifeOptions.duration.sync ? 1 : Math.random())) /
+                ? (((0, Utils_1.getRangeValue)(lifeOptions.duration.value) * (lifeOptions.duration.sync ? 1 : Math.random())) /
                     container.retina.reduceFactor) *
                     1000
                 : 0,

package/Core/Particles.d.ts

@@ -17,12 +17,11 @@ export declare class Particles {
     pushing?: boolean;
     linksColor?: IRgb | string;
     grabLineColor?: IRgb | string;
+    readonly updaters: import("./Interfaces").IParticleUpdater[];
     private interactionManager;
     private nextId;
-    private linksFreq;
-    private trianglesFreq;
+    private readonly freqs;
     private readonly mover;
-    private readonly updaters;
     constructor(container: Container);
     init(): void;
     redraw(): void;

package/Core/Particles.js

@@ -16,8 +16,10 @@ class Particles {
         this.limit = 0;
         this.needsSort = false;
         this.lastZIndex = 0;
-        this.linksFreq = new Map();
-        this.trianglesFreq = new Map();
+        this.freqs = {
+            links: new Map(),
+            triangles: new Map(),
+        };
         this.interactionManager = new InteractionManager_1.InteractionManager(container);
         const canvasSize = this.container.canvas.size;
         this.linksColors = new Map();
@@ -33,8 +35,8 @@ class Particles {
         const options = container.actualOptions;
         this.lastZIndex = 0;
         this.needsSort = false;
-        this.linksFreq = new Map();
-        this.trianglesFreq = new Map();
+        this.freqs.links = new Map();
+        this.freqs.triangles = new Map();
         let handled = false;
         for (const [, plugin] of container.plugins) {
             if (plugin.particlesInitialization !== undefined) {
@@ -173,7 +175,7 @@ class Particles {
         const splitOptions = parent.options.destroy.split;
         const options = new ParticlesOptions_1.ParticlesOptions();
         options.load(parent.options);
-        const factor = Utils_1.getRangeValue(splitOptions.factor.value);
+        const factor = (0, Utils_1.getRangeValue)(splitOptions.factor.value);
         options.color.load({
             value: {
                 hsl: parent.getFillColor(),
@@ -187,16 +189,16 @@ class Particles {
             options.size.value.max /= factor;
         }
         options.load(splitOptions.particles);
-        const offset = splitOptions.sizeOffset ? Utils_1.setRangeValue(-parent.size.value, parent.size.value) : 0;
+        const offset = splitOptions.sizeOffset ? (0, Utils_1.setRangeValue)(-parent.size.value, parent.size.value) : 0;
         const position = {
-            x: parent.position.x + Utils_1.randomInRange(offset),
-            y: parent.position.y + Utils_1.randomInRange(offset),
+            x: parent.position.x + (0, Utils_1.randomInRange)(offset),
+            y: parent.position.y + (0, Utils_1.randomInRange)(offset),
         };
         return this.pushParticle(position, options, parent.group, (particle) => {
             if (particle.size.value < 0.5) {
                 return false;
             }
-            particle.velocity.length = Utils_1.randomInRange(Utils_1.setRangeValue(parent.velocity.length, particle.velocity.length));
+            particle.velocity.length = (0, Utils_1.randomInRange)((0, Utils_1.setRangeValue)(parent.velocity.length, particle.velocity.length));
             particle.splitCount = parent.splitCount + 1;
             particle.unbreakable = true;
             setTimeout(() => {
@@ -210,10 +212,10 @@ class Particles {
     }
     getLinkFrequency(p1, p2) {
         const key = `${Math.min(p1.id, p2.id)}_${Math.max(p1.id, p2.id)}`;
-        let res = this.linksFreq.get(key);
+        let res = this.freqs.links.get(key);
         if (res === undefined) {
             res = Math.random();
-            this.linksFreq.set(key, res);
+            this.freqs.links.set(key, res);
         }
         return res;
     }
@@ -229,10 +231,10 @@ class Particles {
             [id3, id1] = [id1, id3];
         }
         const key = `${id1}_${id2}_${id3}`;
-        let res = this.trianglesFreq.get(key);
+        let res = this.freqs.triangles.get(key);
         if (res === undefined) {
             res = Math.random();
-            this.trianglesFreq.set(key, res);
+            this.freqs.triangles.set(key, res);
         }
         return res;
     }
@@ -282,7 +284,7 @@ class Particles {
         }
         const canvas = container.canvas.element;
         const pxRatio = container.retina.pixelRatio;
-        return (canvas.width * canvas.height) / (densityOptions.factor * Math.pow(pxRatio, 2) * densityOptions.area);
+        return (canvas.width * canvas.height) / (densityOptions.factor * pxRatio ** 2 * densityOptions.area);
     }
     pushParticle(position, overrideOptions, group, initializer) {
         try {