tsparticles 1.37.5 → 1.39.1

package/esm/Updaters/OutModes/OutOfCanvasUpdater.js

@@ -1,6 +1,5 @@
-import { calculateBounds, isPointInside } from "../../Utils";
-import { OutMode, OutModeDirection } from "../../Enums";
 import { bounceHorizontal, bounceVertical } from "./Utils";
+import { calculateBounds, isPointInside } from "../../Utils";
 export class OutOfCanvasUpdater {
     constructor(container) {
         this.container = container;
@@ -13,28 +12,28 @@ export class OutOfCanvasUpdater {
     update(particle, delta) {
         var _a, _b, _c, _d;
         const outModes = particle.options.move.outModes;
-        this.updateOutMode(particle, delta, (_a = outModes.bottom) !== null && _a !== void 0 ? _a : outModes.default, OutModeDirection.bottom);
-        this.updateOutMode(particle, delta, (_b = outModes.left) !== null && _b !== void 0 ? _b : outModes.default, OutModeDirection.left);
-        this.updateOutMode(particle, delta, (_c = outModes.right) !== null && _c !== void 0 ? _c : outModes.default, OutModeDirection.right);
-        this.updateOutMode(particle, delta, (_d = outModes.top) !== null && _d !== void 0 ? _d : outModes.default, OutModeDirection.top);
+        this.updateOutMode(particle, delta, (_a = outModes.bottom) !== null && _a !== void 0 ? _a : outModes.default, "bottom");
+        this.updateOutMode(particle, delta, (_b = outModes.left) !== null && _b !== void 0 ? _b : outModes.default, "left");
+        this.updateOutMode(particle, delta, (_c = outModes.right) !== null && _c !== void 0 ? _c : outModes.default, "right");
+        this.updateOutMode(particle, delta, (_d = outModes.top) !== null && _d !== void 0 ? _d : outModes.default, "top");
     }
     updateOutMode(particle, delta, outMode, direction) {
         switch (outMode) {
-            case OutMode.bounce:
-            case OutMode.bounceVertical:
-            case OutMode.bounceHorizontal:
+            case "bounce":
+            case "bounce-vertical":
+            case "bounce-horizontal":
             case "bounceVertical":
             case "bounceHorizontal":
-            case OutMode.split:
+            case "split":
                 this.bounce(particle, delta, direction, outMode);
                 break;
-            case OutMode.destroy:
+            case "destroy":
                 this.destroy(particle, direction);
                 break;
-            case OutMode.out:
+            case "out":
                 this.out(particle, direction);
                 break;
-            case OutMode.none:
+            case "none":
             default:
                 this.none(particle, direction);
                 break;
@@ -58,7 +57,7 @@ export class OutOfCanvasUpdater {
             right: canvasSize.width + particle.getRadius() + particle.offset.x,
             top: -particle.getRadius() - particle.offset.y,
         }, sizeValue = particle.getRadius(), nextBounds = calculateBounds(particle.position, sizeValue);
-        if (direction === OutModeDirection.right && nextBounds.left > canvasSize.width + particle.offset.x) {
+        if (direction === "right" && nextBounds.left > canvasSize.width + particle.offset.x) {
             particle.position.x = newPos.left;
             particle.initialPosition.x = particle.position.x;
             if (!wrap) {
@@ -66,7 +65,7 @@ export class OutOfCanvasUpdater {
                 particle.initialPosition.y = particle.position.y;
             }
         }
-        else if (direction === OutModeDirection.left && nextBounds.right < -particle.offset.x) {
+        else if (direction === "left" && nextBounds.right < -particle.offset.x) {
             particle.position.x = newPos.right;
             particle.initialPosition.x = particle.position.x;
             if (!wrap) {
@@ -74,7 +73,7 @@ export class OutOfCanvasUpdater {
                 particle.initialPosition.y = particle.position.y;
             }
         }
-        if (direction === OutModeDirection.bottom && nextBounds.top > canvasSize.height + particle.offset.y) {
+        if (direction === "bottom" && nextBounds.top > canvasSize.height + particle.offset.y) {
             if (!wrap) {
                 particle.position.x = Math.random() * canvasSize.width;
                 particle.initialPosition.x = particle.position.x;
@@ -82,7 +81,7 @@ export class OutOfCanvasUpdater {
             particle.position.y = newPos.top;
             particle.initialPosition.y = particle.position.y;
         }
-        else if (direction === OutModeDirection.top && nextBounds.bottom < -particle.offset.y) {
+        else if (direction === "top" && nextBounds.bottom < -particle.offset.y) {
             if (!wrap) {
                 particle.position.x = Math.random() * canvasSize.width;
                 particle.initialPosition.x = particle.position.x;
@@ -111,9 +110,9 @@ export class OutOfCanvasUpdater {
     }
     none(particle, direction) {
         if ((particle.options.move.distance.horizontal &&
-            (direction === OutModeDirection.left || direction === OutModeDirection.right)) ||
+            (direction === "left" || direction === "right")) ||
             (particle.options.move.distance.vertical &&
-                (direction === OutModeDirection.top || direction === OutModeDirection.bottom))) {
+                (direction === "top" || direction === "bottom"))) {
             return;
         }
         const gravityOptions = particle.options.move.gravity, container = this.container;
@@ -134,8 +133,8 @@ export class OutOfCanvasUpdater {
             const position = particle.position;
             if ((!gravityOptions.inverse &&
                 position.y > canvasSize.height + pRadius &&
-                direction === OutModeDirection.bottom) ||
-                (gravityOptions.inverse && position.y < -pRadius && direction === OutModeDirection.top)) {
+                direction === "bottom") ||
+                (gravityOptions.inverse && position.y < -pRadius && direction === "top")) {
                 container.particles.remove(particle);
             }
         }

package/esm/Updaters/OutModes/Utils.js

@@ -1,16 +1,15 @@
-import { OutMode, OutModeDirection } from "../../Enums";
 import { getRangeValue } from "../../Utils";
 export function bounceHorizontal(data) {
-    if (!(data.outMode === OutMode.bounce ||
-        data.outMode === OutMode.bounceHorizontal ||
+    if (!(data.outMode === "bounce" ||
+        data.outMode === "bounce-horizontal" ||
         data.outMode === "bounceHorizontal" ||
-        data.outMode === OutMode.split)) {
+        data.outMode === "split")) {
         return;
     }
     const velocity = data.particle.velocity.x;
     let bounced = false;
-    if ((data.direction === OutModeDirection.right && data.bounds.right >= data.canvasSize.width && velocity > 0) ||
-        (data.direction === OutModeDirection.left && data.bounds.left <= 0 && velocity < 0)) {
+    if ((data.direction === "right" && data.bounds.right >= data.canvasSize.width && velocity > 0) ||
+        (data.direction === "left" && data.bounds.left <= 0 && velocity < 0)) {
         const newVelocity = getRangeValue(data.particle.options.bounce.horizontal.value);
         data.particle.velocity.x *= -newVelocity;
         bounced = true;
@@ -25,21 +24,21 @@ export function bounceHorizontal(data) {
     else if (data.bounds.left <= 0) {
         data.particle.position.x = minPos;
     }
-    if (data.outMode === OutMode.split) {
+    if (data.outMode === "split") {
         data.particle.destroy();
     }
 }
 export function bounceVertical(data) {
-    if (data.outMode === OutMode.bounce ||
-        data.outMode === OutMode.bounceVertical ||
+    if (data.outMode === "bounce" ||
+        data.outMode === "bounce-vertical" ||
         data.outMode === "bounceVertical" ||
-        data.outMode === OutMode.split) {
+        data.outMode === "split") {
         const velocity = data.particle.velocity.y;
         let bounced = false;
-        if ((data.direction === OutModeDirection.bottom &&
+        if ((data.direction === "bottom" &&
             data.bounds.bottom >= data.canvasSize.height &&
             velocity > 0) ||
-            (data.direction === OutModeDirection.top && data.bounds.top <= 0 && velocity < 0)) {
+            (data.direction === "top" && data.bounds.top <= 0 && velocity < 0)) {
             const newVelocity = getRangeValue(data.particle.options.bounce.vertical.value);
             data.particle.velocity.y *= -newVelocity;
             bounced = true;
@@ -54,7 +53,7 @@ export function bounceVertical(data) {
         else if (data.bounds.top <= 0) {
             data.particle.position.y = minPos;
         }
-        if (data.outMode === OutMode.split) {
+        if (data.outMode === "split") {
             data.particle.destroy();
         }
     }

package/esm/Updaters/OutModes/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadOutModesUpdater(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadOutModesUpdater(engine: Engine): Promise<void>;

package/esm/Updaters/OutModes/index.js

@@ -1,4 +1,4 @@
 import { OutOfCanvasUpdater } from "./OutOfCanvasUpdater";
-export async function loadOutModesUpdater(tsParticles) {
-    await tsParticles.addParticleUpdater("outModes", (container) => new OutOfCanvasUpdater(container));
+export async function loadOutModesUpdater(engine) {
+    await engine.addParticleUpdater("outModes", (container) => new OutOfCanvasUpdater(container));
 }

package/esm/Updaters/Roll/RollUpdater.d.ts

@@ -1,5 +1,4 @@
-import type { IDelta, IParticleUpdater } from "../../Core/Interfaces";
-import type { Particle } from "../../Core/Particle";
+import type { IDelta, IParticleUpdater, Particle } from "../../Core";
 export declare class RollUpdater implements IParticleUpdater {
     init(particle: Particle): void;
     isEnabled(particle: Particle): boolean;

package/esm/Updaters/Roll/RollUpdater.js

@@ -1,5 +1,4 @@
 import { colorToHsl, getRangeValue } from "../../Utils";
-import { AlterType } from "../../Enums";
 function updateRoll(particle, delta) {
     const roll = particle.options.roll;
     if (!particle.roll || !roll.enable) {
@@ -24,21 +23,21 @@ export class RollUpdater {
                 particle.backColor = colorToHsl(rollOpt.backColor);
             }
             else if (rollOpt.darken.enable && rollOpt.enlighten.enable) {
-                const alterType = Math.random() >= 0.5 ? AlterType.darken : AlterType.enlighten;
+                const alterType = Math.random() >= 0.5 ? "darken" : "enlighten";
                 particle.roll.alter = {
                     type: alterType,
-                    value: alterType === AlterType.darken ? rollOpt.darken.value : rollOpt.enlighten.value,
+                    value: alterType === "darken" ? rollOpt.darken.value : rollOpt.enlighten.value,
                 };
             }
             else if (rollOpt.darken.enable) {
                 particle.roll.alter = {
-                    type: AlterType.darken,
+                    type: "darken",
                     value: rollOpt.darken.value,
                 };
             }
             else if (rollOpt.enlighten.enable) {
                 particle.roll.alter = {
-                    type: AlterType.enlighten,
+                    type: "enlighten",
                     value: rollOpt.enlighten.value,
                 };
             }

package/esm/Updaters/Roll/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadRollUpdater(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadRollUpdater(engine: Engine): Promise<void>;

package/esm/Updaters/Roll/index.js

@@ -1,4 +1,4 @@
 import { RollUpdater } from "./RollUpdater";
-export async function loadRollUpdater(tsParticles) {
-    await tsParticles.addParticleUpdater("roll", () => new RollUpdater());
+export async function loadRollUpdater(engine) {
+    await engine.addParticleUpdater("roll", () => new RollUpdater());
 }

package/esm/Updaters/Size/SizeUpdater.d.ts

@@ -1,5 +1,4 @@
-import type { Particle } from "../../Core/Particle";
-import type { IDelta, IParticleUpdater } from "../../Core/Interfaces";
+import type { IDelta, IParticleUpdater, Particle } from "../../Core";
 export declare class SizeUpdater implements IParticleUpdater {
     init(): void;
     isEnabled(particle: Particle): boolean;

package/esm/Updaters/Size/SizeUpdater.js

@@ -1,13 +1,12 @@
-import { AnimationStatus, DestroyType } from "../../Enums";
 import { clamp } from "../../Utils";
 function checkDestroy(particle, value, minValue, maxValue) {
     switch (particle.options.size.animation.destroy) {
-        case DestroyType.max:
+        case "max":
             if (value >= maxValue) {
                 particle.destroy();
             }
             break;
-        case DestroyType.min:
+        case "min":
             if (value <= minValue) {
                 particle.destroy();
             }
@@ -25,9 +24,9 @@ function updateSize(particle, delta) {
         return;
     }
     switch (particle.size.status) {
-        case AnimationStatus.increasing:
+        case 0:
             if (particle.size.value >= maxValue) {
-                particle.size.status = AnimationStatus.decreasing;
+                particle.size.status = 1;
                 if (!particle.size.loops) {
                     particle.size.loops = 0;
                 }
@@ -37,9 +36,9 @@ function updateSize(particle, delta) {
                 particle.size.value += sizeVelocity;
             }
             break;
-        case AnimationStatus.decreasing:
+        case 1:
             if (particle.size.value <= minValue) {
-                particle.size.status = AnimationStatus.increasing;
+                particle.size.status = 0;
                 if (!particle.size.loops) {
                     particle.size.loops = 0;
                 }

package/esm/Updaters/Size/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadSizeUpdater(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadSizeUpdater(engine: Engine): Promise<void>;

package/esm/Updaters/Size/index.js

@@ -1,4 +1,4 @@
 import { SizeUpdater } from "./SizeUpdater";
-export async function loadSizeUpdater(tsParticles) {
-    await tsParticles.addParticleUpdater("size", () => new SizeUpdater());
+export async function loadSizeUpdater(engine) {
+    await engine.addParticleUpdater("size", () => new SizeUpdater());
 }

package/esm/Updaters/StrokeColor/StrokeColorUpdater.d.ts

@@ -1,6 +1,4 @@
-import type { Particle } from "../../Core/Particle";
-import type { IDelta, IParticleUpdater } from "../../Core/Interfaces";
-import type { Container } from "../../Core/Container";
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
 export declare class StrokeColorUpdater implements IParticleUpdater {
     private readonly container;
     constructor(container: Container);

package/esm/Updaters/StrokeColor/StrokeColorUpdater.js

@@ -1,5 +1,4 @@
 import { colorToHsl, getHslAnimationFromHsl, itemFromArray, randomInRange } from "../../Utils";
-import { AnimationStatus } from "../../Enums";
 function updateColorValue(delta, value, valueAnimation, max, decrease) {
     var _a;
     const colorValue = value;
@@ -8,17 +7,17 @@ function updateColorValue(delta, value, valueAnimation, max, decrease) {
     }
     const offset = randomInRange(valueAnimation.offset);
     const velocity = ((_a = value.velocity) !== null && _a !== void 0 ? _a : 0) * delta.factor + offset * 3.6;
-    if (!decrease || colorValue.status === AnimationStatus.increasing) {
+    if (!decrease || colorValue.status === 0) {
         colorValue.value += velocity;
         if (decrease && colorValue.value > max) {
-            colorValue.status = AnimationStatus.decreasing;
+            colorValue.status = 1;
             colorValue.value -= colorValue.value % max;
         }
     }
     else {
         colorValue.value -= velocity;
         if (colorValue.value < 0) {
-            colorValue.status = AnimationStatus.increasing;
+            colorValue.status = 0;
             colorValue.value += colorValue.value;
         }
     }

package/esm/Updaters/StrokeColor/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadStrokeColorUpdater(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadStrokeColorUpdater(engine: Engine): Promise<void>;

package/esm/Updaters/StrokeColor/index.js

@@ -1,4 +1,4 @@
 import { StrokeColorUpdater } from "./StrokeColorUpdater";
-export async function loadStrokeColorUpdater(tsParticles) {
-    await tsParticles.addParticleUpdater("strokeColor", (container) => new StrokeColorUpdater(container));
+export async function loadStrokeColorUpdater(engine) {
+    await engine.addParticleUpdater("strokeColor", (container) => new StrokeColorUpdater(container));
 }

package/esm/Updaters/Tilt/TiltUpdater.d.ts

@@ -1,6 +1,4 @@
-import type { IDelta, IParticleUpdater } from "../../Core/Interfaces";
-import type { Particle } from "../../Core/Particle";
-import { Container } from "../../Core/Container";
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
 export declare class TiltUpdater implements IParticleUpdater {
     private readonly container;
     constructor(container: Container);

package/esm/Updaters/Tilt/TiltUpdater.js

@@ -1,4 +1,3 @@
-import { AnimationStatus, TiltDirection } from "../../Enums";
 import { getRangeValue } from "../../Utils";
 function updateTilt(particle, delta) {
     var _a;
@@ -13,13 +12,13 @@ function updateTilt(particle, delta) {
         return;
     }
     switch (particle.tilt.status) {
-        case AnimationStatus.increasing:
+        case 0:
             particle.tilt.value += speed;
             if (particle.tilt.value > max) {
                 particle.tilt.value -= max;
             }
             break;
-        case AnimationStatus.decreasing:
+        case 1:
         default:
             particle.tilt.value -= speed;
             if (particle.tilt.value < 0) {
@@ -41,17 +40,17 @@ export class TiltUpdater {
             cosDirection: Math.random() >= 0.5 ? 1 : -1,
         };
         let tiltDirection = tiltOptions.direction;
-        if (tiltDirection === TiltDirection.random) {
+        if (tiltDirection === "random") {
             const index = Math.floor(Math.random() * 2);
-            tiltDirection = index > 0 ? TiltDirection.counterClockwise : TiltDirection.clockwise;
+            tiltDirection = index > 0 ? "counter-clockwise" : "clockwise";
         }
         switch (tiltDirection) {
-            case TiltDirection.counterClockwise:
+            case "counter-clockwise":
             case "counterClockwise":
-                particle.tilt.status = AnimationStatus.decreasing;
+                particle.tilt.status = 1;
                 break;
-            case TiltDirection.clockwise:
-                particle.tilt.status = AnimationStatus.increasing;
+            case "clockwise":
+                particle.tilt.status = 0;
                 break;
         }
         const tiltAnimation = particle.options.tilt.animation;

package/esm/Updaters/Tilt/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadTiltUpdater(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadTiltUpdater(engine: Engine): Promise<void>;

package/esm/Updaters/Tilt/index.js

@@ -1,4 +1,4 @@
 import { TiltUpdater } from "./TiltUpdater";
-export async function loadTiltUpdater(tsParticles) {
-    await tsParticles.addParticleUpdater("tilt", (container) => new TiltUpdater(container));
+export async function loadTiltUpdater(engine) {
+    await engine.addParticleUpdater("tilt", (container) => new TiltUpdater(container));
 }

package/esm/Updaters/Wobble/WobbleUpdater.d.ts

@@ -1,6 +1,4 @@
-import type { IDelta, IParticleUpdater } from "../../Core/Interfaces";
-import type { Particle } from "../../Core/Particle";
-import type { Container } from "../../Core/Container";
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
 declare type WobbleParticle = Particle & {
     retina: {
         wobbleDistance?: number;

package/esm/Updaters/Wobble/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadWobbleUpdater(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadWobbleUpdater(engine: Engine): Promise<void>;

package/esm/Updaters/Wobble/index.js

@@ -1,4 +1,4 @@
 import { WobbleUpdater } from "./WobbleUpdater";
-export async function loadWobbleUpdater(tsParticles) {
-    await tsParticles.addParticleUpdater("wobble", (container) => new WobbleUpdater(container));
+export async function loadWobbleUpdater(engine) {
+    await engine.addParticleUpdater("wobble", (container) => new WobbleUpdater(container));
 }

package/esm/Utils/CanvasUtils.d.ts

@@ -1,9 +1,8 @@
+import { AlterType } from "../Enums";
+import type { Container, IContainerPlugin, ICoordinates, IDelta, IDimension, IHsl, IParticle, IParticleGradientAnimation, IRgb } from "../Core";
 import type { ILinksShadow } from "../Options/Interfaces/Particles/Links/ILinksShadow";
 import type { IShadow } from "../Options/Interfaces/Particles/IShadow";
-import type { Container } from "../Core/Container";
-import type { IContainerPlugin, ICoordinates, IDelta, IDimension, IHsl, IParticle, IParticleGradientAnimation, IRgb } from "../Core/Interfaces";
-import type { Particle } from "../Core/Particle";
-import { AlterType } from "../Enums";
+import type { Particle } from "../Core";
 export declare function paintBase(context: CanvasRenderingContext2D, dimension: IDimension, baseColor?: string): void;
 export declare function clear(context: CanvasRenderingContext2D, dimension: IDimension): void;
 export declare function drawLinkLine(context: CanvasRenderingContext2D, width: number, begin: ICoordinates, end: ICoordinates, maxDistance: number, canvasSize: IDimension, warp: boolean, backgroundMask: boolean, composite: string, colorLine: IRgb, opacity: number, shadow: ILinksShadow): void;

package/esm/Utils/CanvasUtils.js

@@ -1,6 +1,5 @@
-import { getDistance, getDistances } from "./NumberUtils";
 import { colorMix, colorToRgb, getStyleFromHsl, getStyleFromRgb } from "./ColorUtils";
-import { AlterType, GradientType, RollMode } from "../Enums";
+import { getDistance, getDistances } from "./NumberUtils";
 function drawLine(context, begin, end) {
     context.beginPath();
     context.moveTo(begin.x, begin.y);
@@ -140,8 +139,8 @@ export function drawParticle(container, context, particle, delta, fillColorValue
     if (tiltOptions.enable || rollOptions.enable) {
         const roll = rollOptions.enable && particle.roll;
         const tilt = tiltOptions.enable && particle.tilt;
-        const rollHorizontal = roll && (rollOptions.mode === RollMode.horizontal || rollOptions.mode === RollMode.both);
-        const rollVertical = roll && (rollOptions.mode === RollMode.vertical || rollOptions.mode === RollMode.both);
+        const rollHorizontal = roll && (rollOptions.mode === "horizontal" || rollOptions.mode === "both");
+        const rollVertical = roll && (rollOptions.mode === "vertical" || rollOptions.mode === "both");
         context.setTransform(rollHorizontal ? Math.cos(particle.roll.angle) : 1, tilt ? Math.cos(particle.tilt.value) * particle.tilt.cosDirection : 0, tilt ? Math.sin(particle.tilt.value) * particle.tilt.sinDirection : 0, rollVertical ? Math.sin(particle.roll.angle) : 1, pos.x, pos.y);
     }
     else {
@@ -164,7 +163,7 @@ export function drawParticle(container, context, particle, delta, fillColorValue
     }
     if (gradient) {
         const gradientAngle = gradient.angle.value;
-        const fillGradient = gradient.type === GradientType.radial
+        const fillGradient = gradient.type === "radial"
             ? context.createRadialGradient(0, 0, 0, 0, 0, radius)
             : context.createLinearGradient(Math.cos(gradientAngle) * -radius, Math.sin(gradientAngle) * -radius, Math.cos(gradientAngle) * radius, Math.sin(gradientAngle) * radius);
         for (const color of gradient.colors) {
@@ -266,6 +265,6 @@ export function alterHsl(color, type, value) {
     return {
         h: color.h,
         s: color.s,
-        l: color.l + (type === AlterType.darken ? -1 : 1) * value,
+        l: color.l + (type === "darken" ? -1 : 1) * value,
     };
 }

package/esm/Utils/ColorUtils.d.ts

@@ -1,4 +1,4 @@
-import type { IColor, IHsl, IHsla, IHsv, IHsva, IParticle, IParticleHslAnimation, IRgb, IRgba } from "../Core/Interfaces";
+import type { IColor, IHsl, IHsla, IHsv, IHsva, IParticle, IParticleHslAnimation, IRgb, IRgba } from "../Core";
 import type { HslAnimation } from "../Options/Classes/HslAnimation";
 export declare function colorToRgb(input?: string | IColor, index?: number, useIndex?: boolean): IRgb | undefined;
 export declare function colorToHsl(color: string | IColor | undefined, index?: number, useIndex?: boolean): IHsl | undefined;

package/esm/Utils/ColorUtils.js

@@ -1,7 +1,6 @@
-import { itemFromArray } from "./Utils";
-import { Constants } from "./Constants";
 import { mix, randomInRange, setRangeValue } from "./NumberUtils";
-import { AnimationStatus } from "../Enums";
+import { Constants } from "../Core";
+import { itemFromArray } from "./Utils";
 function hue2rgb(p, q, t) {
     let tCalc = t;
     if (tCalc < 0) {
@@ -438,7 +437,7 @@ function setColorAnimation(colorValue, colorAnimation, reduceFactor) {
         if (colorAnimation.sync) {
             return;
         }
-        colorValue.status = AnimationStatus.increasing;
+        colorValue.status = 0;
         colorValue.velocity *= Math.random();
         if (colorValue.value) {
             colorValue.value *= Math.random();

package/esm/Utils/NumberUtils.d.ts

@@ -1,8 +1,8 @@
-import type { IValueWithRandom } from "../Options/Interfaces/IValueWithRandom";
-import type { ICoordinates } from "../Core/Interfaces";
 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/Particle/Vector";
+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;

package/esm/Utils/NumberUtils.js

@@ -1,5 +1,4 @@
-import { EasingType, MoveDirection } from "../Enums";
-import { Vector } from "../Core/Particle/Vector";
+import { Vector } from "../Core";
 export function clamp(num, min, max) {
     return Math.min(Math.max(num, min), max);
 }
@@ -54,23 +53,23 @@ export function getParticleDirectionAngle(direction) {
     }
     else {
         switch (direction) {
-            case MoveDirection.top:
+            case "top":
                 return -Math.PI / 2;
-            case MoveDirection.topRight:
+            case "top-right":
                 return -Math.PI / 4;
-            case MoveDirection.right:
+            case "right":
                 return 0;
-            case MoveDirection.bottomRight:
+            case "bottom-right":
                 return Math.PI / 4;
-            case MoveDirection.bottom:
+            case "bottom":
                 return Math.PI / 2;
-            case MoveDirection.bottomLeft:
+            case "bottom-left":
                 return (3 * Math.PI) / 4;
-            case MoveDirection.left:
+            case "left":
                 return Math.PI;
-            case MoveDirection.topLeft:
+            case "top-left":
                 return (-3 * Math.PI) / 4;
-            case MoveDirection.none:
+            case "none":
             default:
                 return Math.random() * Math.PI * 2;
         }
@@ -87,24 +86,24 @@ export function collisionVelocity(v1, v2, m1, m2) {
 }
 export function calcEasing(value, type) {
     switch (type) {
-        case EasingType.easeOutQuad:
+        case "ease-out-quad":
             return 1 - (1 - value) ** 2;
-        case EasingType.easeOutCubic:
+        case "ease-out-cubic":
             return 1 - (1 - value) ** 3;
-        case EasingType.easeOutQuart:
+        case "ease-out-quart":
             return 1 - (1 - value) ** 4;
-        case EasingType.easeOutQuint:
+        case "ease-out-quint":
             return 1 - (1 - value) ** 5;
-        case EasingType.easeOutExpo:
+        case "ease-out-expo":
             return value === 1 ? 1 : 1 - Math.pow(2, -10 * value);
-        case EasingType.easeOutSine:
+        case "ease-out-sine":
             return Math.sin((value * Math.PI) / 2);
-        case EasingType.easeOutBack: {
+        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 EasingType.easeOutCirc:
+        case "ease-out-circ":
             return Math.sqrt(1 - Math.pow(value - 1, 2));
         default:
             return value;

package/esm/Utils/Utils.d.ts

@@ -1,9 +1,9 @@
-import type { IBounds, ICircleBouncer, ICoordinates, IDimension, IParticle } from "../Core/Interfaces";
 import { DivMode, OutModeDirection } from "../Enums";
-import type { ICharacterShape } from "../Options/Interfaces/Particles/Shape/ICharacterShape";
-import type { SingleOrMultiple } from "../Types";
+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;