@tsparticles/plugin-absorbers 4.0.0-alpha.2 → 4.0.0-alpha.20

package/tsparticles.plugin.absorbers.js

@@ -4,7 +4,7 @@
  * Demo / Generator : https://particles.js.org/
  * GitHub : https://www.github.com/matteobruni/tsparticles
  * How to use? : Check the GitHub README
- * v4.0.0-alpha.2
+ * v4.0.0-alpha.20
  */
 /*
  * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
@@ -16,25 +16,35 @@
  */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
-		module.exports = factory(require("@tsparticles/engine"));
+		module.exports = factory(require("@tsparticles/plugin-interactivity"), require("@tsparticles/engine"));
 	else if(typeof define === 'function' && define.amd)
-		define(["@tsparticles/engine"], factory);
+		define(["@tsparticles/plugin-interactivity", "@tsparticles/engine"], factory);
 	else {
-		var a = typeof exports === 'object' ? factory(require("@tsparticles/engine")) : factory(root["window"]);
+		var a = typeof exports === 'object' ? factory(require("@tsparticles/plugin-interactivity"), require("@tsparticles/engine")) : factory(root["window"], root["window"]);
 		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
 	}
-})(this, (__WEBPACK_EXTERNAL_MODULE__tsparticles_engine__) => {
+})(this, (__WEBPACK_EXTERNAL_MODULE__tsparticles_plugin_interactivity__, __WEBPACK_EXTERNAL_MODULE__tsparticles_engine__) => {
 return /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ "./dist/browser/Enums/AbsorberClickMode.js"
-/*!*************************************************!*\
-  !*** ./dist/browser/Enums/AbsorberClickMode.js ***!
-  \*************************************************/
-(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+/***/ "@tsparticles/engine"
+/*!*********************************************************************************************************************************!*\
+  !*** external {"commonjs":"@tsparticles/engine","commonjs2":"@tsparticles/engine","amd":"@tsparticles/engine","root":"window"} ***!
+  \*********************************************************************************************************************************/
+(module) {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__tsparticles_engine__;
+
+/***/ },
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   AbsorberClickMode: () => (/* binding */ AbsorberClickMode)\n/* harmony export */ });\nvar AbsorberClickMode;\n(function (AbsorberClickMode) {\n  AbsorberClickMode[\"absorber\"] = \"absorber\";\n})(AbsorberClickMode || (AbsorberClickMode = {}));\n\n//# sourceURL=webpack://@tsparticles/plugin-absorbers/./dist/browser/Enums/AbsorberClickMode.js?\n}");
+/***/ "@tsparticles/plugin-interactivity"
+/*!***************************************************************************************************************************************************************************!*\
+  !*** external {"commonjs":"@tsparticles/plugin-interactivity","commonjs2":"@tsparticles/plugin-interactivity","amd":"@tsparticles/plugin-interactivity","root":"window"} ***!
+  \***************************************************************************************************************************************************************************/
+(module) {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__tsparticles_plugin_interactivity__;
 
 /***/ },
 
@@ -44,17 +54,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpa
   \*******************************/
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   AbsorberClickMode: () => (/* reexport safe */ _Enums_AbsorberClickMode_js__WEBPACK_IMPORTED_MODULE_0__.AbsorberClickMode),\n/* harmony export */   loadAbsorbersPlugin: () => (/* binding */ loadAbsorbersPlugin)\n/* harmony export */ });\n/* harmony import */ var _Enums_AbsorberClickMode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Enums/AbsorberClickMode.js */ \"./dist/browser/Enums/AbsorberClickMode.js\");\nfunction loadAbsorbersPlugin(engine) {\n  engine.checkVersion(\"4.0.0-alpha.2\");\n  engine.register(async e => {\n    const {\n      AbsorbersPlugin\n    } = await __webpack_require__.e(/*! import() */ \"dist_browser_AbsorbersPlugin_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./AbsorbersPlugin.js */ \"./dist/browser/AbsorbersPlugin.js\"));\n    e.addPlugin(new AbsorbersPlugin(e));\n  });\n}\n\n\n//# sourceURL=webpack://@tsparticles/plugin-absorbers/./dist/browser/index.js?\n}");
-
-/***/ },
-
-/***/ "@tsparticles/engine"
-/*!*********************************************************************************************************************************!*\
-  !*** external {"commonjs":"@tsparticles/engine","commonjs2":"@tsparticles/engine","amd":"@tsparticles/engine","root":"window"} ***!
-  \*********************************************************************************************************************************/
-(module) {
-
-module.exports = __WEBPACK_EXTERNAL_MODULE__tsparticles_engine__;
+eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   loadAbsorbersPlugin: () => (/* binding */ loadAbsorbersPlugin)\n/* harmony export */ });\nasync function loadAbsorbersPlugin(engine) {\n    engine.checkVersion(\"4.0.0-alpha.20\");\n    await engine.register(async (e)=>{\n        const [{ ensureInteractivityPluginLoaded }, { AbsorbersInstancesManager }, { AbsorbersPlugin }] = await Promise.all([\n            Promise.resolve(/*! import() */).then(__webpack_require__.t.bind(__webpack_require__, /*! @tsparticles/plugin-interactivity */ \"@tsparticles/plugin-interactivity\", 19)),\n            __webpack_require__.e(/*! import() */ \"dist_browser_AbsorbersInstancesManager_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./AbsorbersInstancesManager.js */ \"./dist/browser/AbsorbersInstancesManager.js\")),\n            __webpack_require__.e(/*! import() */ \"dist_browser_AbsorbersPlugin_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./AbsorbersPlugin.js */ \"./dist/browser/AbsorbersPlugin.js\"))\n        ]), instancesManager = new AbsorbersInstancesManager(e);\n        ensureInteractivityPluginLoaded(e);\n        e.addPlugin(new AbsorbersPlugin(instancesManager));\n        e.addInteractor?.(\"externalAbsorbers\", async (container)=>{\n            const { AbsorbersInteractor } = await __webpack_require__.e(/*! import() */ \"dist_browser_AbsorbersInteractor_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./AbsorbersInteractor.js */ \"./dist/browser/AbsorbersInteractor.js\"));\n            return new AbsorbersInteractor(container, instancesManager);\n        });\n    });\n}\n\n\n//# sourceURL=webpack://@tsparticles/plugin-absorbers/./dist/browser/index.js?\n}");
 
 /***/ }
 
