@tsparticles/plugin-absorbers 3.0.0-alpha.1 → 3.0.0-beta.1

package/README.md

@@ -2,9 +2,9 @@
 
 # tsParticles Absorbers Plugin
 
-[![jsDelivr](https://data.jsdelivr.com/v1/package/npm/tsparticles-plugin-absorbers/badge)](https://www.jsdelivr.com/package/npm/tsparticles-plugin-absorbers)
-[![npmjs](https://badge.fury.io/js/tsparticles-plugin-absorbers.svg)](https://www.npmjs.com/package/tsparticles-plugin-absorbers)
-[![npmjs](https://img.shields.io/npm/dt/tsparticles-plugin-absorbers)](https://www.npmjs.com/package/tsparticles-plugin-absorbers) [![GitHub Sponsors](https://img.shields.io/github/sponsors/matteobruni)](https://github.com/sponsors/matteobruni)
+[![jsDelivr](https://data.jsdelivr.com/v1/package/npm/@tsparticles/plugin-absorbers/badge)](https://www.jsdelivr.com/package/npm/@tsparticles/plugin-absorbers)
+[![npmjs](https://badge.fury.io/js/@tsparticles/plugin-absorbers.svg)](https://www.npmjs.com/package/@tsparticles/plugin-absorbers)
+[![npmjs](https://img.shields.io/npm/dt/@tsparticles/plugin-absorbers)](https://www.npmjs.com/package/@tsparticles/plugin-absorbers) [![GitHub Sponsors](https://img.shields.io/github/sponsors/matteobruni)](https://github.com/sponsors/matteobruni)
 
 [tsParticles](https://github.com/matteobruni/tsparticles) plugin for particles absorbers.
 
@@ -42,29 +42,33 @@ Once the scripts are loaded you can set up `tsParticles` and the plugin like thi
 This package is compatible also with ES or CommonJS modules, firstly this needs to be installed, like this:
 
 ```shell
-$ npm install tsparticles-plugin-absorbers
+$ npm install @tsparticles/plugin-absorbers
 ```
 
 or
 
 ```shell
-$ yarn add tsparticles-plugin-absorbers
+$ yarn add @tsparticles/plugin-absorbers
 ```
 
 Then you need to import it in the app, like this:
 
 ```javascript
-const { tsParticles } = require("tsparticles-engine");
-const { loadAbsorbersPlugin } = require("tsparticles-plugin-absorbers");
+const { tsParticles } = require("@tsparticles/engine");
+const { loadAbsorbersPlugin } = require("@tsparticles/plugin-absorbers");
 
-loadAbsorbersPlugin(tsParticles);
+(async () => {
+  await loadAbsorbersPlugin(tsParticles);
+})();
 ```
 
 or
 
 ```javascript
-import { tsParticles } from "tsparticles-engine";
-import { loadAbsorbersPlugin } from "tsparticles-plugin-absorbers";
+import { tsParticles } from "@tsparticles/engine";
+import { loadAbsorbersPlugin } from "@tsparticles/plugin-absorbers";
 
-loadAbsorbersPlugin(tsParticles);
+(async () => {
+  await loadAbsorbersPlugin(tsParticles);
+})();
 ```

package/browser/AbsorberInstance.js

@@ -1,10 +1,62 @@
 import { Vector, calcPositionOrRandomFromSize, calcPositionOrRandomFromSizeRanged, getDistance, getDistances, getRandom, getRangeValue, getStyleFromRgb, isPointInside, rangeColorToRgb, } from "@tsparticles/engine";
-import { Absorber } from "./Options/Classes/Absorber";
+import { Absorber } from "./Options/Classes/Absorber.js";
 export class AbsorberInstance {
     constructor(absorbers, container, options, position) {
-        var _a, _b, _c;
         this.absorbers = absorbers;
         this.container = container;
+        this._calcPosition = () => {
+            const exactPosition = calcPositionOrRandomFromSizeRanged({
+                size: this.container.canvas.size,
+                position: this.options.position,
+            });
+            return Vector.create(exactPosition.x, exactPosition.y);
+        };
+        this._updateParticlePosition = (particle, v) => {
+            if (particle.destroyed) {
+                return;
+            }
+            const container = this.container, canvasSize = container.canvas.size;
+            if (particle.needsNewPosition) {
+                const newPosition = calcPositionOrRandomFromSize({ size: canvasSize });
+                particle.position.setTo(newPosition);
+                particle.velocity.setTo(particle.initialVelocity);
+                particle.absorberOrbit = undefined;
+                particle.needsNewPosition = false;
+            }
+            if (this.options.orbits) {
+                if (particle.absorberOrbit === undefined) {
+                    particle.absorberOrbit = Vector.create(0, 0);
+                    particle.absorberOrbit.length = getDistance(particle.getPosition(), this.position);
+                    particle.absorberOrbit.angle = getRandom() * Math.PI * 2;
+                }
+                if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
+                    const minSize = Math.min(canvasSize.width, canvasSize.height);
+                    particle.absorberOrbit.length = minSize * (1 + (getRandom() * 0.2 - 0.1));
+                }
+                if (particle.absorberOrbitDirection === undefined) {
+                    particle.absorberOrbitDirection =
+                        particle.velocity.x >= 0 ? "clockwise" : "counter-clockwise";
+                }
+                const orbitRadius = particle.absorberOrbit.length, orbitAngle = particle.absorberOrbit.angle, orbitDirection = particle.absorberOrbitDirection;
+                particle.velocity.setTo(Vector.origin);
+                const updateFunc = {
+                    x: orbitDirection === "clockwise" ? Math.cos : Math.sin,
+                    y: orbitDirection === "clockwise" ? Math.sin : Math.cos,
+                };
+                particle.position.x = this.position.x + orbitRadius * updateFunc.x(orbitAngle);
+                particle.position.y = this.position.y + orbitRadius * updateFunc.y(orbitAngle);
+                particle.absorberOrbit.length -= v.length;
+                particle.absorberOrbit.angle +=
+                    (((particle.retina.moveSpeed ?? 0) * container.retina.pixelRatio) / 100) *
+                        container.retina.reduceFactor;
+            }
+            else {
+                const addV = Vector.origin;
+                addV.length = v.length;
+                addV.angle = v.angle;
+                particle.velocity.addTo(addV);
+            }
+        };
         this.initialPosition = position ? Vector.create(position.x, position.y) : undefined;
         if (options instanceof Absorber) {
             this.options = options;
@@ -23,12 +75,12 @@ export class AbsorberInstance {
             radius: limit.radius * container.retina.pixelRatio * container.retina.reduceFactor,
             mass: limit.mass,
         };
-        this.color = (_a = rangeColorToRgb(this.options.color)) !== null && _a !== void 0 ? _a : {
+        this.color = rangeColorToRgb(this.options.color) ?? {
             b: 0,
             g: 0,
             r: 0,
         };
-        this.position = (_c = (_b = this.initialPosition) === null || _b === void 0 ? void 0 : _b.copy()) !== null && _c !== void 0 ? _c : this.calcPosition();
+        this.position = this.initialPosition?.copy() ?? this._calcPosition();
     }
     attract(particle) {
         const container = this.container, options = this.options;
@@ -59,14 +111,14 @@ export class AbsorberInstance {
                 }
                 else {
                     particle.needsNewPosition = true;
-                    this.updateParticlePosition(particle, v);
+                    this._updateParticlePosition(particle, v);
                 }
             }
             else {
                 if (options.destroy) {
                     particle.size.value -= sizeFactor;
                 }
-                this.updateParticlePosition(particle, v);
+                this._updateParticlePosition(particle, v);
             }
             if (this.limit.radius <= 0 || this.size < this.limit.radius) {
                 this.size += sizeFactor;
@@ -76,7 +128,7 @@ export class AbsorberInstance {
             }
         }
         else {
-            this.updateParticlePosition(particle, v);
+            this._updateParticlePosition(particle, v);
         }
     }
     draw(context) {
@@ -92,60 +144,6 @@ export class AbsorberInstance {
         this.position =
             initialPosition && isPointInside(initialPosition, this.container.canvas.size, Vector.origin)
                 ? initialPosition
-                : this.calcPosition();
-    }
-    calcPosition() {
-        const exactPosition = calcPositionOrRandomFromSizeRanged({
-            size: this.container.canvas.size,
-            position: this.options.position,
-        });
-        return Vector.create(exactPosition.x, exactPosition.y);
-    }
-    updateParticlePosition(particle, v) {
-        var _a;
-        if (particle.destroyed) {
-            return;
-        }
-        const container = this.container, canvasSize = container.canvas.size;
-        if (particle.needsNewPosition) {
-            const newPosition = calcPositionOrRandomFromSize({ size: canvasSize });
-            particle.position.setTo(newPosition);
-            particle.velocity.setTo(particle.initialVelocity);
-            particle.absorberOrbit = undefined;
-            particle.needsNewPosition = false;
-        }
-        if (this.options.orbits) {
-            if (particle.absorberOrbit === undefined) {
-                particle.absorberOrbit = Vector.create(0, 0);
-                particle.absorberOrbit.length = getDistance(particle.getPosition(), this.position);
-                particle.absorberOrbit.angle = getRandom() * Math.PI * 2;
-            }
-            if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
-                const minSize = Math.min(canvasSize.width, canvasSize.height);
-                particle.absorberOrbit.length = minSize * (1 + (getRandom() * 0.2 - 0.1));
-            }
-            if (particle.absorberOrbitDirection === undefined) {
-                particle.absorberOrbitDirection =
-                    particle.velocity.x >= 0 ? "clockwise" : "counter-clockwise";
-            }
-            const orbitRadius = particle.absorberOrbit.length, orbitAngle = particle.absorberOrbit.angle, orbitDirection = particle.absorberOrbitDirection;
-            particle.velocity.setTo(Vector.origin);
-            const updateFunc = {
-                x: orbitDirection === "clockwise" ? Math.cos : Math.sin,
-                y: orbitDirection === "clockwise" ? Math.sin : Math.cos,
-            };
-            particle.position.x = this.position.x + orbitRadius * updateFunc.x(orbitAngle);
-            particle.position.y = this.position.y + orbitRadius * updateFunc.y(orbitAngle);
-            particle.absorberOrbit.length -= v.length;
-            particle.absorberOrbit.angle +=
-                ((((_a = particle.retina.moveSpeed) !== null && _a !== void 0 ? _a : 0) * container.retina.pixelRatio) / 100) *
-                    container.retina.reduceFactor;
-        }
-        else {
-            const addV = Vector.origin;
-            addV.length = v.length;
-            addV.angle = v.angle;
-            particle.velocity.addTo(addV);
-        }
+                : this._calcPosition();
     }
 }

package/browser/Absorbers.js

@@ -1,12 +1,12 @@
-import { executeOnSingleOrMultiple, itemFromSingleOrMultiple } from "@tsparticles/engine";
-import { AbsorberInstance } from "./AbsorberInstance";
+import { executeOnSingleOrMultiple, isNumber, itemFromSingleOrMultiple, } from "@tsparticles/engine";
+import { AbsorberInstance } from "./AbsorberInstance.js";
 export class Absorbers {
     constructor(container) {
         this.container = container;
         this.array = [];
         this.absorbers = [];
         this.interactivityAbsorbers = [];
-        container.getAbsorber = (idxOrName) => idxOrName === undefined || typeof idxOrName === "number"
+        container.getAbsorber = (idxOrName) => idxOrName === undefined || isNumber(idxOrName)
             ? this.array[idxOrName || 0]
             : this.array.find((t) => t.name === idxOrName);
         container.addAbsorber = (options, position) => this.addAbsorber(options, position);
@@ -24,7 +24,7 @@ export class Absorbers {
     handleClickMode(mode) {
         const absorberOptions = this.absorbers, modeAbsorbers = this.interactivityAbsorbers;
         if (mode === "absorber") {
-            const absorbersModeOptions = itemFromSingleOrMultiple(modeAbsorbers), absorbersOptions = absorbersModeOptions !== null && absorbersModeOptions !== void 0 ? absorbersModeOptions : itemFromSingleOrMultiple(absorberOptions), aPosition = this.container.interactivity.mouse.clickPosition;
+            const absorbersModeOptions = itemFromSingleOrMultiple(modeAbsorbers), absorbersOptions = absorbersModeOptions ?? itemFromSingleOrMultiple(absorberOptions), aPosition = this.container.interactivity.mouse.clickPosition;
             this.addAbsorber(absorbersOptions, aPosition);
         }
     }

package/browser/Options/Classes/Absorber.js

@@ -1,5 +1,5 @@
-import { OptionsColor, setRangeValue } from "@tsparticles/engine";
-import { AbsorberSize } from "./AbsorberSize";
+import { OptionsColor, setRangeValue, } from "@tsparticles/engine";
+import { AbsorberSize } from "./AbsorberSize.js";
 export class Absorber {
     constructor() {
         this.color = new OptionsColor();

package/browser/Options/Classes/AbsorberSize.js

@@ -1,5 +1,5 @@
-import { AbsorberSizeLimit } from "./AbsorberSizeLimit";
-import { ValueWithRandom } from "@tsparticles/engine";
+import { ValueWithRandom, isNumber } from "@tsparticles/engine";
+import { AbsorberSizeLimit } from "./AbsorberSizeLimit.js";
 export class AbsorberSize extends ValueWithRandom {
     constructor() {
         super();
@@ -15,7 +15,7 @@ export class AbsorberSize extends ValueWithRandom {
         if (data.density !== undefined) {
             this.density = data.density;
         }
-        if (typeof data.limit === "number") {
+        if (isNumber(data.limit)) {
             this.limit.radius = data.limit;
         }
         else {

package/browser/index.js

@@ -1,6 +1,6 @@
-import { executeOnSingleOrMultiple, isInArray } from "@tsparticles/engine";
-import { Absorber } from "./Options/Classes/Absorber";
-import { Absorbers } from "./Absorbers";
+import { executeOnSingleOrMultiple, isArray, isInArray, } from "@tsparticles/engine";
+import { Absorber } from "./Options/Classes/Absorber.js";
+import { Absorbers } from "./Absorbers.js";
 class AbsorbersPlugin {
     constructor() {
         this.id = "absorbers";
@@ -9,45 +9,42 @@ class AbsorbersPlugin {
         return new Absorbers(container);
     }
     loadOptions(options, source) {
-        var _a, _b;
         if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
             return;
         }
-        if (source === null || source === void 0 ? void 0 : source.absorbers) {
+        if (source?.absorbers) {
             options.absorbers = executeOnSingleOrMultiple(source.absorbers, (absorber) => {
                 const tmp = new Absorber();
                 tmp.load(absorber);
                 return tmp;
             });
         }
-        options.interactivity.modes.absorbers = executeOnSingleOrMultiple((_b = (_a = source === null || source === void 0 ? void 0 : source.interactivity) === null || _a === void 0 ? void 0 : _a.modes) === null || _b === void 0 ? void 0 : _b.absorbers, (absorber) => {
+        options.interactivity.modes.absorbers = executeOnSingleOrMultiple(source?.interactivity?.modes?.absorbers, (absorber) => {
             const tmp = new Absorber();
             tmp.load(absorber);
             return tmp;
         });
     }
     needsPlugin(options) {
-        var _a, _b, _c;
         if (!options) {
             return false;
         }
         const absorbers = options.absorbers;
-        if (absorbers instanceof Array) {
+        if (isArray(absorbers)) {
             return !!absorbers.length;
         }
         else if (absorbers) {
             return true;
         }
-        else if (((_c = (_b = (_a = options.interactivity) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.onClick) === null || _c === void 0 ? void 0 : _c.mode) &&
+        else if (options.interactivity?.events?.onClick?.mode &&
             isInArray("absorber", options.interactivity.events.onClick.mode)) {
             return true;
         }
         return false;
     }
 }
-export async function loadAbsorbersPlugin(engine) {
-    const plugin = new AbsorbersPlugin();
-    await engine.addPlugin(plugin);
+export async function loadAbsorbersPlugin(engine, refresh = true) {
+    await engine.addPlugin(new AbsorbersPlugin(), refresh);
 }
-export * from "./AbsorberContainer";
-export * from "./Enums/AbsorberClickMode";
+export * from "./AbsorberContainer.js";
+export * from "./Enums/AbsorberClickMode.js";

package/browser/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/cjs/AbsorberInstance.js

@@ -2,18 +2,70 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbsorberInstance = void 0;
 const engine_1 = require("@tsparticles/engine");
-const Absorber_1 = require("./Options/Classes/Absorber");
+const Absorber_js_1 = require("./Options/Classes/Absorber.js");
 class AbsorberInstance {
     constructor(absorbers, container, options, position) {
-        var _a, _b, _c;
         this.absorbers = absorbers;
         this.container = container;
+        this._calcPosition = () => {
+            const exactPosition = (0, engine_1.calcPositionOrRandomFromSizeRanged)({
+                size: this.container.canvas.size,
+                position: this.options.position,
+            });
+            return engine_1.Vector.create(exactPosition.x, exactPosition.y);
+        };
+        this._updateParticlePosition = (particle, v) => {
+            if (particle.destroyed) {
+                return;
+            }
+            const container = this.container, canvasSize = container.canvas.size;
+            if (particle.needsNewPosition) {
+                const newPosition = (0, engine_1.calcPositionOrRandomFromSize)({ size: canvasSize });
+                particle.position.setTo(newPosition);
+                particle.velocity.setTo(particle.initialVelocity);
+                particle.absorberOrbit = undefined;
+                particle.needsNewPosition = false;
+            }
+            if (this.options.orbits) {
+                if (particle.absorberOrbit === undefined) {
+                    particle.absorberOrbit = engine_1.Vector.create(0, 0);
+                    particle.absorberOrbit.length = (0, engine_1.getDistance)(particle.getPosition(), this.position);
+                    particle.absorberOrbit.angle = (0, engine_1.getRandom)() * Math.PI * 2;
+                }
+                if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
+                    const minSize = Math.min(canvasSize.width, canvasSize.height);
+                    particle.absorberOrbit.length = minSize * (1 + ((0, engine_1.getRandom)() * 0.2 - 0.1));
+                }
+                if (particle.absorberOrbitDirection === undefined) {
+                    particle.absorberOrbitDirection =
+                        particle.velocity.x >= 0 ? "clockwise" : "counter-clockwise";
+                }
+                const orbitRadius = particle.absorberOrbit.length, orbitAngle = particle.absorberOrbit.angle, orbitDirection = particle.absorberOrbitDirection;
+                particle.velocity.setTo(engine_1.Vector.origin);
+                const updateFunc = {
+                    x: orbitDirection === "clockwise" ? Math.cos : Math.sin,
+                    y: orbitDirection === "clockwise" ? Math.sin : Math.cos,
+                };
+                particle.position.x = this.position.x + orbitRadius * updateFunc.x(orbitAngle);
+                particle.position.y = this.position.y + orbitRadius * updateFunc.y(orbitAngle);
+                particle.absorberOrbit.length -= v.length;
+                particle.absorberOrbit.angle +=
+                    (((particle.retina.moveSpeed ?? 0) * container.retina.pixelRatio) / 100) *
+                        container.retina.reduceFactor;
+            }
+            else {
+                const addV = engine_1.Vector.origin;
+                addV.length = v.length;
+                addV.angle = v.angle;
+                particle.velocity.addTo(addV);
+            }
+        };
         this.initialPosition = position ? engine_1.Vector.create(position.x, position.y) : undefined;
-        if (options instanceof Absorber_1.Absorber) {
+        if (options instanceof Absorber_js_1.Absorber) {
             this.options = options;
         }
         else {
-            this.options = new Absorber_1.Absorber();
+            this.options = new Absorber_js_1.Absorber();
             this.options.load(options);
         }
         this.dragging = false;
@@ -26,12 +78,12 @@ class AbsorberInstance {
             radius: limit.radius * container.retina.pixelRatio * container.retina.reduceFactor,
             mass: limit.mass,
         };
-        this.color = (_a = (0, engine_1.rangeColorToRgb)(this.options.color)) !== null && _a !== void 0 ? _a : {
+        this.color = (0, engine_1.rangeColorToRgb)(this.options.color) ?? {
             b: 0,
             g: 0,
             r: 0,
         };
-        this.position = (_c = (_b = this.initialPosition) === null || _b === void 0 ? void 0 : _b.copy()) !== null && _c !== void 0 ? _c : this.calcPosition();
+        this.position = this.initialPosition?.copy() ?? this._calcPosition();
     }
     attract(particle) {
         const container = this.container, options = this.options;
@@ -62,14 +114,14 @@ class AbsorberInstance {
                 }
                 else {
                     particle.needsNewPosition = true;
-                    this.updateParticlePosition(particle, v);
+                    this._updateParticlePosition(particle, v);
                 }
             }
             else {
                 if (options.destroy) {
                     particle.size.value -= sizeFactor;
                 }
-                this.updateParticlePosition(particle, v);
+                this._updateParticlePosition(particle, v);
             }
             if (this.limit.radius <= 0 || this.size < this.limit.radius) {
                 this.size += sizeFactor;
@@ -79,7 +131,7 @@ class AbsorberInstance {
             }
         }
         else {
-            this.updateParticlePosition(particle, v);
+            this._updateParticlePosition(particle, v);
         }
     }
     draw(context) {
@@ -95,61 +147,7 @@ class AbsorberInstance {
         this.position =
             initialPosition && (0, engine_1.isPointInside)(initialPosition, this.container.canvas.size, engine_1.Vector.origin)
                 ? initialPosition
-                : this.calcPosition();
-    }
-    calcPosition() {
-        const exactPosition = (0, engine_1.calcPositionOrRandomFromSizeRanged)({
-            size: this.container.canvas.size,
-            position: this.options.position,
-        });
-        return engine_1.Vector.create(exactPosition.x, exactPosition.y);
-    }
-    updateParticlePosition(particle, v) {
-        var _a;
-        if (particle.destroyed) {
-            return;
-        }
-        const container = this.container, canvasSize = container.canvas.size;
-        if (particle.needsNewPosition) {
-            const newPosition = (0, engine_1.calcPositionOrRandomFromSize)({ size: canvasSize });
-            particle.position.setTo(newPosition);
-            particle.velocity.setTo(particle.initialVelocity);
-            particle.absorberOrbit = undefined;
-            particle.needsNewPosition = false;
-        }
-        if (this.options.orbits) {
-            if (particle.absorberOrbit === undefined) {
-                particle.absorberOrbit = engine_1.Vector.create(0, 0);
-                particle.absorberOrbit.length = (0, engine_1.getDistance)(particle.getPosition(), this.position);
-                particle.absorberOrbit.angle = (0, engine_1.getRandom)() * Math.PI * 2;
-            }
-            if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
-                const minSize = Math.min(canvasSize.width, canvasSize.height);
-                particle.absorberOrbit.length = minSize * (1 + ((0, engine_1.getRandom)() * 0.2 - 0.1));
-            }
-            if (particle.absorberOrbitDirection === undefined) {
-                particle.absorberOrbitDirection =
-                    particle.velocity.x >= 0 ? "clockwise" : "counter-clockwise";
-            }
-            const orbitRadius = particle.absorberOrbit.length, orbitAngle = particle.absorberOrbit.angle, orbitDirection = particle.absorberOrbitDirection;
-            particle.velocity.setTo(engine_1.Vector.origin);
-            const updateFunc = {
-                x: orbitDirection === "clockwise" ? Math.cos : Math.sin,
-                y: orbitDirection === "clockwise" ? Math.sin : Math.cos,
-            };
-            particle.position.x = this.position.x + orbitRadius * updateFunc.x(orbitAngle);
-            particle.position.y = this.position.y + orbitRadius * updateFunc.y(orbitAngle);
-            particle.absorberOrbit.length -= v.length;
-            particle.absorberOrbit.angle +=
-                ((((_a = particle.retina.moveSpeed) !== null && _a !== void 0 ? _a : 0) * container.retina.pixelRatio) / 100) *
-                    container.retina.reduceFactor;
-        }
-        else {
-            const addV = engine_1.Vector.origin;
-            addV.length = v.length;
-            addV.angle = v.angle;
-            particle.velocity.addTo(addV);
-        }
+                : this._calcPosition();
     }
 }
 exports.AbsorberInstance = AbsorberInstance;

package/cjs/Absorbers.js

@@ -1,30 +1,21 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Absorbers = void 0;
 const engine_1 = require("@tsparticles/engine");
-const AbsorberInstance_1 = require("./AbsorberInstance");
+const AbsorberInstance_js_1 = require("./AbsorberInstance.js");
 class Absorbers {
     constructor(container) {
         this.container = container;
         this.array = [];
         this.absorbers = [];
         this.interactivityAbsorbers = [];
-        container.getAbsorber = (idxOrName) => idxOrName === undefined || typeof idxOrName === "number"
+        container.getAbsorber = (idxOrName) => idxOrName === undefined || (0, engine_1.isNumber)(idxOrName)
             ? this.array[idxOrName || 0]
             : this.array.find((t) => t.name === idxOrName);
         container.addAbsorber = (options, position) => this.addAbsorber(options, position);
     }
     addAbsorber(options, position) {
-        const absorber = new AbsorberInstance_1.AbsorberInstance(this, this.container, options, position);
+        const absorber = new AbsorberInstance_js_1.AbsorberInstance(this, this.container, options, position);
         this.array.push(absorber);
         return absorber;
     }
@@ -36,17 +27,15 @@ class Absorbers {
     handleClickMode(mode) {
         const absorberOptions = this.absorbers, modeAbsorbers = this.interactivityAbsorbers;
         if (mode === "absorber") {
-            const absorbersModeOptions = (0, engine_1.itemFromSingleOrMultiple)(modeAbsorbers), absorbersOptions = absorbersModeOptions !== null && absorbersModeOptions !== void 0 ? absorbersModeOptions : (0, engine_1.itemFromSingleOrMultiple)(absorberOptions), aPosition = this.container.interactivity.mouse.clickPosition;
+            const absorbersModeOptions = (0, engine_1.itemFromSingleOrMultiple)(modeAbsorbers), absorbersOptions = absorbersModeOptions ?? (0, engine_1.itemFromSingleOrMultiple)(absorberOptions), aPosition = this.container.interactivity.mouse.clickPosition;
             this.addAbsorber(absorbersOptions, aPosition);
         }
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.absorbers = this.container.actualOptions.absorbers;
-            this.interactivityAbsorbers = this.container.actualOptions.interactivity.modes.absorbers;
-            (0, engine_1.executeOnSingleOrMultiple)(this.absorbers, (absorber) => {
-                this.addAbsorber(absorber);
-            });
+    async init() {
+        this.absorbers = this.container.actualOptions.absorbers;
+        this.interactivityAbsorbers = this.container.actualOptions.interactivity.modes.absorbers;
+        (0, engine_1.executeOnSingleOrMultiple)(this.absorbers, (absorber) => {
+            this.addAbsorber(absorber);
         });
     }
     particleUpdate(particle) {

package/cjs/Options/Classes/Absorber.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Absorber = void 0;
 const engine_1 = require("@tsparticles/engine");
-const AbsorberSize_1 = require("./AbsorberSize");
+const AbsorberSize_js_1 = require("./AbsorberSize.js");
 class Absorber {
     constructor() {
         this.color = new engine_1.OptionsColor();
@@ -11,7 +11,7 @@ class Absorber {
         this.opacity = 1;
         this.destroy = true;
         this.orbits = false;
-        this.size = new AbsorberSize_1.AbsorberSize();
+        this.size = new AbsorberSize_js_1.AbsorberSize();
     }
     load(data) {
         if (data === undefined) {

package/cjs/Options/Classes/AbsorberSize.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbsorberSize = void 0;
-const AbsorberSizeLimit_1 = require("./AbsorberSizeLimit");
 const engine_1 = require("@tsparticles/engine");
+const AbsorberSizeLimit_js_1 = require("./AbsorberSizeLimit.js");
 class AbsorberSize extends engine_1.ValueWithRandom {
     constructor() {
         super();
         this.density = 5;
         this.value = 50;
-        this.limit = new AbsorberSizeLimit_1.AbsorberSizeLimit();
+        this.limit = new AbsorberSizeLimit_js_1.AbsorberSizeLimit();
     }
     load(data) {
         if (!data) {
@@ -18,7 +18,7 @@ class AbsorberSize extends engine_1.ValueWithRandom {
         if (data.density !== undefined) {
             this.density = data.density;
         }
-        if (typeof data.limit === "number") {
+        if ((0, engine_1.isNumber)(data.limit)) {
             this.limit.radius = data.limit;
         }
         else {