tsparticles 1.35.4 → 1.37.2

package/browser/Enums/Types/ShapeType.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @category Enums
+ */
 export declare enum ShapeType {
     char = "char",
     character = "character",

package/browser/Enums/Types/ShapeType.js

@@ -1,3 +1,6 @@
+/**
+ * @category Enums
+ */
 export var ShapeType;
 (function (ShapeType) {
     ShapeType["char"] = "char";

package/browser/Enums/Types/StartValueType.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @category Enums
+ */
 export declare enum StartValueType {
     max = "max",
     min = "min",

package/browser/Enums/Types/StartValueType.js

@@ -1,3 +1,6 @@
+/**
+ * @category Enums
+ */
 export var StartValueType;
 (function (StartValueType) {
     StartValueType["max"] = "max";

package/browser/Interactions/External/Attract/Attractor.d.ts

@@ -1,5 +1,9 @@
 import type { Container } from "../../../Core/Container";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
+/**
+ * Particle attract manager
+ * @category Interactions
+ */
 export declare class Attractor extends ExternalInteractorBase {
     constructor(container: Container);
     isEnabled(): boolean;

package/browser/Interactions/External/Attract/Attractor.js

@@ -2,6 +2,10 @@ import { ClickMode, HoverMode } from "../../../Enums";
 import { Circle, Constants, getDistances, calcEasing, clamp, isInArray } from "../../../Utils";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
 import { Vector } from "../../../Core/Particle/Vector";
+/**
+ * Particle attract manager
+ * @category Interactions
+ */
 export class Attractor extends ExternalInteractorBase {
     constructor(container) {
         super(container);
@@ -15,6 +19,7 @@ export class Attractor extends ExternalInteractorBase {
         return isInArray(HoverMode.attract, hoverMode) || isInArray(ClickMode.attract, clickMode);
     }
     reset() {
+        // do nothing
     }
     interact() {
         const container = this.container, options = container.actualOptions, mouseMoveStatus = container.interactivity.status === Constants.mouseMoveEvent, events = options.interactivity.events, hoverEnabled = events.onHover.enable, hoverMode = events.onHover.mode, clickEnabled = events.onClick.enable, clickMode = events.onClick.mode;

package/browser/Interactions/External/Attract/index.d.ts

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

package/browser/Interactions/External/Attract/index.js

@@ -1,4 +1,4 @@
 import { Attractor } from "./Attractor";
-export function loadExternalAttractInteraction(tsParticles) {
-    tsParticles.addInteractor("externalAttract", (container) => new Attractor(container));
+export async function loadExternalAttractInteraction(tsParticles) {
+    await tsParticles.addInteractor("externalAttract", (container) => new Attractor(container));
 }

package/browser/Interactions/External/Bounce/Bouncer.js

@@ -21,6 +21,7 @@ export class Bouncer extends ExternalInteractorBase {
         }
     }
     reset() {
+        // do nothing
     }
     processMouseBounce() {
         const container = this.container, pxRatio = container.retina.pixelRatio, tolerance = 10 * pxRatio, mousePos = container.interactivity.mouse.position, radius = container.retina.bounceModeDistance;

package/browser/Interactions/External/Bounce/index.d.ts

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

package/browser/Interactions/External/Bounce/index.js

@@ -1,4 +1,4 @@
 import { Bouncer } from "./Bouncer";
-export function loadExternalBounceInteraction(tsParticles) {
-    tsParticles.addInteractor("externalBounce", (container) => new Bouncer(container));
+export async function loadExternalBounceInteraction(tsParticles) {
+    await tsParticles.addInteractor("externalBounce", (container) => new Bouncer(container));
 }

package/browser/Interactions/External/Bubble/Bubbler.d.ts

@@ -1,6 +1,10 @@
 import type { Container } from "../../../Core/Container";
 import { Particle } from "../../../Core/Particle";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
+/**
+ * Particle bubble manager
+ * @category Interactions
+ */
 export declare class Bubbler extends ExternalInteractorBase {
     constructor(container: Container);
     isEnabled(): boolean;

package/browser/Interactions/External/Bubble/Bubbler.js

@@ -12,6 +12,10 @@ function calculateBubbleValue(particleValue, modeValue, optionsValue, ratio) {
         return clamp(value, modeValue, particleValue);
     }
 }
+/**
+ * Particle bubble manager
+ * @category Interactions
+ */
 export class Bubbler extends ExternalInteractorBase {
     constructor(container) {
         super(container);
@@ -36,6 +40,7 @@ export class Bubbler extends ExternalInteractorBase {
     }
     interact() {
         const options = this.container.actualOptions, events = options.interactivity.events, onHover = events.onHover, onClick = events.onClick, hoverEnabled = onHover.enable, hoverMode = onHover.mode, clickEnabled = onClick.enable, clickMode = onClick.mode, divs = events.onDiv;
+        /* on hover event */
         if (hoverEnabled && isInArray(HoverMode.bubble, hoverMode)) {
             this.hoverBubble();
         }
@@ -69,8 +74,11 @@ export class Bubbler extends ExternalInteractorBase {
                     this.reset(particle, true);
                     particle.bubble.div = elem;
                 }
+                /* size */
                 this.hoverBubbleSize(particle, 1, divBubble);
+                /* opacity */
                 this.hoverBubbleOpacity(particle, 1, divBubble);
+                /* color */
                 this.hoverBubbleColor(particle, 1, divBubble);
             }
         });
@@ -178,19 +186,25 @@ export class Bubbler extends ExternalInteractorBase {
             return;
         }
         const distance = container.retina.bubbleModeDistance, query = container.particles.quadTree.queryCircle(mousePos, distance);
+        //for (const { distance, particle } of query) {
         for (const particle of query) {
             particle.bubble.inRange = true;
             const pos = particle.getPosition(), pointDistance = getDistance(pos, mousePos), ratio = 1 - pointDistance / distance;
+            /* mousemove - check ratio */
             if (pointDistance <= distance) {
                 if (ratio >= 0 && container.interactivity.status === Constants.mouseMoveEvent) {
+                    /* size */
                     this.hoverBubbleSize(particle, ratio);
+                    /* opacity */
                     this.hoverBubbleOpacity(particle, ratio);
+                    /* color */
                     this.hoverBubbleColor(particle, ratio);
                 }
             }
             else {
                 this.reset(particle);
             }
+            /* mouseleave */
             if (container.interactivity.status === Constants.mouseLeaveEvent) {
                 this.reset(particle);
             }

package/browser/Interactions/External/Bubble/IBubblerProcessParam.d.ts

@@ -1,9 +1,15 @@
 import type { ProcessBubbleType } from "./ProcessBubbleType";
+/**
+ * @category Interfaces
+ */
 export interface IBubblerProcessParam {
     bubbleObj: IBubblerProcessParamObj;
     particlesObj: IBubblerProcessParamObj;
     type: ProcessBubbleType;
 }
+/**
+ * @category Interfaces
+ */
 export interface IBubblerProcessParamObj {
     optValue?: number;
     value?: number;

package/browser/Interactions/External/Bubble/ProcessBubbleType.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @category Enums
+ */
 export declare enum ProcessBubbleType {
     color = "color",
     opacity = "opacity",

package/browser/Interactions/External/Bubble/ProcessBubbleType.js

@@ -1,3 +1,6 @@
+/**
+ * @category Enums
+ */
 export var ProcessBubbleType;
 (function (ProcessBubbleType) {
     ProcessBubbleType["color"] = "color";

package/browser/Interactions/External/Bubble/index.d.ts

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

package/browser/Interactions/External/Bubble/index.js

@@ -1,4 +1,4 @@
 import { Bubbler } from "./Bubbler";
-export function loadExternalBubbleInteraction(tsParticles) {
-    tsParticles.addInteractor("externalBubble", (container) => new Bubbler(container));
+export async function loadExternalBubbleInteraction(tsParticles) {
+    await tsParticles.addInteractor("externalBubble", (container) => new Bubbler(container));
 }

package/browser/Interactions/External/Connect/Connector.d.ts

@@ -1,8 +1,15 @@
 import type { Container } from "../../../Core/Container";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
+/**
+ * Particle connection manager
+ * @category Interactions
+ */
 export declare class Connector extends ExternalInteractorBase {
     constructor(container: Container);
     isEnabled(): boolean;
     reset(): void;
+    /**
+     * Connecting particles on hover interactivity
+     */
     interact(): void;
 }

package/browser/Interactions/External/Connect/Connector.js

@@ -1,6 +1,10 @@
 import { isInArray } from "../../../Utils";
 import { HoverMode } from "../../../Enums";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
+/**
+ * Particle connection manager
+ * @category Interactions
+ */
 export class Connector extends ExternalInteractorBase {
     constructor(container) {
         super(container);
@@ -13,7 +17,11 @@ export class Connector extends ExternalInteractorBase {
         return isInArray(HoverMode.connect, events.onHover.mode);
     }
     reset() {
+        // do nothing
     }
+    /**
+     * Connecting particles on hover interactivity
+     */
     interact() {
         const container = this.container, options = container.actualOptions;
         if (options.interactivity.events.onHover.enable && container.interactivity.status === "mousemove") {

package/browser/Interactions/External/Connect/index.d.ts

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

package/browser/Interactions/External/Connect/index.js

@@ -1,4 +1,4 @@
 import { Connector } from "./Connector";
-export function loadExternalConnectInteraction(tsParticles) {
-    tsParticles.addInteractor("externalConnect", (container) => new Connector(container));
+export async function loadExternalConnectInteraction(tsParticles) {
+    await tsParticles.addInteractor("externalConnect", (container) => new Connector(container));
 }

package/browser/Interactions/External/Grab/Grabber.d.ts

@@ -1,5 +1,9 @@
 import type { Container } from "../../../Core/Container";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
+/**
+ * Particle grab manager
+ * @category Interactions
+ */
 export declare class Grabber extends ExternalInteractorBase {
     constructor(container: Container);
     isEnabled(): boolean;

package/browser/Interactions/External/Grab/Grabber.js

@@ -1,6 +1,10 @@
 import { Constants, getLinkRandomColor, getLinkColor, getDistance, isInArray } from "../../../Utils";
 import { HoverMode } from "../../../Enums";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
+/**
+ * Particle grab manager
+ * @category Interactions
+ */
 export class Grabber extends ExternalInteractorBase {
     constructor(container) {
         super(container);
@@ -10,6 +14,7 @@ export class Grabber extends ExternalInteractorBase {
         return events.onHover.enable && !!mouse.position && isInArray(HoverMode.grab, events.onHover.mode);
     }
     reset() {
+        // do nothing
     }
     interact() {
         var _a;
@@ -21,6 +26,10 @@ export class Grabber extends ExternalInteractorBase {
             }
             const distance = container.retina.grabModeDistance, query = container.particles.quadTree.queryCircle(mousePos, distance);
             for (const particle of query) {
+                /*
+                   draw a line between the cursor and the particle
+                   if the distance between them is under the config distance
+                */
                 const pos = particle.getPosition(), pointDistance = getDistance(pos, mousePos);
                 if (pointDistance <= distance) {
                     const grabLineOptions = interactivity.modes.grab.links, lineOpacity = grabLineOptions.opacity, opacityLine = lineOpacity - (pointDistance * lineOpacity) / distance;

package/browser/Interactions/External/Grab/index.d.ts

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

package/browser/Interactions/External/Grab/index.js

@@ -1,4 +1,4 @@
 import { Grabber } from "./Grabber";
-export function loadExternalGrabInteraction(tsParticles) {
-    tsParticles.addInteractor("externalGrab", (container) => new Grabber(container));
+export async function loadExternalGrabInteraction(tsParticles) {
+    await tsParticles.addInteractor("externalGrab", (container) => new Grabber(container));
 }

package/browser/Interactions/External/Repulse/Repulser.d.ts

@@ -1,5 +1,9 @@
 import type { Container } from "../../../Core/Container";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
+/**
+ * Particle repulse manager
+ * @category Interactions
+ */
 export declare class Repulser extends ExternalInteractorBase {
     constructor(container: Container);
     isEnabled(): boolean;

package/browser/Interactions/External/Repulse/Repulser.js

@@ -2,6 +2,10 @@ import { ClickMode, DivMode, DivType, HoverMode } from "../../../Enums";
 import { calcEasing, Circle, clamp, Constants, divMode, divModeExecute, getDistances, isDivModeEnabled, isInArray, Rectangle, } from "../../../Utils";
 import { Vector } from "../../../Core/Particle/Vector";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
+/**
+ * Particle repulse manager
+ * @category Interactions
+ */
 export class Repulser extends ExternalInteractorBase {
     constructor(container) {
         super(container);
@@ -15,6 +19,7 @@ export class Repulser extends ExternalInteractorBase {
         return isInArray(HoverMode.repulse, hoverMode) || isInArray(ClickMode.repulse, clickMode) || divRepulse;
     }
     reset() {
+        // do nothing
     }
     interact() {
         const container = this.container, options = container.actualOptions, mouseMoveStatus = container.interactivity.status === Constants.mouseMoveEvent, events = options.interactivity.events, hoverEnabled = events.onHover.enable, hoverMode = events.onHover.mode, clickEnabled = events.onClick.enable, clickMode = events.onClick.mode, divs = events.onDiv;
@@ -94,3 +99,160 @@ export class Repulser extends ExternalInteractorBase {
         }
     }
 }
+/* Ready for a future release, breaking change. It's behavior seems more correct than the current.
+export class Repulser implements IExternalInteractor {
+    constructor(private readonly container: Container) {}
+
+    public isEnabled(): boolean {
+        const container = this.container;
+        const options = container.options;
+
+        const mouse = container.interactivity.mouse;
+        const events = options.interactivity.events;
+        const divs = events.onDiv;
+
+        const divRepulse = isDivModeEnabled(DivMode.repulse, divs);
+
+        if (
+            !(divRepulse || (events.onHover.enable && mouse.position) || (events.onClick.enable && mouse.clickPosition))
+        ) {
+            return false;
+        }
+
+        const hoverMode = events.onHover.mode;
+        const clickMode = events.onClick.mode;
+
+        return (
+            isInArray(HoverMode.repulse, hoverMode) || isInArray(ClickMode.repulse, clickMode) || divRepulse
+        );
+    }
+
+    public reset(): void {
+        // do nothing
+    }
+
+    public interact(): void {
+        const container = this.container;
+        const options = container.options;
+        const mouseMoveStatus = container.interactivity.status === Constants.mouseMoveEvent;
+        const events = options.interactivity.events;
+        const hoverEnabled = events.onHover.enable;
+        const hoverMode = events.onHover.mode;
+        const clickEnabled = events.onClick.enable;
+        const clickMode = events.onClick.mode;
+        const divs = events.onDiv;
+
+        if (mouseMoveStatus && hoverEnabled && isInArray(HoverMode.repulse, hoverMode)) {
+            this.hoverRepulse();
+        } else if (clickEnabled && isInArray(ClickMode.repulse, clickMode)) {
+            this.clickRepulse();
+        } else {
+            divModeExecute(DivMode.repulse, divs, (selector, div): void => this.singleDivRepulse(selector, div));
+        }
+    }
+
+    private singleDivRepulse(selector: string, div: DivEvent): void {
+        const container = this.container;
+        const query = document.querySelectorAll(selector);
+
+        if (!query.length) {
+            return;
+        }
+
+        query.forEach(item => {
+                const elem = item as HTMLElement;
+            const pxRatio = container.retina.pixelRatio;
+            const pos = {
+                x: (elem.offsetLeft + elem.offsetWidth / 2) * pxRatio,
+                y: (elem.offsetTop + elem.offsetHeight / 2) * pxRatio,
+            };
+            const repulseRadius = (elem.offsetWidth / 2) * pxRatio;
+
+            const area =
+                div.type === DivType.circle
+                    ? new Circle(pos.x, pos.y, repulseRadius)
+                    : new Rectangle(
+                    elem.offsetLeft * pxRatio,
+                    elem.offsetTop * pxRatio,
+                    elem.offsetWidth * pxRatio,
+                    elem.offsetHeight * pxRatio
+                    );
+
+            const divs = container.options.interactivity.modes.repulse.divs;
+            const divRepulse = divMode(divs, selector);
+            const velocity = (divRepulse?.speed ?? container.options.interactivity.modes.repulse.speed) * 100;
+
+            this.processRepulse(pos, repulseRadius, velocity, area, divRepulse);
+        });
+    }
+
+    private hoverRepulse(): void {
+        const container = this.container;
+        const mousePos = container.interactivity.mouse.position;
+
+        if (!mousePos) {
+            return;
+        }
+
+        const repulseRadius = container.retina.repulseModeDistance;
+        const velocity = container.options.interactivity.modes.repulse.speed * 100;
+
+        this.processRepulse(mousePos, repulseRadius, velocity, new Circle(mousePos.x, mousePos.y, repulseRadius));
+    }
+
+    private clickRepulse(): void {
+        const container = this.container;
+
+        if (!container.repulse.finish) {
+            if (!container.repulse.count) {
+                container.repulse.count = 0;
+            }
+
+            container.repulse.count++;
+
+            if (container.repulse.count === container.particles.count) {
+                container.repulse.finish = true;
+            }
+        }
+
+        if (container.repulse.clicking) {
+            const mousePos = container.interactivity.mouse.clickPosition;
+
+            if (!mousePos) {
+                return;
+            }
+
+            const repulseRadius = container.retina.repulseModeDistance;
+            const velocity = container.options.interactivity.modes.repulse.speed * 10;
+
+            this.processRepulse(mousePos, repulseRadius, velocity, new Circle(mousePos.x, mousePos.y, repulseRadius));
+        } else if (container.repulse.clicking === false) {
+            container.repulse.particles = [];
+        }
+    }
+
+    private processRepulse(
+        position: ICoordinates,
+        repulseRadius: number,
+        velocity: number,
+        area: Range,
+        divRepulse?: RepulseDiv
+    ): void {
+        const container = this.container;
+        const query = container.particles.quadTree.query(area);
+
+        for (const particle of query) {
+            const { dx, dy, distance } = getDistances(particle.position, position);
+            const normVec = {
+                x: dx / distance,
+                y: dy / distance,
+            };
+
+            const repulseFactor = clamp((1 - Math.pow(distance / repulseRadius, 2)) * velocity, 0, 50);
+
+            particle.position.x += normVec.x * repulseFactor;
+            particle.position.y += normVec.y * repulseFactor;
+        }
+    }
+}
+ */

package/browser/Interactions/External/Repulse/index.d.ts

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

package/browser/Interactions/External/Repulse/index.js

@@ -1,4 +1,4 @@
 import { Repulser } from "./Repulser";
-export function loadExternalRepulseInteraction(tsParticles) {
-    tsParticles.addInteractor("externalRepulse", (container) => new Repulser(container));
+export async function loadExternalRepulseInteraction(tsParticles) {
+    await tsParticles.addInteractor("externalRepulse", (container) => new Repulser(container));
 }

package/browser/Interactions/External/Trail/TrailMaker.d.ts

@@ -1,6 +1,9 @@
 import type { Container } from "../../../Core/Container";
 import type { IDelta } from "../../../Core/Interfaces";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
+/**
+ * @category Interactions
+ */
 export declare class TrailMaker extends ExternalInteractorBase {
     private delay;
     private lastPosition?;

package/browser/Interactions/External/Trail/TrailMaker.js

@@ -1,6 +1,9 @@
 import { isInArray } from "../../../Utils";
 import { ClickMode, HoverMode } from "../../../Enums";
 import { ExternalInteractorBase } from "../../../Core/ExternalInteractorBase";
+/**
+ * @category Interactions
+ */
 export class TrailMaker extends ExternalInteractorBase {
     constructor(container) {
         super(container);
@@ -46,5 +49,6 @@ export class TrailMaker extends ExternalInteractorBase {
             (mouse.inside && !!mouse.position && isInArray(HoverMode.trail, events.onHover.mode)));
     }
     reset() {
+        // nothing to do
     }
 }

package/browser/Interactions/External/Trail/index.d.ts

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

package/browser/Interactions/External/Trail/index.js

@@ -1,4 +1,4 @@
 import { TrailMaker } from "./TrailMaker";
-export function loadExternalTrailInteraction(tsParticles) {
-    tsParticles.addInteractor("externalTrail", (container) => new TrailMaker(container));
+export async function loadExternalTrailInteraction(tsParticles) {
+    await tsParticles.addInteractor("externalTrail", (container) => new TrailMaker(container));
 }

package/browser/Interactions/Particles/Attract/Attractor.d.ts

@@ -2,6 +2,9 @@ import type { IParticle } from "../../../Core/Interfaces";
 import type { Container } from "../../../Core/Container";
 import { Particle } from "../../../Core/Particle";
 import { ParticlesInteractorBase } from "../../../Core/ParticlesInteractorBase";
+/**
+ * @category Interactions
+ */
 export declare class Attractor extends ParticlesInteractorBase {
     constructor(container: Container);
     interact(p1: IParticle): void;

package/browser/Interactions/Particles/Attract/Attractor.js

@@ -1,5 +1,8 @@
 import { getDistances } from "../../../Utils";
 import { ParticlesInteractorBase } from "../../../Core/ParticlesInteractorBase";
+/**
+ * @category Interactions
+ */
 export class Attractor extends ParticlesInteractorBase {
     constructor(container) {
         super(container);
@@ -22,5 +25,6 @@ export class Attractor extends ParticlesInteractorBase {
         return particle.options.move.attract.enable;
     }
     reset() {
+        // do nothing
     }
 }

package/browser/Interactions/Particles/Attract/index.d.ts

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

package/browser/Interactions/Particles/Attract/index.js

@@ -1,4 +1,4 @@
 import { Attractor } from "./Attractor";
-export function loadParticlesAttractInteraction(tsParticles) {
-    tsParticles.addInteractor("particlesAttract", (container) => new Attractor(container));
+export async function loadParticlesAttractInteraction(tsParticles) {
+    await tsParticles.addInteractor("particlesAttract", (container) => new Attractor(container));
 }

package/browser/Interactions/Particles/Collisions/Collider.d.ts

@@ -1,6 +1,9 @@
 import type { Particle } from "../../../Core/Particle";
 import type { Container } from "../../../Core/Container";
 import { ParticlesInteractorBase } from "../../../Core/ParticlesInteractorBase";
+/**
+ * @category Interactions
+ */
 export declare class Collider extends ParticlesInteractorBase {
     constructor(container: Container);
     isEnabled(particle: Particle): boolean;

package/browser/Interactions/Particles/Collisions/Collider.js

@@ -23,6 +23,9 @@ function destroy(p1, p2) {
         }
     }
 }
+/**
+ * @category Interactions
+ */
 export class Collider extends ParticlesInteractorBase {
     constructor(container) {
         super(container);
@@ -31,6 +34,7 @@ export class Collider extends ParticlesInteractorBase {
         return particle.options.collisions.enable;
     }
     reset() {
+        // do nothing
     }
     interact(p1) {
         const container = this.container;

package/browser/Interactions/Particles/Collisions/index.d.ts

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