tsparticles 1.37.6 → 1.39.2

package/esm/Shapes/Image/Utils.js

@@ -1,52 +1,83 @@
 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);
+    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 (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));
+    if (!image.error) {
+        image.svgData = await response.text();
     }
-    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);
+    const svg = new Blob([svgColoredData], { type: "image/svg+xml" });
+    const domUrl = URL || window.URL || window.webkitURL || window;
+    const url = domUrl.createObjectURL(svg);
+    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 });
+        loadImage(img2).then(() => {
+            const pImage = particle.image;
+            if (pImage) {
+                image.element = img2.element;
+                pImage.loaded = true;
+            }
+        });
+    });
+    img.src = url;
+    return imageRes;
 }

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

package/esm/Shapes/Image/index.js

@@ -1,6 +1,6 @@
 import { ImageDrawer } from "./ImageDrawer";
-export async function loadImageShape(tsParticles) {
+export async function loadImageShape(engine) {
     const imageDrawer = new ImageDrawer();
-    await tsParticles.addShape("image", imageDrawer);
-    await tsParticles.addShape("images", imageDrawer);
+    await engine.addShape("image", imageDrawer);
+    await engine.addShape("images", imageDrawer);
 }

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

@@ -1,4 +1,4 @@
-import { IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { IParticle, IShapeDrawer } from "../../Core";
 export declare class LineDrawer implements IShapeDrawer {
     getSidesCount(): number;
     draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;

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

package/esm/Shapes/Line/index.js

@@ -1,4 +1,4 @@
 import { LineDrawer } from "./LineDrawer";
-export async function loadLineShape(tsParticles) {
-    await tsParticles.addShape("line", new LineDrawer());
+export async function loadLineShape(engine) {
+    await engine.addShape("line", new LineDrawer());
 }

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

@@ -1,6 +1,6 @@
+import type { ICoordinates, IParticle } from "../../Core";
 import type { ISide } from "./PolygonDrawerBase";
 import { PolygonDrawerBase } from "./PolygonDrawerBase";
-import type { ICoordinates, IParticle } from "../../Core/Interfaces";
 export declare class PolygonDrawer extends PolygonDrawerBase {
     getSidesData(particle: IParticle, radius: number): ISide;
     getCenter(particle: IParticle, radius: number): ICoordinates;

package/esm/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/esm/Shapes/Polygon/TriangleDrawer.d.ts

@@ -1,5 +1,5 @@
+import type { ICoordinates, IParticle } from "../../Core";
 import type { ISide } from "./PolygonDrawerBase";
-import type { ICoordinates, IParticle } from "../../Core/Interfaces";
 import { PolygonDrawerBase } from "./PolygonDrawerBase";
 export declare class TriangleDrawer extends PolygonDrawerBase {
     getSidesCount(): number;

package/esm/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(engine: Engine): Promise<void>;
+export declare function loadTriangleShape(engine: Engine): Promise<void>;
+export declare function loadPolygonShape(engine: Engine): Promise<void>;

package/esm/Shapes/Polygon/index.js

@@ -1,12 +1,12 @@
 import { PolygonDrawer } from "./PolygonDrawer";
 import { TriangleDrawer } from "./TriangleDrawer";
-export async function loadGenericPolygonShape(tsParticles) {
-    await tsParticles.addShape("polygon", new PolygonDrawer());
+export async function loadGenericPolygonShape(engine) {
+    await engine.addShape("polygon", new PolygonDrawer());
 }
-export async function loadTriangleShape(tsParticles) {
-    await tsParticles.addShape("triangle", new TriangleDrawer());
+export async function loadTriangleShape(engine) {
+    await engine.addShape("triangle", new TriangleDrawer());
 }
-export async function loadPolygonShape(tsParticles) {
-    await loadGenericPolygonShape(tsParticles);
-    await loadTriangleShape(tsParticles);
+export async function loadPolygonShape(engine) {
+    await loadGenericPolygonShape(engine);
+    await loadTriangleShape(engine);
 }

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

@@ -1,4 +1,4 @@
-import type { IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { IParticle, IShapeDrawer } from "../../Core";
 export declare class SquareDrawer implements IShapeDrawer {
     getSidesCount(): number;
     draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;

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

package/esm/Shapes/Square/index.js

@@ -1,6 +1,6 @@
 import { SquareDrawer } from "./SquareDrawer";
-export async function loadSquareShape(tsParticles) {
+export async function loadSquareShape(engine) {
     const drawer = new SquareDrawer();
-    await tsParticles.addShape("edge", drawer);
-    await tsParticles.addShape("square", drawer);
+    await engine.addShape("edge", drawer);
+    await engine.addShape("square", drawer);
 }

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

@@ -1,4 +1,4 @@
-import type { IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { IParticle, IShapeDrawer } from "../../Core";
 export declare class StarDrawer implements IShapeDrawer {
     getSidesCount(particle: IParticle): number;
     draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;

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

package/esm/Shapes/Star/index.js

@@ -1,4 +1,4 @@
 import { StarDrawer } from "./StarDrawer";
-export async function loadStarShape(tsParticles) {
-    await tsParticles.addShape("star", new StarDrawer());
+export async function loadStarShape(engine) {
+    await engine.addShape("star", new StarDrawer());
 }

package/esm/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[];
 export declare class TextDrawer implements IShapeDrawer {
     getSidesCount(): number;

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

package/esm/Shapes/Text/index.js

@@ -1,7 +1,7 @@
-import { validTypes, TextDrawer } from "./TextDrawer";
-export async function loadTextShape(tsParticles) {
+import { TextDrawer, validTypes } from "./TextDrawer";
+export async function loadTextShape(engine) {
     const drawer = new TextDrawer();
     for (const type of validTypes) {
-        await tsParticles.addShape(type, drawer);
+        await engine.addShape(type, drawer);
     }
 }

package/esm/Types/ShapeData.d.ts

@@ -1,5 +1,5 @@
-import type { SingleOrMultiple } from "./SingleOrMultiple";
 import type { IShapeValues } from "../Options/Interfaces/Particles/Shape/IShapeValues";
+import type { SingleOrMultiple } from "./SingleOrMultiple";
 export declare type ShapeData = {
     [type: string]: SingleOrMultiple<IShapeValues>;
 };

package/esm/Types/ShapeDrawerFunctions.d.ts

@@ -1,6 +1,6 @@
-import type { IParticle } from "../Core/Interfaces/IParticle";
 import type { Container } from "../Core/Container";
 import type { IDelta } from "../Core/Interfaces/IDelta";
+import type { IParticle } from "../Core/Interfaces/IParticle";
 import { Particle } from "../Core/Particle";
 export declare type ShapeDrawerDrawFunction = (context: CanvasRenderingContext2D, particle: IParticle, radius: number, opacity: number, delta: IDelta, pixelRatio: number) => void;
 export declare type ShapeDrawerInitFunction = (container: Container) => Promise<void>;

package/esm/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/esm/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:
             rotate.value += speed;
             if (rotate.value > max) {
                 rotate.value -= max;
             }
             break;
-        case AnimationStatus.decreasing:
+        case 1:
         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") {
             const index = Math.floor(Math.random() * 2);
-            rotateDirection = index > 0 ? RotateDirection.counterClockwise : RotateDirection.clockwise;
+            rotateDirection = index > 0 ? "counter-clockwise" : "clockwise";
         }
         switch (rotateDirection) {
-            case RotateDirection.counterClockwise:
+            case "counter-clockwise":
             case "counterClockwise":
-                particle.rotate.status = AnimationStatus.decreasing;
+                particle.rotate.status = 1;
                 break;
-            case RotateDirection.clockwise:
-                particle.rotate.status = AnimationStatus.increasing;
+            case "clockwise":
+                particle.rotate.status = 0;
                 break;
         }
         const rotateAnimation = particle.options.rotate.animation;

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

package/esm/Updaters/Angle/index.js

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

package/esm/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/esm/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) {
         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/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(engine: Engine): Promise<void>;

package/esm/Updaters/Color/index.js

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

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

package/esm/Updaters/Life/index.js

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

package/esm/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/esm/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":
             if (value >= maxValue) {
                 particle.destroy();
             }
             break;
-        case DestroyType.min:
+        case "min":
             if (value <= minValue) {
                 particle.destroy();
             }
@@ -27,9 +26,9 @@ function updateOpacity(particle, delta) {
         return;
     }
     switch (particle.opacity.status) {
-        case AnimationStatus.increasing:
+        case 0:
             if (particle.opacity.value >= maxValue) {
-                particle.opacity.status = AnimationStatus.decreasing;
+                particle.opacity.status = 1;
                 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:
             if (particle.opacity.value <= minValue) {
-                particle.opacity.status = AnimationStatus.increasing;
+                particle.opacity.status = 0;
                 if (!particle.opacity.loops) {
                     particle.opacity.loops = 0;
                 }
@@ -73,24 +72,24 @@ export class OpacityUpdater {
         };
         const opacityAnimation = opacityOptions.animation;
         if (opacityAnimation.enable) {
-            particle.opacity.status = AnimationStatus.increasing;
+            particle.opacity.status = 0;
             const opacityRange = opacityOptions.value;
             particle.opacity.min = getRangeMin(opacityRange);
             particle.opacity.max = getRangeMax(opacityRange);
             switch (opacityAnimation.startValue) {
-                case StartValueType.min:
+                case "min":
                     particle.opacity.value = particle.opacity.min;
-                    particle.opacity.status = AnimationStatus.increasing;
+                    particle.opacity.status = 0;
                     break;
-                case StartValueType.random:
+                case "random":
                     particle.opacity.value = randomInRange(particle.opacity);
                     particle.opacity.status =
-                        Math.random() >= 0.5 ? AnimationStatus.increasing : AnimationStatus.decreasing;
+                        Math.random() >= 0.5 ? 0 : 1;
                     break;
-                case StartValueType.max:
+                case "max":
                 default:
                     particle.opacity.value = particle.opacity.max;
-                    particle.opacity.status = AnimationStatus.decreasing;
+                    particle.opacity.status = 1;
                     break;
             }
             particle.opacity.velocity = (opacityAnimation.speed / 100) * this.container.retina.reduceFactor;

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

package/esm/Updaters/Opacity/index.js

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

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

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

package/esm/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);