tsparticles 1.37.4 → 1.39.0

package/browser/Shapes/Image/Utils.js

@@ -1,53 +1,87 @@
 import { getStyleFromHsl } from "../../Utils";
-export function loadImage(source) {
-    return new Promise((resolve, reject) => {
-        if (!source) {
-            reject("Error tsParticles - No image.src");
-            return;
-        }
-        const image = {
-            source: source,
-            type: source.substr(source.length - 3),
-        };
+const currentColorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d.]+%?\))|currentcolor/gi;
+function replaceColorSvg(imageShape, color, opacity) {
+    const { svgData } = imageShape;
+    if (!svgData) {
+        return "";
+    }
+    const colorStyle = getStyleFromHsl(color, opacity);
+    /* set color to svg element */
+    if (svgData.includes("fill")) {
+        return svgData.replace(currentColorRegex, () => colorStyle);
+    }
+    const preFillIndex = svgData.indexOf(">");
+    return `${svgData.substring(0, preFillIndex)} fill="${colorStyle}"${svgData.substring(preFillIndex)}`;
+}
+export async function loadImage(image) {
+    return new Promise((resolve) => {
+        image.loading = true;
         const img = new Image();
         img.addEventListener("load", () => {
             image.element = img;
-            resolve(image);
+            image.loading = false;
+            resolve();
         });
         img.addEventListener("error", () => {
-            reject(`Error tsParticles - loading image: ${source}`);
+            image.error = true;
+            image.loading = false;
+            console.error(`Error tsParticles - loading image: ${image.source}`);
+            resolve();
         });
-        img.src = source;
+        img.src = image.source;
     });
 }