@@ -94,6 +94,36 @@ module.exports = __WEBPACK_EXTERNAL_MODULE__tsparticles_engine__;
 /******/ 	__webpack_require__.m = __webpack_modules__;
 /******/ 	
 /************************************************************************/
+/******/ 	/* webpack/runtime/create fake namespace object */
+/******/ 	(() => {
+/******/ 		var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);
+/******/ 		var leafPrototypes;
+/******/ 		// create a fake namespace object
+/******/ 		// mode & 1: value is a module id, require it
+/******/ 		// mode & 2: merge all properties of value into the ns
+/******/ 		// mode & 4: return value when already ns object
+/******/ 		// mode & 16: return value when it's Promise-like
+/******/ 		// mode & 8|1: behave like require
+/******/ 		__webpack_require__.t = function(value, mode) {
+/******/ 			if(mode & 1) value = this(value);
+/******/ 			if(mode & 8) return value;
+/******/ 			if(typeof value === 'object' && value) {
+/******/ 				if((mode & 4) && value.__esModule) return value;
+/******/ 				if((mode & 16) && typeof value.then === 'function') return value;
+/******/ 			}
+/******/ 			var ns = Object.create(null);
+/******/ 			__webpack_require__.r(ns);
+/******/ 			var def = {};
+/******/ 			leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
+/******/ 			for(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {
+/******/ 				Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));
+/******/ 			}
+/******/ 			def['default'] = () => (value);
+/******/ 			__webpack_require__.d(ns, def);
+/******/ 			return ns;
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/define property getters */
 /******/ 	(() => {
 /******/ 		// define getter functions for harmony exports

package/tsparticles.plugin.absorbers.min.js

@@ -1,2 +1,2 @@
-/*! For license information please see tsparticles.plugin.absorbers.min.js.LICENSE.txt */
-!function(e,r){if("object"==typeof exports&&"object"==typeof module)module.exports=r(require("@tsparticles/engine"));else if("function"==typeof define&&define.amd)define(["@tsparticles/engine"],r);else{var t="object"==typeof exports?r(require("@tsparticles/engine")):r(e.window);for(var o in t)("object"==typeof exports?exports:e)[o]=t[o]}}(this,(e=>(()=>{var r,t,o={303(r){r.exports=e},633(e,r,t){var o;t.d(r,{w:()=>o}),function(e){e.absorber="absorber"}(o||(o={}))}},n={};function i(e){var r=n[e];if(void 0!==r)return r.exports;var t=n[e]={exports:{}};return o[e](t,t.exports,i),t.exports}i.m=o,i.d=(e,r)=>{for(var t in r)i.o(r,t)&&!i.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:r[t]})},i.f={},i.e=e=>Promise.all(Object.keys(i.f).reduce(((r,t)=>(i.f[t](e,r),r)),[])),i.u=e=>e+".min.js",i.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),i.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),r={},t="@tsparticles/plugin-absorbers:",i.l=(e,o,n,a)=>{if(r[e])r[e].push(o);else{var s,l;if(void 0!==n)for(var c=document.getElementsByTagName("script"),p=0;p<c.length;p++){var u=c[p];if(u.getAttribute("src")==e||u.getAttribute("data-webpack")==t+n){s=u;break}}s||(l=!0,(s=document.createElement("script")).charset="utf-8",i.nc&&s.setAttribute("nonce",i.nc),s.setAttribute("data-webpack",t+n),s.src=e),r[e]=[o];var d=(t,o)=>{s.onerror=s.onload=null,clearTimeout(b);var n=r[e];if(delete r[e],s.parentNode&&s.parentNode.removeChild(s),n&&n.forEach((e=>e(o))),t)return t(o)},b=setTimeout(d.bind(null,void 0,{type:"timeout",target:s}),12e4);s.onerror=d.bind(null,s.onerror),s.onload=d.bind(null,s.onload),l&&document.head.appendChild(s)}},i.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},(()=>{var e;i.g.importScripts&&(e=i.g.location+"");var r=i.g.document;if(!e&&r&&(r.currentScript&&"SCRIPT"===r.currentScript.tagName.toUpperCase()&&(e=r.currentScript.src),!e)){var t=r.getElementsByTagName("script");if(t.length)for(var o=t.length-1;o>-1&&(!e||!/^http(s?):/.test(e));)e=t[o--].src}if(!e)throw new Error("Automatic publicPath is not supported in this browser");e=e.replace(/^blob:/,"").replace(/#.*$/,"").replace(/\?.*$/,"").replace(/\/[^\/]+$/,"/"),i.p=e})(),(()=>{var e={425:0};i.f.j=(r,t)=>{var o=i.o(e,r)?e[r]:void 0;if(0!==o)if(o)t.push(o[2]);else{var n=new Promise(((t,n)=>o=e[r]=[t,n]));t.push(o[2]=n);var a=i.p+i.u(r),s=new Error;i.l(a,(t=>{if(i.o(e,r)&&(0!==(o=e[r])&&(e[r]=void 0),o)){var n=t&&("load"===t.type?"missing":t.type),a=t&&t.target&&t.target.src;s.message="Loading chunk "+r+" failed.\n("+n+": "+a+")",s.name="ChunkLoadError",s.type=n,s.request=a,o[1](s)}}),"chunk-"+r,r)}};var r=(r,t)=>{var o,n,[a,s,l]=t,c=0;if(a.some((r=>0!==e[r]))){for(o in s)i.o(s,o)&&(i.m[o]=s[o]);if(l)l(i)}for(r&&r(t);c<a.length;c++)n=a[c],i.o(e,n)&&e[n]&&e[n][0](),e[n]=0},t=this.webpackChunk_tsparticles_plugin_absorbers=this.webpackChunk_tsparticles_plugin_absorbers||[];t.forEach(r.bind(null,0)),t.push=r.bind(null,t.push.bind(t))})();var a={};i.r(a),i.d(a,{AbsorberClickMode:()=>s.w,loadAbsorbersPlugin:()=>l});var s=i(633);function l(e){e.checkVersion("4.0.0-alpha.2"),e.register((async e=>{const{AbsorbersPlugin:r}=await i.e(47).then(i.bind(i,47));e.addPlugin(new r(e))}))}return a})()));
+!function(e,t){if("object"==typeof exports&&"object"==typeof module)module.exports=t(require("@tsparticles/plugin-interactivity"),require("@tsparticles/engine"));else if("function"==typeof define&&define.amd)define(["@tsparticles/plugin-interactivity","@tsparticles/engine"],t);else{var r="object"==typeof exports?t(require("@tsparticles/plugin-interactivity"),require("@tsparticles/engine")):t(e.window,e.window);for(var o in r)("object"==typeof exports?exports:e)[o]=r[o]}}(this,(e,t)=>(()=>{"use strict";var r,o,i,n={303(e){e.exports=t},702(t){t.exports=e}},a={};function s(e){var t=a[e];if(void 0!==t)return t.exports;var r=a[e]={exports:{}};return n[e](r,r.exports,s),r.exports}s.m=n,l=Object.getPrototypeOf?e=>Object.getPrototypeOf(e):e=>e.__proto__,s.t=function(e,t){if(1&t&&(e=this(e)),8&t||"object"==typeof e&&e&&(4&t&&e.__esModule||16&t&&"function"==typeof e.then))return e;var r=Object.create(null);s.r(r);var o={};c=c||[null,l({}),l([]),l(l)];for(var i=2&t&&e;("object"==typeof i||"function"==typeof i)&&!~c.indexOf(i);i=l(i))Object.getOwnPropertyNames(i).forEach(t=>o[t]=()=>e[t]);return o.default=()=>e,s.d(r,o),r},s.d=(e,t)=>{for(var r in t)s.o(t,r)&&!s.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},s.f={},s.e=e=>Promise.all(Object.keys(s.f).reduce((t,r)=>(s.f[r](e,t),t),[])),s.u=e=>""+e+".min.js",s.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||Function("return this")()}catch(e){if("object"==typeof window)return window}}(),s.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),p={},s.l=(e,t,r,o)=>{if(p[e])return void p[e].push(t);if(void 0!==r)for(var i,n,a=document.getElementsByTagName("script"),c=0;c<a.length;c++){var l=a[c];if(l.getAttribute("src")==e||l.getAttribute("data-webpack")=="@tsparticles/plugin-absorbers:"+r){i=l;break}}i||(n=!0,(i=document.createElement("script")).charset="utf-8",s.nc&&i.setAttribute("nonce",s.nc),i.setAttribute("data-webpack","@tsparticles/plugin-absorbers:"+r),i.src=e),p[e]=[t];var u=(t,r)=>{i.onerror=i.onload=null,clearTimeout(d);var o=p[e];if(delete p[e],i.parentNode&&i.parentNode.removeChild(i),o&&o.forEach(e=>e(r)),t)return t(r)},d=setTimeout(u.bind(null,void 0,{type:"timeout",target:i}),12e4);i.onerror=u.bind(null,i.onerror),i.onload=u.bind(null,i.onload),n&&document.head.appendChild(i)},s.r=e=>{"u">typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},s.g.importScripts&&(u=s.g.location+"");var c,l,p,u,d=s.g.document;if(!u&&d&&(d.currentScript&&"SCRIPT"===d.currentScript.tagName.toUpperCase()&&(u=d.currentScript.src),!u)){var f=d.getElementsByTagName("script");if(f.length)for(var b=f.length-1;b>-1&&(!u||!/^http(s?):/.test(u));)u=f[b--].src}if(!u)throw Error("Automatic publicPath is not supported in this browser");s.p=u=u.replace(/^blob:/,"").replace(/#.*$/,"").replace(/\?.*$/,"").replace(/\/[^\/]+$/,"/"),r={425:0},s.f.j=(e,t)=>{var o=s.o(r,e)?r[e]:void 0;if(0!==o)if(o)t.push(o[2]);else{var i=new Promise((t,i)=>o=r[e]=[t,i]);t.push(o[2]=i);var n=s.p+s.u(e),a=Error();s.l(n,t=>{if(s.o(r,e)&&(0!==(o=r[e])&&(r[e]=void 0),o)){var i=t&&("load"===t.type?"missing":t.type),n=t&&t.target&&t.target.src;a.message="Loading chunk "+e+` failed.
+(`+i+": "+n+")",a.name="ChunkLoadError",a.type=i,a.request=n,o[1](a)}},"chunk-"+e,e)}},o=(e,t)=>{var o,i,[n,a,c]=t,l=0;if(n.some(e=>0!==r[e])){for(o in a)s.o(a,o)&&(s.m[o]=a[o]);c&&c(s)}for(e&&e(t);l<n.length;l++)i=n[l],s.o(r,i)&&r[i]&&r[i][0](),r[i]=0},(i=this.webpackChunk_tsparticles_plugin_absorbers=this.webpackChunk_tsparticles_plugin_absorbers||[]).forEach(o.bind(null,0)),i.push=o.bind(null,i.push.bind(i));var g={};async function h(e){e.checkVersion("4.0.0-alpha.20"),await e.register(async e=>{let[{ensureInteractivityPluginLoaded:t},{AbsorbersInstancesManager:r},{AbsorbersPlugin:o}]=await Promise.all([Promise.resolve().then(s.t.bind(s,702,19)),s.e(991).then(s.bind(s,991)),s.e(295).then(s.bind(s,295))]),i=new r(e);t(e),e.addPlugin(new o(i)),e.addInteractor?.("externalAbsorbers",async e=>{let{AbsorbersInteractor:t}=await s.e(415).then(s.bind(s,415));return new t(e,i)})})}return s.r(g),s.d(g,{loadAbsorbersPlugin:()=>h}),g})());

package/types/AbsorberContainer.d.ts

@@ -1,9 +1,10 @@
-import type { Container, ICoordinates, RecursivePartial } from "@tsparticles/engine";
+import type { ICoordinates, RecursivePartial } from "@tsparticles/engine";
 import type { AbsorberInstance } from "./AbsorberInstance.js";
 import type { AbsorberOptions } from "./types.js";
 import type { IAbsorber } from "./Options/Interfaces/IAbsorber.js";
-export interface AbsorberContainer extends Container {
+import type { InteractivityContainer } from "@tsparticles/plugin-interactivity";
+export interface AbsorberContainer extends InteractivityContainer {
     actualOptions: AbsorberOptions;
-    addAbsorber: (options: RecursivePartial<IAbsorber>, position?: ICoordinates) => Promise<AbsorberInstance>;
-    getAbsorber: (idxOrName?: number | string) => AbsorberInstance | undefined;
+    addAbsorber?: (options: RecursivePartial<IAbsorber>, position?: ICoordinates) => Promise<AbsorberInstance>;
+    getAbsorber?: (idxOrName?: number | string) => AbsorberInstance | undefined;
 }

package/types/AbsorberInstance.d.ts

@@ -1,4 +1,5 @@
-import { type Container, type Engine, type ICoordinates, type IRgb, type Particle, type RecursivePartial, RotateDirection, Vector } from "@tsparticles/engine";
+import { type Container, type Engine, type ICoordinates, type IDelta, type IRgb, type Particle, type RecursivePartial, RotateDirection, Vector } from "@tsparticles/engine";
+import { Absorber } from "./Options/Classes/Absorber.js";
 import type { IAbsorber } from "./Options/Interfaces/IAbsorber.js";
 import type { IAbsorberSizeLimit } from "./Options/Interfaces/IAbsorberSizeLimit.js";
 type OrbitingParticle = Particle & {
@@ -12,18 +13,27 @@ export declare class AbsorberInstance {
     mass: number;
     readonly name?: string;
     opacity: number;
+    readonly options: Absorber;
     position: Vector;
     size: number;
     private readonly _container;
+    private _currentDuration;
+    private _currentSpawnDelay;
+    private _duration?;
     private readonly _engine;
-    private dragging;
+    private _firstSpawn;
+    private readonly _immortal;
+    private _lifeCount;
+    private _spawnDelay?;
     private readonly initialPosition?;
-    private readonly options;
-    constructor(container: Container, engine: Engine, options: RecursivePartial<IAbsorber>, position?: ICoordinates);
-    attract(particle: OrbitingParticle): void;
+    constructor(engine: Engine, container: Container, options: RecursivePartial<IAbsorber>, position?: ICoordinates);
+    attract(particle: OrbitingParticle, delta: IDelta): void;
     draw(context: CanvasRenderingContext2D): void;
     resize(): void;
+    update(delta: IDelta): void;
     private readonly _calcPosition;
+    private readonly _prepareToDie;
     private readonly _updateParticlePosition;
+    private readonly play;
 }
 export {};

package/types/AbsorbersInstancesManager.d.ts

@@ -0,0 +1,14 @@
+import { type Engine, type ICoordinates, type RecursivePartial } from "@tsparticles/engine";
+import type { AbsorberContainer } from "./AbsorberContainer.js";
+import type { AbsorberInstance } from "./AbsorberInstance.js";
+import type { IAbsorber } from "./Options/Interfaces/IAbsorber.js";
+export declare class AbsorbersInstancesManager {
+    private readonly _containerArrays;
+    private readonly _engine;
+    constructor(engine: Engine);
+    addAbsorber(container: AbsorberContainer, options: RecursivePartial<IAbsorber>, position?: ICoordinates): Promise<AbsorberInstance>;
+    clear(container: AbsorberContainer): void;
+    getArray(container: AbsorberContainer): AbsorberInstance[];
+    initContainer(container: AbsorberContainer): void;
+    removeAbsorber(container: AbsorberContainer, absorber: AbsorberInstance): void;
+}

package/types/AbsorbersInteractor.d.ts

@@ -0,0 +1,18 @@
+import type { AbsorberModeOptions, IAbsorberModeOptions } from "./types.js";
+import { ExternalInteractorBase, type IInteractivityData, type IModes, type InteractivityParticle, type Modes } from "@tsparticles/plugin-interactivity";
+import { type IDelta, type RecursivePartial } from "@tsparticles/engine";
+import type { AbsorberContainer } from "./AbsorberContainer.js";
+import type { AbsorbersInstancesManager } from "./AbsorbersInstancesManager.js";
+export declare class AbsorbersInteractor extends ExternalInteractorBase<AbsorberContainer> {
+    handleClickMode: (mode: string, interactivityData: IInteractivityData) => void;
+    private readonly _instancesManager;
+    private dragging;
+    private draggingAbsorber;
+    constructor(container: AbsorberContainer, instancesManager: AbsorbersInstancesManager);
+    clear(): void;
+    init(): void;
+    interact(interactivityData: IInteractivityData, delta: IDelta): void;
+    isEnabled(interactivityData: IInteractivityData, particle?: InteractivityParticle): boolean;
+    loadModeOptions(options: Modes & AbsorberModeOptions, ...sources: RecursivePartial<(IModes & IAbsorberModeOptions) | undefined>[]): void;
+    reset(): void;
+}

package/types/AbsorbersPlugin.d.ts

@@ -1,12 +1,12 @@
 import type { AbsorberOptions, IAbsorberOptions } from "./types.js";
-import { type Engine, type IOptions, type IPlugin, type RecursivePartial } from "@tsparticles/engine";
+import { type Container, type IContainerPlugin, type IOptions, type IPlugin, type RecursivePartial } from "@tsparticles/engine";
 import type { AbsorberContainer } from "./AbsorberContainer.js";
-import { Absorbers } from "./Absorbers.js";
+import type { AbsorbersInstancesManager } from "./AbsorbersInstancesManager.js";
 export declare class AbsorbersPlugin implements IPlugin {
-    readonly id: string;
-    private readonly _engine;
-    constructor(engine: Engine);
-    getPlugin(container: AbsorberContainer): Promise<Absorbers>;
-    loadOptions(options: AbsorberOptions, source?: RecursivePartial<IAbsorberOptions>): void;
+    readonly id = "absorbers";
+    private readonly _instancesManager;
+    constructor(instancesManager: AbsorbersInstancesManager);
+    getPlugin(container: AbsorberContainer): Promise<IContainerPlugin>;
+    loadOptions(_container: Container, options: AbsorberOptions, source?: RecursivePartial<IAbsorberOptions>): void;
     needsPlugin(options?: RecursivePartial<IOptions & IAbsorberOptions>): boolean;
 }

package/types/AbsorbersPluginInstance.d.ts

@@ -0,0 +1,13 @@
+import { type IContainerPlugin, type IDelta, type Particle } from "@tsparticles/engine";
+import type { AbsorberContainer } from "./AbsorberContainer.js";
+import type { AbsorbersInstancesManager } from "./AbsorbersInstancesManager.js";
+export declare class AbsorbersPluginInstance implements IContainerPlugin {
+    private readonly _container;
+    private readonly _instancesManager;
+    constructor(container: AbsorberContainer, instancesManager: AbsorbersInstancesManager);
+    draw(context: CanvasRenderingContext2D): void;
+    init(): Promise<void>;
+    particleUpdate(particle: Particle, delta: IDelta): void;
+    resize(): void;
+    stop(): void;
+}

package/types/Options/Classes/Absorber.d.ts

@@ -1,10 +1,12 @@
 import { type IOptionLoader, type IRangedCoordinates, OptionsColor, type RecursivePartial } from "@tsparticles/engine";
+import { AbsorberLife } from "./AbsorberLife.js";
 import { AbsorberSize } from "./AbsorberSize.js";
 import type { IAbsorber } from "../Interfaces/IAbsorber.js";
 export declare class Absorber implements IAbsorber, IOptionLoader<IAbsorber> {
     color: OptionsColor;
     destroy: boolean;
     draggable: boolean;
+    life: AbsorberLife;
     name?: string;
     opacity: number;
     orbits: boolean;

package/types/Options/Classes/AbsorberLife.d.ts

@@ -0,0 +1,10 @@
+import { type IOptionLoader, type RangeValue, type RecursivePartial } from "@tsparticles/engine";
+import type { IAbsorberLife } from "../Interfaces/IAbsorberLife.js";
+export declare class AbsorberLife implements IAbsorberLife, IOptionLoader<IAbsorberLife> {
+    count?: number;
+    delay?: RangeValue;
+    duration?: RangeValue;
+    wait: boolean;
+    constructor();
+    load(data?: RecursivePartial<IAbsorberLife>): void;
+}

package/types/Options/Interfaces/IAbsorber.d.ts

@@ -1,9 +1,11 @@
 import type { IOptionsColor, IRangedCoordinates, RecursivePartial } from "@tsparticles/engine";
+import type { IAbsorberLife } from "./IAbsorberLife.js";
 import type { IAbsorberSize } from "./IAbsorberSize.js";
 export interface IAbsorber {
     color: string | IOptionsColor;
     destroy: boolean;
     draggable: boolean;
+    life: IAbsorberLife;
     name?: string;
     opacity: number;
     orbits: boolean;

package/types/Options/Interfaces/IAbsorberLife.d.ts

@@ -0,0 +1,7 @@
+import type { RangeValue } from "@tsparticles/engine";
+export interface IAbsorberLife {
+    count?: number;
+    delay?: RangeValue;
+    duration?: RangeValue;
+    wait: boolean;
+}

package/types/index.d.ts

@@ -1,4 +1,3 @@
 import { type Engine } from "@tsparticles/engine";
-export declare function loadAbsorbersPlugin(engine: Engine): void;
+export declare function loadAbsorbersPlugin(engine: Engine): Promise<void>;
 export type * from "./AbsorberContainer.js";
-export * from "./Enums/AbsorberClickMode.js";

package/types/types.d.ts

@@ -1,19 +1,22 @@
-import type { IOptions, Options, SingleOrMultiple } from "@tsparticles/engine";
+import type { IInteractivityOptions, InteractivityOptions } from "@tsparticles/plugin-interactivity";
 import type { Absorber } from "./Options/Classes/Absorber.js";
 import type { IAbsorber } from "./Options/Interfaces/IAbsorber.js";
-export type AbsorberOptions = Options & {
+import type { SingleOrMultiple } from "@tsparticles/engine";
+export interface AbsorberModeOptions {
+    absorbers?: Absorber[];
+}
+export interface IAbsorberModeOptions {
+    absorbers?: SingleOrMultiple<IAbsorber>;
+}
+export type AbsorberOptions = InteractivityOptions & {
     absorbers: SingleOrMultiple<Absorber>;
     interactivity: {
-        modes: {
-            absorbers: SingleOrMultiple<Absorber>;
-        };
+        modes: AbsorberModeOptions;
     };
 };
-export type IAbsorberOptions = IOptions & {
+export type IAbsorberOptions = IInteractivityOptions & {
     absorbers: SingleOrMultiple<IAbsorber>;
     interactivity: {
-        modes: {
-            absorbers: SingleOrMultiple<IAbsorber>;
-        };
+        modes: IAbsorberModeOptions;
     };
 };

package/umd/AbsorberInstance.js

@@ -12,62 +12,31 @@
     exports.AbsorberInstance = void 0;
     const engine_1 = require("@tsparticles/engine");
     const Absorber_js_1 = require("./Options/Classes/Absorber.js");
-    const squareExp = 2, absorbFactor = 0.033, minOrbitLength = 0, minRadius = 0, minMass = 0, minAngle = 0, double = 2, maxAngle = Math.PI * double, minVelocity = 0;
+    const squareExp = 2, absorbFactor = 0.033, minOrbitLength = 0, minRadius = 0, minMass = 0, minAngle = 0, maxAngle = engine_1.doublePI, minVelocity = 0, defaultLifeDelay = 0, minLifeCount = 0, defaultSpawnDelay = 0, defaultLifeCount = -1;
     class AbsorberInstance {
-        constructor(container, engine, options, position) {
-            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.origin;
-                        particle.absorberOrbit.length = (0, engine_1.getDistance)(particle.getPosition(), this.position);
-                        particle.absorberOrbit.angle = (0, engine_1.getRandom)() * maxAngle;
-                    }
-                    if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
-                        const minSize = Math.min(canvasSize.width, canvasSize.height), offset = 1, randomOffset = 0.1, randomFactor = 0.2;
-                        particle.absorberOrbit.length = minSize * (offset + ((0, engine_1.getRandom)() * randomFactor - randomOffset));
-                    }
-                    particle.absorberOrbitDirection ??=
-                        particle.velocity.x >= minVelocity ? engine_1.RotateDirection.clockwise : engine_1.RotateDirection.counterClockwise;
-                    const orbitRadius = particle.absorberOrbit.length, orbitAngle = particle.absorberOrbit.angle, orbitDirection = particle.absorberOrbitDirection;
-                    particle.velocity.setTo(engine_1.Vector.origin);
-                    const updateFunc = {
-                        x: orbitDirection === engine_1.RotateDirection.clockwise ? Math.cos : Math.sin,
-                        y: orbitDirection === engine_1.RotateDirection.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 ?? minVelocity) * container.retina.pixelRatio) / engine_1.percentDenominator) *
-                            container.retina.reduceFactor;
-                }
-                else {
-                    const addV = engine_1.Vector.origin;
-                    addV.length = v.length;
-                    addV.angle = v.angle;
-                    particle.velocity.addTo(addV);
-                }
-            };
+        color;
+        limit;
+        mass;
+        name;
+        opacity;
+        options;
+        position;
+        size;
+        _container;
+        _currentDuration;
+        _currentSpawnDelay;
+        _duration;
+        _engine;
+        _firstSpawn;
+        _immortal;
+        _lifeCount;
+        _spawnDelay;
+        initialPosition;
+        constructor(engine, container, options, position) {
             this._container = container;
             this._engine = engine;
+            this._currentDuration = 0;
+            this._currentSpawnDelay = 0;
             this.initialPosition = position ? engine_1.Vector.create(position.x, position.y) : undefined;
             if (options instanceof Absorber_js_1.Absorber) {
                 this.options = options;
@@ -76,7 +45,6 @@
                 this.options = new Absorber_js_1.Absorber();
                 this.options.load(options);
             }
-            this.dragging = false;
             this.name = this.options.name;
             this.opacity = this.options.opacity;
             this.size = (0, engine_1.getRangeValue)(this.options.size.value) * container.retina.pixelRatio;
@@ -92,29 +60,19 @@
                 r: 0,
             };
             this.position = this.initialPosition?.copy() ?? this._calcPosition();
+            this._firstSpawn = !this.options.life.wait;
+            this._lifeCount = this.options.life.count ?? defaultLifeCount;
+            this._immortal = this._lifeCount <= minLifeCount;
+            this._spawnDelay = container.retina.reduceFactor
+                ? ((0, engine_1.getRangeValue)(this.options.life.delay ?? defaultLifeDelay) * engine_1.millisecondsToSeconds) /
+                    container.retina.reduceFactor
+                : Infinity;
         }
-        attract(particle) {
-            const container = this._container, options = this.options;
-            if (options.draggable) {
-                const mouse = container.interactivity.mouse;
-                if (mouse.clicking && mouse.downPosition) {
-                    const mouseDist = (0, engine_1.getDistance)(this.position, mouse.downPosition);
-                    if (mouseDist <= this.size) {
-                        this.dragging = true;
-                    }
-                }
-                else {
-                    this.dragging = false;
-                }
-                if (this.dragging && mouse.position) {
-                    this.position.x = mouse.position.x;
-                    this.position.y = mouse.position.y;
-                }
-            }
-            const pos = particle.getPosition(), { dx, dy, distance } = (0, engine_1.getDistances)(this.position, pos), v = engine_1.Vector.create(dx, dy);
+        attract(particle, delta) {
+            const container = this._container, options = this.options, pos = particle.getPosition(), { dx, dy, distance } = (0, engine_1.getDistances)(this.position, pos), v = engine_1.Vector.create(dx, dy);
             v.length = (this.mass / Math.pow(distance, squareExp)) * container.retina.reduceFactor;
             if (distance < this.size + particle.getRadius()) {
-                const sizeFactor = particle.getRadius() * absorbFactor * container.retina.pixelRatio;
+                const sizeFactor = particle.getRadius() * absorbFactor * container.retina.pixelRatio * delta.factor;
                 if ((this.size > particle.getRadius() && distance < this.size - particle.getRadius()) ||
                     (particle.absorberOrbit !== undefined && particle.absorberOrbit.length < minOrbitLength)) {
                     if (options.destroy) {
@@ -157,6 +115,103 @@
                     ? initialPosition
                     : this._calcPosition();
         }
+        update(delta) {
+            if (this._firstSpawn) {
+                this._firstSpawn = false;
+                this._currentSpawnDelay = this._spawnDelay ?? defaultSpawnDelay;
+            }
+            if (this._duration !== undefined) {
+                this._currentDuration += delta.value;
+                if (this._currentDuration >= this._duration) {
+                    if (!this._immortal) {
+                        this._lifeCount--;
+                    }
+                    if (this._lifeCount > minLifeCount || this._immortal) {
+                        this.position = this._calcPosition();
+                        this._spawnDelay = this._container.retina.reduceFactor
+                            ? ((0, engine_1.getRangeValue)(this.options.life.delay ?? defaultLifeDelay) * engine_1.millisecondsToSeconds) /
+                                this._container.retina.reduceFactor
+                            : Infinity;
+                    }
+                    this._currentDuration -= this._duration;
+                    delete this._duration;
+                }
+            }
+            if (this._spawnDelay !== undefined) {
+                this._currentSpawnDelay += delta.value;
+                if (this._currentSpawnDelay >= this._spawnDelay) {
+                    this.play();
+                    this._currentSpawnDelay -= this._spawnDelay;
+                    delete this._spawnDelay;
+                }
+            }
+        }
+        _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);
+        };
+        _prepareToDie = () => {
+            const duration = this.options.life.duration !== undefined ? (0, engine_1.getRangeValue)(this.options.life.duration) : undefined, minDuration = 0;
+            if ((this._lifeCount > minLifeCount || this._immortal) && duration !== undefined && duration > minDuration) {
+                this._duration = duration * engine_1.millisecondsToSeconds;
+            }
+        };
+        _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.origin;
+                    particle.absorberOrbit.length = (0, engine_1.getDistance)(particle.getPosition(), this.position);
+                    particle.absorberOrbit.angle = (0, engine_1.getRandom)() * maxAngle;
+                }
+                if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
+                    const minSize = Math.min(canvasSize.width, canvasSize.height), offset = 1, randomOffset = 0.1, randomFactor = 0.2;
+                    particle.absorberOrbit.length = minSize * (offset + ((0, engine_1.getRandom)() * randomFactor - randomOffset));
+                }
+                particle.absorberOrbitDirection ??=
+                    particle.velocity.x >= minVelocity ? engine_1.RotateDirection.clockwise : engine_1.RotateDirection.counterClockwise;
+                const orbitRadius = particle.absorberOrbit.length, orbitAngle = particle.absorberOrbit.angle, orbitDirection = particle.absorberOrbitDirection;
+                particle.velocity.setTo(engine_1.Vector.origin);
+                const updateFunc = {
+                    x: orbitDirection === engine_1.RotateDirection.clockwise ? Math.cos : Math.sin,
+                    y: orbitDirection === engine_1.RotateDirection.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 ?? minVelocity) * container.retina.pixelRatio) / engine_1.percentDenominator) *
+                        container.retina.reduceFactor;
+            }
+            else {
+                const addV = engine_1.Vector.origin;
+                addV.length = v.length;
+                addV.angle = v.angle;
+                particle.velocity.addTo(addV);
+            }
+        };
+        play = () => {
+            if (!((this._lifeCount > minLifeCount || this._immortal || !this.options.life.count) &&
+                (this._firstSpawn || this._currentSpawnDelay >= (this._spawnDelay ?? defaultSpawnDelay)))) {
+                return;
+            }
+            if (this._lifeCount > minLifeCount || this._immortal) {
+                this._prepareToDie();
+            }
+        };
     }
     exports.AbsorberInstance = AbsorberInstance;
 });