tsparticles 1.41.4 → 1.42.0

package/Core/Canvas.js

@@ -98,10 +98,7 @@ class Canvas {
         const container = this.container;
         const pxRatio = container.retina.pixelRatio;
         const size = container.canvas.size;
-        const oldSize = {
-            width: size.width,
-            height: size.height,
-        };
+        const oldSize = Object.assign({}, size);
         size.width = this.element.offsetWidth * pxRatio;
         size.height = this.element.offsetHeight * pxRatio;
         this.element.width = size.width;
@@ -160,7 +157,9 @@ class Canvas {
         const zIndexOptions = particle.options.zIndex;
         const zOpacityFactor = (1 - particle.zIndexFactor) ** zIndexOptions.opacityRate;
         const radius = particle.getRadius();
-        const opacity = twinkling ? twinkle.opacity : (_d = (_b = particle.bubble.opacity) !== null && _b !== void 0 ? _b : (_c = particle.opacity) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : 1;
+        const opacity = twinkling
+            ? (0, Utils_1.getRangeValue)(twinkle.opacity)
+            : (_d = (_b = particle.bubble.opacity) !== null && _b !== void 0 ? _b : (_c = particle.opacity) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : 1;
         const strokeOpacity = (_f = (_e = particle.stroke) === null || _e === void 0 ? void 0 : _e.opacity) !== null && _f !== void 0 ? _f : opacity;
         const zOpacity = opacity * zOpacityFactor;
         const fillColorValue = fColor ? (0, Utils_1.getStyleFromHsl)(fColor, zOpacity) : undefined;

package/Core/Interfaces/ICoordinates.d.ts

@@ -1,3 +1,4 @@
+import type { RangeValue } from "../../Types";
 export interface ICoordinates {
     x: number;
     y: number;
@@ -5,3 +6,10 @@ export interface ICoordinates {
 export interface ICoordinates3d extends ICoordinates {
     z: number;
 }
+export interface IRangedCoordinates {
+    x: RangeValue;
+    y: RangeValue;
+}
+export interface IRangedCoordinates3d extends IRangedCoordinates {
+    z: RangeValue;
+}

package/Core/Interfaces/IParticleGravity.d.ts

@@ -0,0 +1,5 @@
+export interface IParticleGravity {
+    enable: boolean;
+    acceleration: number;
+    inverse: boolean;
+}

package/Core/Interfaces/IParticleGravity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/Core/Interfaces/index.d.ts

@@ -18,6 +18,7 @@ export * from "./IMovePathGenerator";
 export * from "./IParticle";
 export * from "./IParticleGradientAnimation";
 export * from "./IParticleGradientColorAnimation";
+export * from "./IParticleGravity";
 export * from "./IParticleHslAnimation";
 export * from "./IParticlesInteractor";
 export * from "./IParticleLife";

package/Core/Interfaces/index.js

@@ -30,6 +30,7 @@ __exportStar(require("./IMovePathGenerator"), exports);
 __exportStar(require("./IParticle"), exports);
 __exportStar(require("./IParticleGradientAnimation"), exports);
 __exportStar(require("./IParticleGradientColorAnimation"), exports);
+__exportStar(require("./IParticleGravity"), exports);
 __exportStar(require("./IParticleHslAnimation"), exports);
 __exportStar(require("./IParticlesInteractor"), exports);
 __exportStar(require("./IParticleLife"), exports);

package/Core/Particle.d.ts

@@ -1,5 +1,5 @@
 import { ShapeType } from "../Enums";
-import type { IBubbleParticleData, ICoordinates, ICoordinates3d, IDelta, IHsl, IParticle, IParticleGradientAnimation, IParticleHslAnimation, IParticleLife, IParticleNumericValueAnimation, IParticleRetinaProps, IParticleRoll, IParticleSpin, IParticleTiltValueAnimation, IParticleValueAnimation, IParticleWobble, IRgb, IShapeValues } from "./Interfaces";
+import type { IBubbleParticleData, ICoordinates, ICoordinates3d, IDelta, IHsl, IParticle, IParticleGradientAnimation, IParticleGravity, IParticleHslAnimation, IParticleLife, IParticleNumericValueAnimation, IParticleRetinaProps, IParticleRoll, IParticleSpin, IParticleTiltValueAnimation, IParticleValueAnimation, IParticleWobble, IRgb, IShapeValues } from "./Interfaces";
 import { Vector, Vector3d } from "./Utils";
 import type { Container } from "./Container";
 import type { Engine } from "../engine";
@@ -13,6 +13,7 @@ export declare class Particle implements IParticle {
     readonly container: Container;
     readonly group?: string | undefined;
     destroyed: boolean;
+    ignoresResizeRatio: boolean;
     lastPathTime: number;
     misplaced: boolean;
     spawning: boolean;
@@ -36,6 +37,7 @@ export declare class Particle implements IParticle {
     strokeWidth?: number;
     stroke?: Stroke;
     strokeColor?: IParticleHslAnimation;
+    readonly gravity: IParticleGravity;
     readonly moveDecay: number;
     readonly direction: number;
     readonly position: Vector3d;

package/Core/Particle.js

@@ -45,6 +45,7 @@ class Particle {
         this.retina = {
             maxDistance: {},
         };
+        this.ignoresResizeRatio = true;
         const pxRatio = container.retina.pixelRatio;
         const mainOptions = container.actualOptions;
         const particlesOptions = new ParticlesOptions_1.ParticlesOptions();
@@ -88,7 +89,7 @@ class Particle {
             max: (0, Utils_2.getRangeMax)(sizeRange) * pxRatio,
             min: (0, Utils_2.getRangeMin)(sizeRange) * pxRatio,
             loops: 0,
-            maxLoops: sizeOptions.animation.count,
+            maxLoops: (0, Utils_2.getRangeValue)(sizeOptions.animation.count),
         };
         const sizeAnimation = sizeOptions.animation;
         if (sizeAnimation.enable) {
@@ -122,6 +123,12 @@ class Particle {
         this.initialVelocity = this.calculateVelocity();
         this.velocity = this.initialVelocity.copy();
         this.moveDecay = 1 - (0, Utils_2.getRangeValue)(this.options.move.decay);
+        const gravityOptions = this.options.move.gravity;
+        this.gravity = {
+            enable: gravityOptions.enable,
+            acceleration: (0, Utils_2.getRangeValue)(gravityOptions.acceleration),
+            inverse: gravityOptions.inverse,
+        };
         this.position = this.calcPosition(container, position, (0, Utils_2.clamp)(zIndexValue, 0, container.zLayers));
         this.initialPosition = this.position.copy();
         this.offset = Utils_1.Vector.origin;
@@ -329,12 +336,7 @@ class Particle {
         return overlaps;
     }
     calculateVelocity() {
-        const baseVelocity = (0, Utils_2.getParticleBaseVelocity)(this.direction);
-        const res = baseVelocity.copy();
-        const moveOptions = this.options.move;
-        const rad = (Math.PI / 180) * moveOptions.angle.value;
-        const radOffset = (Math.PI / 180) * moveOptions.angle.offset;
-        const range = {
+        const baseVelocity = (0, Utils_2.getParticleBaseVelocity)(this.direction), res = baseVelocity.copy(), moveOptions = this.options.move, rad = (Math.PI / 180) * (0, Utils_2.getRangeValue)(moveOptions.angle.value), radOffset = (Math.PI / 180) * (0, Utils_2.getRangeValue)(moveOptions.angle.offset), range = {
             left: radOffset - rad / 2,
             right: radOffset + rad / 2,
         };

package/Core/Particles.js

@@ -111,10 +111,11 @@ class Particles {
         }
         for (const particle of this.array) {
             const resizeFactor = container.canvas.resizeFactor;
-            if (resizeFactor) {
+            if (resizeFactor && !particle.ignoresResizeRatio) {
                 particle.position.x *= resizeFactor.width;
                 particle.position.y *= resizeFactor.height;
             }
+            particle.ignoresResizeRatio = false;
             particle.bubble.inRange = false;
             for (const [, plugin] of this.container.plugins) {
                 if (particle.destroyed) {

package/Core/Retina.js

@@ -43,13 +43,13 @@ class Retina {
             container.canvas.size.height = element.offsetHeight * ratio;
         }
         const particles = options.particles;
-        this.attractDistance = particles.move.attract.distance * ratio;
+        this.attractDistance = (0, Utils_1.getRangeValue)(particles.move.attract.distance) * ratio;
         this.linksDistance = particles.links.distance * ratio;
         this.linksWidth = particles.links.width * ratio;
-        this.sizeAnimationSpeed = particles.size.animation.speed * ratio;
-        this.maxSpeed = particles.move.gravity.maxSpeed * ratio;
+        this.sizeAnimationSpeed = (0, Utils_1.getRangeValue)(particles.size.animation.speed) * ratio;
+        this.maxSpeed = (0, Utils_1.getRangeValue)(particles.move.gravity.maxSpeed) * ratio;
         if (particles.orbit.radius !== undefined) {
-            this.orbitRadius = particles.orbit.radius * this.container.retina.pixelRatio;
+            this.orbitRadius = (0, Utils_1.getRangeValue)(particles.orbit.radius) * this.container.retina.pixelRatio;
         }
         const modes = options.interactivity.modes;
         this.connectModeDistance = modes.connect.distance * ratio;
@@ -69,19 +69,19 @@ class Retina {
         const ratio = this.pixelRatio;
         const moveDistance = options.move.distance;
         const props = particle.retina;
-        props.attractDistance = options.move.attract.distance * ratio;
+        props.attractDistance = (0, Utils_1.getRangeValue)(options.move.attract.distance) * ratio;
         props.linksDistance = options.links.distance * ratio;
         props.linksWidth = options.links.width * ratio;
         props.moveDrift = (0, Utils_1.getRangeValue)(options.move.drift) * ratio;
         props.moveSpeed = (0, Utils_1.getRangeValue)(options.move.speed) * ratio;
-        props.sizeAnimationSpeed = options.size.animation.speed * ratio;
+        props.sizeAnimationSpeed = (0, Utils_1.getRangeValue)(options.size.animation.speed) * ratio;
         if (particle.spin) {
             props.spinAcceleration = (0, Utils_1.getRangeValue)(options.move.spin.acceleration) * ratio;
         }
         const maxDistance = props.maxDistance;
         maxDistance.horizontal = moveDistance.horizontal !== undefined ? moveDistance.horizontal * ratio : undefined;
         maxDistance.vertical = moveDistance.vertical !== undefined ? moveDistance.vertical * ratio : undefined;
-        props.maxSpeed = options.move.gravity.maxSpeed * ratio;
+        props.maxSpeed = (0, Utils_1.getRangeValue)(options.move.gravity.maxSpeed) * ratio;
     }
     handleMotionChange(mediaQuery) {
         const options = this.container.actualOptions;

package/Core/Utils/ParticlesMover.js

@@ -55,7 +55,7 @@ class ParticlesMover {
         const container = this.container, slowFactor = this.getProximitySpeedFactor(particle), baseSpeed = ((_a = (_d = particle.retina).moveSpeed) !== null && _a !== void 0 ? _a : (_d.moveSpeed = (0, Utils_1.getRangeValue)(moveOptions.speed) * container.retina.pixelRatio)) *
             container.retina.reduceFactor, moveDrift = ((_b = (_e = particle.retina).moveDrift) !== null && _b !== void 0 ? _b : (_e.moveDrift = (0, Utils_1.getRangeValue)(particle.options.move.drift) * container.retina.pixelRatio)), maxSize = (0, Utils_1.getRangeMax)(particleOptions.size.value) * container.retina.pixelRatio, sizeFactor = moveOptions.size ? particle.getRadius() / maxSize : 1, diffFactor = 2, speedFactor = (sizeFactor * slowFactor * (delta.factor || 1)) / diffFactor, moveSpeed = baseSpeed * speedFactor;
         this.applyPath(particle, delta);
-        const gravityOptions = moveOptions.gravity;
+        const gravityOptions = particle.gravity;
         const gravityFactor = gravityOptions.enable && gravityOptions.inverse ? -1 : 1;
         if (gravityOptions.enable && moveSpeed) {
             particle.velocity.y += (gravityFactor * (gravityOptions.acceleration * delta.factor)) / (60 * moveSpeed);
@@ -70,7 +70,7 @@ class ParticlesMover {
         const velocity = particle.velocity.mult(moveSpeed);
         const maxSpeed = (_c = particle.retina.maxSpeed) !== null && _c !== void 0 ? _c : container.retina.maxSpeed;
         if (gravityOptions.enable &&
-            gravityOptions.maxSpeed > 0 &&
+            maxSpeed > 0 &&
             ((!gravityOptions.inverse && velocity.y >= 0 && velocity.y >= maxSpeed) ||
                 (gravityOptions.inverse && velocity.y <= 0 && velocity.y <= -maxSpeed))) {
             velocity.y = gravityFactor * maxSpeed;

package/Interactions/Particles/Links/LinkInstance.js

@@ -102,7 +102,7 @@ class LinkInstance {
                 const twinkling = Math.random() < twinkleFreq;
                 if (twinkling && twinkleRgb !== undefined) {
                     colorLine = twinkleRgb;
-                    opacity = twinkle.opacity;
+                    opacity = (0, Utils_1.getRangeValue)(twinkle.opacity);
                 }
             }
             if (!colorLine) {

package/Options/Classes/AnimatableGradient.d.ts

@@ -35,17 +35,17 @@ export declare class AnimatableGradientColor implements IAnimatableGradientColor
     load(data?: RecursivePartial<IAnimatableGradientColor>): void;
 }
 export declare class GradientAngleAnimation implements IAnimation, IOptionLoader<IAnimation> {
-    count: number;
+    count: RangeValue;
     enable: boolean;
-    speed: number;
+    speed: RangeValue;
     sync: boolean;
     constructor();
     load(data?: RecursivePartial<IAnimation>): void;
 }
 export declare class GradientColorOpacityAnimation implements IGradientColorOpacityAnimation, IOptionLoader<IGradientColorOpacityAnimation> {
-    count: number;
+    count: RangeValue;
     enable: boolean;
-    speed: number;
+    speed: RangeValue;
     sync: boolean;
     startValue: StartValueType | keyof typeof StartValueType;
     constructor();

package/Options/Classes/AnimatableGradient.js

@@ -100,13 +100,13 @@ class GradientAngleAnimation {
             return;
         }
         if (data.count !== undefined) {
-            this.count = data.count;
+            this.count = (0, Utils_1.setRangeValue)(data.count);
         }
         if (data.enable !== undefined) {
             this.enable = data.enable;
         }
         if (data.speed !== undefined) {
-            this.speed = data.speed;
+            this.speed = (0, Utils_1.setRangeValue)(data.speed);
         }
         if (data.sync !== undefined) {
             this.sync = data.sync;
@@ -127,13 +127,13 @@ class GradientColorOpacityAnimation {
             return;
         }
         if (data.count !== undefined) {
-            this.count = data.count;
+            this.count = (0, Utils_1.setRangeValue)(data.count);
         }
         if (data.enable !== undefined) {
             this.enable = data.enable;
         }
         if (data.speed !== undefined) {
-            this.speed = data.speed;
+            this.speed = (0, Utils_1.setRangeValue)(data.speed);
         }
         if (data.sync !== undefined) {
             this.sync = data.sync;

package/Options/Classes/AnimationOptions.d.ts

@@ -1,10 +1,10 @@
-import { IAnimation } from "../Interfaces/IAnimation";
-import { IOptionLoader } from "../Interfaces/IOptionLoader";
-import { RecursivePartial } from "../../Types";
+import type { RangeValue, RecursivePartial } from "../../Types";
+import type { IAnimation } from "../Interfaces/IAnimation";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
 export declare class AnimationOptions implements IAnimation, IOptionLoader<IAnimation> {
-    count: number;
+    count: RangeValue;
     enable: boolean;
-    speed: number;
+    speed: RangeValue;
     sync: boolean;
     constructor();
     load(data?: RecursivePartial<IAnimation>): void;

package/Options/Classes/AnimationOptions.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnimationOptions = void 0;
+const Utils_1 = require("../../Utils");
 class AnimationOptions {
     constructor() {
         this.count = 0;
@@ -13,13 +14,13 @@ class AnimationOptions {
             return;
         }
         if (data.count !== undefined) {
-            this.count = data.count;
+            this.count = (0, Utils_1.setRangeValue)(data.count);
         }
         if (data.enable !== undefined) {
             this.enable = data.enable;
         }
         if (data.speed !== undefined) {
-            this.speed = data.speed;
+            this.speed = (0, Utils_1.setRangeValue)(data.speed);
         }
         if (data.sync !== undefined) {
             this.sync = data.sync;

package/Options/Classes/ColorAnimation.d.ts

@@ -2,10 +2,10 @@ import type { RangeValue, RecursivePartial } from "../../Types";
 import type { IColorAnimation } from "../Interfaces/IColorAnimation";
 import type { IOptionLoader } from "../Interfaces/IOptionLoader";
 export declare class ColorAnimation implements IColorAnimation, IOptionLoader<IColorAnimation> {
-    count: number;
+    count: RangeValue;
     enable: boolean;
     offset: RangeValue;
-    speed: number;
+    speed: RangeValue;
     sync: boolean;
     constructor();
     load(data?: RecursivePartial<IColorAnimation>): void;

package/Options/Classes/ColorAnimation.js

@@ -15,7 +15,7 @@ class ColorAnimation {
             return;
         }
         if (data.count !== undefined) {
-            this.count = data.count;
+            this.count = (0, Utils_1.setRangeValue)(data.count);
         }
         if (data.enable !== undefined) {
             this.enable = data.enable;
@@ -24,7 +24,7 @@ class ColorAnimation {
             this.offset = (0, Utils_1.setRangeValue)(data.offset);
         }
         if (data.speed !== undefined) {
-            this.speed = data.speed;
+            this.speed = (0, Utils_1.setRangeValue)(data.speed);
         }
         if (data.sync !== undefined) {
             this.sync = data.sync;

package/Options/Classes/Particles/Move/Attract.d.ts

@@ -1,13 +1,13 @@
+import type { RangeValue, RecursivePartial } from "../../../../Types";
 import type { IAttract } from "../../../Interfaces/Particles/Move/IAttract";
 import type { ICoordinates } from "../../../../Core";
 import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
-import type { RecursivePartial } from "../../../../Types";
 export declare class Attract implements IAttract, IOptionLoader<IAttract> {
     get rotateX(): number;
     set rotateX(value: number);
     get rotateY(): number;
     set rotateY(value: number);
-    distance: number;
+    distance: RangeValue;
     enable: boolean;
     rotate: ICoordinates;
     constructor();

package/Options/Classes/Particles/Move/Attract.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Attract = void 0;
+const Utils_1 = require("../../../../Utils");
 class Attract {
     constructor() {
         this.distance = 200;
@@ -28,7 +29,7 @@ class Attract {
             return;
         }
         if (data.distance !== undefined) {
-            this.distance = data.distance;
+            this.distance = (0, Utils_1.setRangeValue)(data.distance);
         }
         if (data.enable !== undefined) {
             this.enable = data.enable;

package/Options/Classes/Particles/Move/MoveAngle.d.ts

@@ -1,9 +1,9 @@
+import type { RangeValue, RecursivePartial } from "../../../../Types";
 import type { IMoveAngle } from "../../../Interfaces/Particles/Move/IMoveAngle";
 import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
-import type { RecursivePartial } from "../../../../Types";
 export declare class MoveAngle implements IMoveAngle, IOptionLoader<IMoveAngle> {
-    offset: number;
-    value: number;
+    offset: RangeValue;
+    value: RangeValue;
     constructor();
     load(data?: RecursivePartial<IMoveAngle>): void;
 }

package/Options/Classes/Particles/Move/MoveAngle.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoveAngle = void 0;
+const Utils_1 = require("../../../../Utils");
 class MoveAngle {
     constructor() {
         this.offset = 0;
@@ -11,10 +12,10 @@ class MoveAngle {
             return;
         }
         if (data.offset !== undefined) {
-            this.offset = data.offset;
+            this.offset = (0, Utils_1.setRangeValue)(data.offset);
         }
         if (data.value !== undefined) {
-            this.value = data.value;
+            this.value = (0, Utils_1.setRangeValue)(data.value);
         }
     }
 }

package/Options/Classes/Particles/Move/MoveGravity.d.ts

@@ -1,11 +1,11 @@
-import { IMoveGravity } from "../../../Interfaces/Particles/Move/IMoveGravity";
-import { IOptionLoader } from "../../../Interfaces/IOptionLoader";
-import { RecursivePartial } from "../../../../Types";
+import type { RangeValue, RecursivePartial } from "../../../../Types";
+import type { IMoveGravity } from "../../../Interfaces/Particles/Move/IMoveGravity";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
 export declare class MoveGravity implements IMoveGravity, IOptionLoader<IMoveGravity> {
-    acceleration: number;
+    acceleration: RangeValue;
     enable: boolean;
     inverse: boolean;
-    maxSpeed: number;
+    maxSpeed: RangeValue;
     constructor();
     load(data?: RecursivePartial<IMoveGravity>): void;
 }

package/Options/Classes/Particles/Move/MoveGravity.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoveGravity = void 0;
+const Utils_1 = require("../../../../Utils");
 class MoveGravity {
     constructor() {
         this.acceleration = 9.81;
@@ -13,7 +14,7 @@ class MoveGravity {
             return;
         }
         if (data.acceleration !== undefined) {
-            this.acceleration = data.acceleration;
+            this.acceleration = (0, Utils_1.setRangeValue)(data.acceleration);
         }
         if (data.enable !== undefined) {
             this.enable = data.enable;
@@ -22,7 +23,7 @@ class MoveGravity {
             this.inverse = data.inverse;
         }
         if (data.maxSpeed !== undefined) {
-            this.maxSpeed = data.maxSpeed;
+            this.maxSpeed = (0, Utils_1.setRangeValue)(data.maxSpeed);
         }
     }
 }

package/Options/Classes/Particles/Orbit/Orbit.d.ts

@@ -1,17 +1,17 @@
+import type { RangeValue, RecursivePartial } from "../../../../Types";
 import { AnimationOptions } from "../../AnimationOptions";
 import type { IAnimatable } from "../../../Interfaces/IAnimatable";
 import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
 import type { IOrbit } from "../../../Interfaces/Particles/Orbit/IOrbit";
 import { OptionsColor } from "../../OptionsColor";
 import { OrbitRotation } from "./OrbitRotation";
-import type { RecursivePartial } from "../../../../Types";
 export declare class Orbit implements IOrbit, IOptionLoader<IOrbit>, IAnimatable<AnimationOptions> {
     animation: AnimationOptions;
     enable: boolean;
-    opacity: number;
-    width: number;
+    opacity: RangeValue;
+    width: RangeValue;
     color?: OptionsColor;
-    radius?: number;
+    radius?: RangeValue;
     rotation: OrbitRotation;
     constructor();
     load(data?: RecursivePartial<IOrbit>): void;

package/Options/Classes/Particles/Orbit/Orbit.js

@@ -4,6 +4,7 @@ exports.Orbit = void 0;
 const AnimationOptions_1 = require("../../AnimationOptions");
 const OptionsColor_1 = require("../../OptionsColor");
 const OrbitRotation_1 = require("./OrbitRotation");
+const Utils_1 = require("../../../../Utils");
 class Orbit {
     constructor() {
         this.animation = new AnimationOptions_1.AnimationOptions();
@@ -22,13 +23,13 @@ class Orbit {
             this.enable = data.enable;
         }
         if (data.opacity !== undefined) {
-            this.opacity = data.opacity;
+            this.opacity = (0, Utils_1.setRangeValue)(data.opacity);
         }
         if (data.width !== undefined) {
-            this.width = data.width;
+            this.width = (0, Utils_1.setRangeValue)(data.width);
         }
         if (data.radius !== undefined) {
-            this.radius = data.radius;
+            this.radius = (0, Utils_1.setRangeValue)(data.radius);
         }
         if (data.color !== undefined) {
             this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);

package/Options/Classes/Particles/Repulse/Repulse.d.ts

@@ -1,13 +1,13 @@
+import type { RangeValue, RecursivePartial } from "../../../../Types";
 import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
 import type { IRepulse } from "../../../Interfaces/Particles/Repulse/IRepulse";
-import type { RecursivePartial } from "../../../../Types";
 import { ValueWithRandom } from "../../ValueWithRandom";
 export declare class Repulse extends ValueWithRandom implements IRepulse, IOptionLoader<IRepulse> {
     enabled: boolean;
-    distance: number;
-    duration: number;
-    factor: number;
-    speed: number;
+    distance: RangeValue;
+    duration: RangeValue;
+    factor: RangeValue;
+    speed: RangeValue;
     constructor();
     load(data?: RecursivePartial<IRepulse>): void;
 }

package/Options/Classes/Particles/Repulse/Repulse.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Repulse = void 0;
 const ValueWithRandom_1 = require("../../ValueWithRandom");
+const Utils_1 = require("../../../../Utils");
 class Repulse extends ValueWithRandom_1.ValueWithRandom {
     constructor() {
         super();
@@ -20,16 +21,16 @@ class Repulse extends ValueWithRandom_1.ValueWithRandom {
             this.enabled = data.enabled;
         }
         if (data.distance !== undefined) {
-            this.distance = data.distance;
+            this.distance = (0, Utils_1.setRangeValue)(data.distance);
         }
         if (data.duration !== undefined) {
-            this.duration = data.duration;
+            this.duration = (0, Utils_1.setRangeValue)(data.duration);
         }
         if (data.factor !== undefined) {
-            this.factor = data.factor;
+            this.factor = (0, Utils_1.setRangeValue)(data.factor);
         }
         if (data.speed !== undefined) {
-            this.speed = data.speed;
+            this.speed = (0, Utils_1.setRangeValue)(data.speed);
         }
     }
 }

package/Options/Classes/Particles/Roll/RollLight.d.ts

@@ -1,9 +1,9 @@
+import type { RangeValue, RecursivePartial } from "../../../../Types";
 import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
 import type { IRollLight } from "../../../Interfaces/Particles/Roll/IRollLight";
-import type { RecursivePartial } from "../../../../Types";
 export declare class RollLight implements IRollLight, IOptionLoader<IRollLight> {
     enable: boolean;
-    value: number;
+    value: RangeValue;
     constructor();
     load(data?: RecursivePartial<IRollLight>): void;
 }

package/Options/Classes/Particles/Roll/RollLight.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RollLight = void 0;
+const Utils_1 = require("../../../../Utils");
 class RollLight {
     constructor() {
         this.enable = false;
@@ -14,7 +15,7 @@ class RollLight {
             this.enable = data.enable;
         }
         if (data.value !== undefined) {
-            this.value = data.value;
+            this.value = (0, Utils_1.setRangeValue)(data.value);
         }
     }
 }

package/Options/Classes/Particles/Rotate/RotateAnimation.d.ts

@@ -1,9 +1,9 @@
+import type { RangeValue, RecursivePartial } from "../../../../Types";
 import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
 import type { IRotateAnimation } from "../../../Interfaces/Particles/Rotate/IRotateAnimation";
-import type { RecursivePartial } from "../../../../Types";
 export declare class RotateAnimation implements IRotateAnimation, IOptionLoader<IRotateAnimation> {
     enable: boolean;
-    speed: number;
+    speed: RangeValue;
     sync: boolean;
     constructor();
     load(data?: RecursivePartial<IRotateAnimation>): void;

package/Options/Classes/Particles/Rotate/RotateAnimation.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RotateAnimation = void 0;
+const Utils_1 = require("../../../../Utils");
 class RotateAnimation {
     constructor() {
         this.enable = false;
@@ -15,7 +16,7 @@ class RotateAnimation {
             this.enable = data.enable;
         }
         if (data.speed !== undefined) {
-            this.speed = data.speed;
+            this.speed = (0, Utils_1.setRangeValue)(data.speed);
         }
         if (data.sync !== undefined) {
             this.sync = data.sync;

package/Options/Classes/Particles/Tilt/TiltAnimation.d.ts

@@ -1,9 +1,9 @@
+import type { RangeValue, RecursivePartial } from "../../../../Types";
 import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
 import type { ITiltAnimation } from "../../../Interfaces/Particles/Tilt/ITiltAnimation";
-import type { RecursivePartial } from "../../../../Types";
 export declare class TiltAnimation implements ITiltAnimation, IOptionLoader<ITiltAnimation> {
     enable: boolean;
-    speed: number;
+    speed: RangeValue;
     sync: boolean;
     constructor();
     load(data?: RecursivePartial<ITiltAnimation>): void;