-export async function downloadSvgImage(source) {
-    if (!source) {
-        throw new Error("Error tsParticles - No image.src");
-    }
-    const image = {
-        source: source,
-        type: source.substr(source.length - 3),
-    };
+export async function downloadSvgImage(image) {
     if (image.type !== "svg") {
-        return loadImage(source);
+        await loadImage(image);
+        return;
     }
+    image.loading = true;
     const response = await fetch(image.source);
+    image.loading = false;
     if (!response.ok) {
-        throw new Error("Error tsParticles - Image not found");
+        console.error("Error tsParticles - Image not found");
+        image.error = true;
     }
-    image.svgData = await response.text();
-    return image;
-}
-export function replaceColorSvg(imageShape, color, opacity) {
-    const { svgData } = imageShape;
-    if (!svgData) {
-        return "";
+    if (!image.error) {
+        image.svgData = await response.text();
     }
-    /* set color to svg element */
-    if (svgData.includes("fill")) {
-        const currentColor = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d.]+%?\))|currentcolor/gi;
-        return svgData.replace(currentColor, () => getStyleFromHsl(color, opacity));
-    }
-    const preFillIndex = svgData.indexOf(">");
-    return `${svgData.substring(0, preFillIndex)} fill="${getStyleFromHsl(color, opacity)}"${svgData.substring(preFillIndex)}`;
+}
+export function replaceImageColor(image, imageData, color, particle) {
+    var _a, _b, _c;
+    const svgColoredData = replaceColorSvg(image, color, (_b = (_a = particle.opacity) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 1);
+    /* prepare to create img with colored svg */
+    const svg = new Blob([svgColoredData], { type: "image/svg+xml" });
+    const domUrl = URL || window.URL || window.webkitURL || window;
+    const url = domUrl.createObjectURL(svg);
+    /* create particle img obj */
+    const img = new Image();
+    const imageRes = {
+        data: Object.assign(Object.assign({}, image), { svgData: svgColoredData }),
+        ratio: imageData.width / imageData.height,
+        replaceColor: (_c = imageData.replaceColor) !== null && _c !== void 0 ? _c : imageData.replace_color,
+        source: imageData.src,
+    };
+    img.addEventListener("load", () => {
+        const pImage = particle.image;
+        if (pImage) {
+            pImage.loaded = true;
+            image.element = img;
+        }
+        domUrl.revokeObjectURL(url);
+    });
+    img.addEventListener("error", () => {
+        domUrl.revokeObjectURL(url);
+        const img2 = Object.assign(Object.assign({}, image), { error: false, loading: true });
+        // deepcode ignore PromiseNotCaughtGeneral: catch can be ignored
+        loadImage(img2).then(() => {
+            const pImage = particle.image;
+            if (pImage) {
+                image.element = img2.element;
+                pImage.loaded = true;
+            }
+        });
+    });
+    img.src = url;
+    return imageRes;
 }

package/browser/Shapes/Image/index.d.ts

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

package/browser/Shapes/Line/LineDrawer.d.ts

@@ -1,4 +1,4 @@
-import { IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { IParticle, IShapeDrawer } from "../../Core";
 /**
  * @category Shape Drawers
  */

package/browser/Shapes/Line/index.d.ts

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

package/browser/Shapes/Polygon/PolygonDrawer.d.ts

@@ -1,6 +1,6 @@
 import type { ISide } from "./PolygonDrawerBase";
 import { PolygonDrawerBase } from "./PolygonDrawerBase";
-import type { ICoordinates, IParticle } from "../../Core/Interfaces";
+import type { ICoordinates, IParticle } from "../../Core";
 /**
  * @category Shape Drawers
  */

package/browser/Shapes/Polygon/PolygonDrawerBase.d.ts

@@ -1,4 +1,4 @@
-import type { ICoordinates, IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { ICoordinates, IParticle, IShapeDrawer } from "../../Core";
 export interface ISideCount {
     numerator: number;
     denominator: number;

package/browser/Shapes/Polygon/TriangleDrawer.d.ts

@@ -1,5 +1,5 @@
 import type { ISide } from "./PolygonDrawerBase";
-import type { ICoordinates, IParticle } from "../../Core/Interfaces";
+import type { ICoordinates, IParticle } from "../../Core";
 import { PolygonDrawerBase } from "./PolygonDrawerBase";
 /**
  * @category Shape Drawers

package/browser/Shapes/Polygon/index.d.ts

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

package/browser/Shapes/Square/SquareDrawer.d.ts

@@ -1,4 +1,4 @@
-import type { IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { IParticle, IShapeDrawer } from "../../Core";
 /**
  * @category Shape Drawers
  */

package/browser/Shapes/Square/index.d.ts

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

package/browser/Shapes/Star/StarDrawer.d.ts

@@ -1,4 +1,4 @@
-import type { IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { IParticle, IShapeDrawer } from "../../Core";
 /**
  * @category Shape Drawers
  */

package/browser/Shapes/Star/index.d.ts

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

package/browser/Shapes/Text/TextDrawer.d.ts

@@ -1,5 +1,4 @@
-import type { IParticle, IShapeDrawer } from "../../Core/Interfaces";
-import type { Container } from "../../Core/Container";
+import type { Container, IParticle, IShapeDrawer } from "../../Core";
 export declare const validTypes: string[];
 /**
  * @category Shape Drawers

package/browser/Shapes/Text/index.d.ts

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

package/browser/Updaters/Angle/AngleUpdater.d.ts

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

package/browser/Updaters/Angle/AngleUpdater.js

@@ -1,4 +1,3 @@
-import { AnimationStatus, RotateDirection } from "../../Enums";
 import { getRangeValue } from "../../Utils";
 function updateAngle(particle, delta) {
     var _a;
@@ -14,13 +13,13 @@ function updateAngle(particle, delta) {
         return;
     }
     switch (rotate.status) {
-        case AnimationStatus.increasing:
+        case 0 /* increasing */:
             rotate.value += speed;
             if (rotate.value > max) {
                 rotate.value -= max;
             }
             break;
-        case AnimationStatus.decreasing:
+        case 1 /* decreasing */:
         default:
             rotate.value -= speed;
             if (rotate.value < 0) {
@@ -40,17 +39,17 @@ export class AngleUpdater {
             value: (getRangeValue(rotateOptions.value) * Math.PI) / 180,
         };
         let rotateDirection = rotateOptions.direction;
-        if (rotateDirection === RotateDirection.random) {
+        if (rotateDirection === "random" /* random */) {
             const index = Math.floor(Math.random() * 2);
-            rotateDirection = index > 0 ? RotateDirection.counterClockwise : RotateDirection.clockwise;
+            rotateDirection = index > 0 ? "counter-clockwise" /* counterClockwise */ : "clockwise" /* clockwise */;
         }
         switch (rotateDirection) {
-            case RotateDirection.counterClockwise:
+            case "counter-clockwise" /* counterClockwise */:
             case "counterClockwise":
-                particle.rotate.status = AnimationStatus.decreasing;
+                particle.rotate.status = 1 /* decreasing */;
                 break;
-            case RotateDirection.clockwise:
-                particle.rotate.status = AnimationStatus.increasing;
+            case "clockwise" /* clockwise */:
+                particle.rotate.status = 0 /* increasing */;
                 break;
         }
         const rotateAnimation = particle.options.rotate.animation;

package/browser/Updaters/Angle/index.d.ts

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

package/browser/Updaters/Color/ColorUpdater.d.ts

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

package/browser/Updaters/Color/ColorUpdater.js

@@ -1,4 +1,3 @@
-import { AnimationStatus } from "../../Enums";
 import { colorToHsl, getHslAnimationFromHsl, randomInRange } from "../../Utils";
 function updateColorValue(delta, value, valueAnimation, max, decrease) {
     var _a;
@@ -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 /* increasing */) {
         colorValue.value += velocity;
         if (decrease && colorValue.value > max) {
-            colorValue.status = AnimationStatus.decreasing;
+            colorValue.status = 1 /* decreasing */;
             colorValue.value -= colorValue.value % max;
         }
     }
     else {
         colorValue.value -= velocity;
         if (colorValue.value < 0) {
-            colorValue.status = AnimationStatus.increasing;
+            colorValue.status = 0 /* increasing */;
             colorValue.value += colorValue.value;
         }
     }

package/browser/Updaters/Color/index.d.ts

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

package/browser/Updaters/Life/LifeUpdater.d.ts

@@ -1,6 +1,4 @@
-import { 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 LifeUpdater implements IParticleUpdater {
     private readonly container;
     constructor(container: Container);

package/browser/Updaters/Life/index.d.ts

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

package/browser/Updaters/Opacity/OpacityUpdater.d.ts

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

package/browser/Updaters/Opacity/OpacityUpdater.js

@@ -1,13 +1,12 @@
-import { AnimationStatus, DestroyType, StartValueType } from "../../Enums";
 import { clamp, getRangeMax, getRangeMin, getRangeValue, randomInRange } from "../../Utils";
 function checkDestroy(particle, value, minValue, maxValue) {
     switch (particle.options.opacity.animation.destroy) {
-        case DestroyType.max:
+        case "max" /* max */:
             if (value >= maxValue) {
                 particle.destroy();
             }
             break;
-        case DestroyType.min:
+        case "min" /* min */:
             if (value <= minValue) {
                 particle.destroy();
             }
@@ -27,9 +26,9 @@ function updateOpacity(particle, delta) {
         return;
     }
     switch (particle.opacity.status) {
-        case AnimationStatus.increasing:
+        case 0 /* increasing */:
             if (particle.opacity.value >= maxValue) {
-                particle.opacity.status = AnimationStatus.decreasing;
+                particle.opacity.status = 1 /* decreasing */;
                 if (!particle.opacity.loops) {
                     particle.opacity.loops = 0;
                 }
@@ -39,9 +38,9 @@ function updateOpacity(particle, delta) {
                 particle.opacity.value += ((_d = particle.opacity.velocity) !== null && _d !== void 0 ? _d : 0) * delta.factor;
             }
             break;
-        case AnimationStatus.decreasing:
+        case 1 /* decreasing */:
             if (particle.opacity.value <= minValue) {
-                particle.opacity.status = AnimationStatus.increasing;
+                particle.opacity.status = 0 /* increasing */;
                 if (!particle.opacity.loops) {
                     particle.opacity.loops = 0;
                 }
@@ -74,24 +73,24 @@ export class OpacityUpdater {
         };
         const opacityAnimation = opacityOptions.animation;
         if (opacityAnimation.enable) {
-            particle.opacity.status = AnimationStatus.increasing;
+            particle.opacity.status = 0 /* increasing */;
             const opacityRange = opacityOptions.value;
             particle.opacity.min = getRangeMin(opacityRange);
             particle.opacity.max = getRangeMax(opacityRange);
             switch (opacityAnimation.startValue) {
-                case StartValueType.min:
+                case "min" /* min */:
                     particle.opacity.value = particle.opacity.min;
-                    particle.opacity.status = AnimationStatus.increasing;
+                    particle.opacity.status = 0 /* increasing */;
                     break;
-                case StartValueType.random:
+                case "random" /* random */:
                     particle.opacity.value = randomInRange(particle.opacity);
                     particle.opacity.status =
-                        Math.random() >= 0.5 ? AnimationStatus.increasing : AnimationStatus.decreasing;
+                        Math.random() >= 0.5 ? 0 /* increasing */ : 1 /* decreasing */;
                     break;
-                case StartValueType.max:
+                case "max" /* max */:
                 default:
                     particle.opacity.value = particle.opacity.max;
-                    particle.opacity.status = AnimationStatus.decreasing;
+                    particle.opacity.status = 1 /* decreasing */;
                     break;
             }
             particle.opacity.velocity = (opacityAnimation.speed / 100) * this.container.retina.reduceFactor;

package/browser/Updaters/Opacity/index.d.ts

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

package/browser/Updaters/OutModes/IBounceData.d.ts

@@ -1,6 +1,5 @@
-import type { Particle } from "../../Core/Particle";
 import type { OutMode, OutModeAlt, OutModeDirection } from "../../Enums";
-import type { IBounds, ICoordinates, IDimension } from "../../Core/Interfaces";
+import type { IBounds, ICoordinates, IDimension, Particle } from "../../Core";
 export interface IBounceData {
     particle: Particle;
     outMode: OutMode | OutModeAlt | keyof typeof OutMode;

package/browser/Updaters/OutModes/OutOfCanvasUpdater.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";
 export declare class OutOfCanvasUpdater implements IParticleUpdater {
     private readonly container;
     constructor(container: Container);

package/browser/Updaters/OutModes/OutOfCanvasUpdater.js

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

package/browser/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" /* bounce */ ||
+        data.outMode === "bounce-horizontal" /* bounceHorizontal */ ||
         data.outMode === "bounceHorizontal" ||
-        data.outMode === OutMode.split)) {
+        data.outMode === "split" /* 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" /* right */ && data.bounds.right >= data.canvasSize.width && velocity > 0) ||
+        (data.direction === "left" /* 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" /* split */) {
         data.particle.destroy();
     }
 }
 export function bounceVertical(data) {
-    if (data.outMode === OutMode.bounce ||
-        data.outMode === OutMode.bounceVertical ||
+    if (data.outMode === "bounce" /* bounce */ ||
+        data.outMode === "bounce-vertical" /* bounceVertical */ ||
         data.outMode === "bounceVertical" ||
-        data.outMode === OutMode.split) {
+        data.outMode === "split" /* split */) {
         const velocity = data.particle.velocity.y;
         let bounced = false;
-        if ((data.direction === OutModeDirection.bottom &&
+        if ((data.direction === "bottom" /* bottom */ &&
             data.bounds.bottom >= data.canvasSize.height &&
             velocity > 0) ||
-            (data.direction === OutModeDirection.top && data.bounds.top <= 0 && velocity < 0)) {
+            (data.direction === "top" /* 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" /* split */) {
             data.particle.destroy();
         }
     }

package/browser/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(tsParticles: Engine): Promise<void>;

package/browser/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;