@tsparticles/plugin-absorbers 3.0.0-alpha.0

package/tsparticles.plugin.absorbers.js

@@ -0,0 +1,458 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v3.0.0-alpha.0
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("@tsparticles/engine"));
+	else if(typeof define === 'function' && define.amd)
+		define(["@tsparticles/engine"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("@tsparticles/engine")) : factory(root["window"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(this, (__WEBPACK_EXTERNAL_MODULE__533__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 533:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__533__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "loadAbsorbersPlugin": () => (/* binding */ loadAbsorbersPlugin)
+});
+
+// EXTERNAL MODULE: external {"commonjs":"@tsparticles/engine","commonjs2":"@tsparticles/engine","amd":"@tsparticles/engine","root":"window"}
+var engine_root_window_ = __webpack_require__(533);
+;// CONCATENATED MODULE: ./dist/browser/Options/Classes/AbsorberSizeLimit.js
+class AbsorberSizeLimit {
+  constructor() {
+    this.radius = 0;
+    this.mass = 0;
+  }
+  load(data) {
+    if (!data) {
+      return;
+    }
+    if (data.mass !== undefined) {
+      this.mass = data.mass;
+    }
+    if (data.radius !== undefined) {
+      this.radius = data.radius;
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/Options/Classes/AbsorberSize.js
+
+
+class AbsorberSize extends engine_root_window_.ValueWithRandom {
+  constructor() {
+    super();
+    this.density = 5;
+    this.value = 50;
+    this.limit = new AbsorberSizeLimit();
+  }
+  load(data) {
+    if (!data) {
+      return;
+    }
+    super.load(data);
+    if (data.density !== undefined) {
+      this.density = data.density;
+    }
+    if (typeof data.limit === "number") {
+      this.limit.radius = data.limit;
+    } else {
+      this.limit.load(data.limit);
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/Options/Classes/Absorber.js
+
+
+class Absorber {
+  constructor() {
+    this.color = new engine_root_window_.OptionsColor();
+    this.color.value = "#000000";
+    this.draggable = false;
+    this.opacity = 1;
+    this.destroy = true;
+    this.orbits = false;
+    this.size = new AbsorberSize();
+  }
+  load(data) {
+    if (data === undefined) {
+      return;
+    }
+    if (data.color !== undefined) {
+      this.color = engine_root_window_.OptionsColor.create(this.color, data.color);
+    }
+    if (data.draggable !== undefined) {
+      this.draggable = data.draggable;
+    }
+    this.name = data.name;
+    if (data.opacity !== undefined) {
+      this.opacity = data.opacity;
+    }
+    if (data.position !== undefined) {
+      this.position = {};
+      if (data.position.x !== undefined) {
+        this.position.x = (0,engine_root_window_.setRangeValue)(data.position.x);
+      }
+      if (data.position.y !== undefined) {
+        this.position.y = (0,engine_root_window_.setRangeValue)(data.position.y);
+      }
+    }
+    if (data.size !== undefined) {
+      this.size.load(data.size);
+    }
+    if (data.destroy !== undefined) {
+      this.destroy = data.destroy;
+    }
+    if (data.orbits !== undefined) {
+      this.orbits = data.orbits;
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/AbsorberInstance.js
+
+
+class AbsorberInstance {
+  constructor(absorbers, container, options, position) {
+    var _a, _b, _c;
+    this.absorbers = absorbers;
+    this.container = container;
+    this.initialPosition = position ? engine_root_window_.Vector.create(position.x, position.y) : undefined;
+    if (options instanceof Absorber) {
+      this.options = options;
+    } else {
+      this.options = new Absorber();
+      this.options.load(options);
+    }
+    this.dragging = false;
+    this.name = this.options.name;
+    this.opacity = this.options.opacity;
+    this.size = (0,engine_root_window_.getRangeValue)(this.options.size.value) * container.retina.pixelRatio;
+    this.mass = this.size * this.options.size.density * container.retina.reduceFactor;
+    const limit = this.options.size.limit;
+    this.limit = {
+      radius: limit.radius * container.retina.pixelRatio * container.retina.reduceFactor,
+      mass: limit.mass
+    };
+    this.color = (_a = (0,engine_root_window_.rangeColorToRgb)(this.options.color)) !== null && _a !== void 0 ? _a : {
+      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();
+  }
+  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_root_window_.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_root_window_.getDistances)(this.position, pos),
+      v = engine_root_window_.Vector.create(dx, dy);
+    v.length = this.mass / Math.pow(distance, 2) * container.retina.reduceFactor;
+    if (distance < this.size + particle.getRadius()) {
+      const sizeFactor = particle.getRadius() * 0.033 * container.retina.pixelRatio;
+      if (this.size > particle.getRadius() && distance < this.size - particle.getRadius() || particle.absorberOrbit !== undefined && particle.absorberOrbit.length < 0) {
+        if (options.destroy) {
+          particle.destroy();
+        } else {
+          particle.needsNewPosition = true;
+          this.updateParticlePosition(particle, v);
+        }
+      } else {
+        if (options.destroy) {
+          particle.size.value -= sizeFactor;
+        }
+        this.updateParticlePosition(particle, v);
+      }
+      if (this.limit.radius <= 0 || this.size < this.limit.radius) {
+        this.size += sizeFactor;
+      }
+      if (this.limit.mass <= 0 || this.mass < this.limit.mass) {
+        this.mass += sizeFactor * this.options.size.density * container.retina.reduceFactor;
+      }
+    } else {
+      this.updateParticlePosition(particle, v);
+    }
+  }
+  draw(context) {
+    context.translate(this.position.x, this.position.y);
+    context.beginPath();
+    context.arc(0, 0, this.size, 0, Math.PI * 2, false);
+    context.closePath();
+    context.fillStyle = (0,engine_root_window_.getStyleFromRgb)(this.color, this.opacity);
+    context.fill();
+  }
+  resize() {
+    const initialPosition = this.initialPosition;
+    this.position = initialPosition && (0,engine_root_window_.isPointInside)(initialPosition, this.container.canvas.size, engine_root_window_.Vector.origin) ? initialPosition : this.calcPosition();
+  }
+  calcPosition() {
+    const exactPosition = (0,engine_root_window_.calcPositionOrRandomFromSizeRanged)({
+      size: this.container.canvas.size,
+      position: this.options.position
+    });
+    return engine_root_window_.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_root_window_.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_root_window_.Vector.create(0, 0);
+        particle.absorberOrbit.length = (0,engine_root_window_.getDistance)(particle.getPosition(), this.position);
+        particle.absorberOrbit.angle = (0,engine_root_window_.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_root_window_.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_root_window_.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_root_window_.Vector.origin;
+      addV.length = v.length;
+      addV.angle = v.angle;
+      particle.velocity.addTo(addV);
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/Absorbers.js
+
+
+class Absorbers {
+  constructor(container) {
+    this.container = container;
+    this.array = [];
+    this.absorbers = [];
+    this.interactivityAbsorbers = [];
+    container.getAbsorber = idxOrName => idxOrName === undefined || typeof idxOrName === "number" ? 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(this, this.container, options, position);
+    this.array.push(absorber);
+    return absorber;
+  }
+  draw(context) {
+    for (const absorber of this.array) {
+      absorber.draw(context);
+    }
+  }
+  handleClickMode(mode) {
+    const absorberOptions = this.absorbers,
+      modeAbsorbers = this.interactivityAbsorbers;
+    if (mode === "absorber") {
+      const absorbersModeOptions = (0,engine_root_window_.itemFromSingleOrMultiple)(modeAbsorbers),
+        absorbersOptions = absorbersModeOptions !== null && absorbersModeOptions !== void 0 ? absorbersModeOptions : (0,engine_root_window_.itemFromSingleOrMultiple)(absorberOptions),
+        aPosition = this.container.interactivity.mouse.clickPosition;
+      this.addAbsorber(absorbersOptions, aPosition);
+    }
+  }
+  async init() {
+    this.absorbers = this.container.actualOptions.absorbers;
+    this.interactivityAbsorbers = this.container.actualOptions.interactivity.modes.absorbers;
+    (0,engine_root_window_.executeOnSingleOrMultiple)(this.absorbers, absorber => {
+      this.addAbsorber(absorber);
+    });
+  }
+  particleUpdate(particle) {
+    for (const absorber of this.array) {
+      absorber.attract(particle);
+      if (particle.destroyed) {
+        break;
+      }
+    }
+  }
+  removeAbsorber(absorber) {
+    const index = this.array.indexOf(absorber);
+    if (index >= 0) {
+      this.array.splice(index, 1);
+    }
+  }
+  resize() {
+    for (const absorber of this.array) {
+      absorber.resize();
+    }
+  }
+  stop() {
+    this.array = [];
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/index.js
+
+
+
+class AbsorbersPlugin {
+  constructor() {
+    this.id = "absorbers";
+  }
+  getPlugin(container) {
+    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) {
+      options.absorbers = (0,engine_root_window_.executeOnSingleOrMultiple)(source.absorbers, absorber => {
+        const tmp = new Absorber();
+        tmp.load(absorber);
+        return tmp;
+      });
+    }
+    options.interactivity.modes.absorbers = (0,engine_root_window_.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 => {
+      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) {
+      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) && (0,engine_root_window_.isInArray)("absorber", options.interactivity.events.onClick.mode)) {
+      return true;
+    }
+    return false;
+  }
+}
+async function loadAbsorbersPlugin(engine) {
+  const plugin = new AbsorbersPlugin();
+  await engine.addPlugin(plugin);
+}
+
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/tsparticles.plugin.absorbers.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see tsparticles.plugin.absorbers.min.js.LICENSE.txt */
+!function(i,t){if("object"==typeof exports&&"object"==typeof module)module.exports=t(require("@tsparticles/engine"));else if("function"==typeof define&&define.amd)define(["@tsparticles/engine"],t);else{var s="object"==typeof exports?t(require("@tsparticles/engine")):t(i.window);for(var o in s)("object"==typeof exports?exports:i)[o]=s[o]}}(this,(i=>(()=>{"use strict";var t={533:t=>{t.exports=i}},s={};function o(i){var e=s[i];if(void 0!==e)return e.exports;var r=s[i]={exports:{}};return t[i](r,r.exports,o),r.exports}o.d=(i,t)=>{for(var s in t)o.o(t,s)&&!o.o(i,s)&&Object.defineProperty(i,s,{enumerable:!0,get:t[s]})},o.o=(i,t)=>Object.prototype.hasOwnProperty.call(i,t),o.r=i=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(i,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(i,"__esModule",{value:!0})};var e={};return(()=>{o.r(e),o.d(e,{loadAbsorbersPlugin:()=>l});var i=o(533);class t{constructor(){this.radius=0,this.mass=0}load(i){i&&(void 0!==i.mass&&(this.mass=i.mass),void 0!==i.radius&&(this.radius=i.radius))}}class s extends i.ValueWithRandom{constructor(){super(),this.density=5,this.value=50,this.limit=new t}load(i){i&&(super.load(i),void 0!==i.density&&(this.density=i.density),"number"==typeof i.limit?this.limit.radius=i.limit:this.limit.load(i.limit))}}class r{constructor(){this.color=new i.OptionsColor,this.color.value="#000000",this.draggable=!1,this.opacity=1,this.destroy=!0,this.orbits=!1,this.size=new s}load(t){void 0!==t&&(void 0!==t.color&&(this.color=i.OptionsColor.create(this.color,t.color)),void 0!==t.draggable&&(this.draggable=t.draggable),this.name=t.name,void 0!==t.opacity&&(this.opacity=t.opacity),void 0!==t.position&&(this.position={},void 0!==t.position.x&&(this.position.x=(0,i.setRangeValue)(t.position.x)),void 0!==t.position.y&&(this.position.y=(0,i.setRangeValue)(t.position.y))),void 0!==t.size&&this.size.load(t.size),void 0!==t.destroy&&(this.destroy=t.destroy),void 0!==t.orbits&&(this.orbits=t.orbits))}}class n{constructor(t,s,o,e){var n,a,c;this.absorbers=t,this.container=s,this.initialPosition=e?i.Vector.create(e.x,e.y):void 0,o instanceof r?this.options=o:(this.options=new r,this.options.load(o)),this.dragging=!1,this.name=this.options.name,this.opacity=this.options.opacity,this.size=(0,i.getRangeValue)(this.options.size.value)*s.retina.pixelRatio,this.mass=this.size*this.options.size.density*s.retina.reduceFactor;const l=this.options.size.limit;this.limit={radius:l.radius*s.retina.pixelRatio*s.retina.reduceFactor,mass:l.mass},this.color=null!==(n=(0,i.rangeColorToRgb)(this.options.color))&&void 0!==n?n:{b:0,g:0,r:0},this.position=null!==(c=null===(a=this.initialPosition)||void 0===a?void 0:a.copy())&&void 0!==c?c:this.calcPosition()}attract(t){const s=this.container,o=this.options;if(o.draggable){const t=s.interactivity.mouse;if(t.clicking&&t.downPosition){(0,i.getDistance)(this.position,t.downPosition)<=this.size&&(this.dragging=!0)}else this.dragging=!1;this.dragging&&t.position&&(this.position.x=t.position.x,this.position.y=t.position.y)}const e=t.getPosition(),{dx:r,dy:n,distance:a}=(0,i.getDistances)(this.position,e),c=i.Vector.create(r,n);if(c.length=this.mass/Math.pow(a,2)*s.retina.reduceFactor,a<this.size+t.getRadius()){const i=.033*t.getRadius()*s.retina.pixelRatio;this.size>t.getRadius()&&a<this.size-t.getRadius()||void 0!==t.absorberOrbit&&t.absorberOrbit.length<0?o.destroy?t.destroy():(t.needsNewPosition=!0,this.updateParticlePosition(t,c)):(o.destroy&&(t.size.value-=i),this.updateParticlePosition(t,c)),(this.limit.radius<=0||this.size<this.limit.radius)&&(this.size+=i),(this.limit.mass<=0||this.mass<this.limit.mass)&&(this.mass+=i*this.options.size.density*s.retina.reduceFactor)}else this.updateParticlePosition(t,c)}draw(t){t.translate(this.position.x,this.position.y),t.beginPath(),t.arc(0,0,this.size,0,2*Math.PI,!1),t.closePath(),t.fillStyle=(0,i.getStyleFromRgb)(this.color,this.opacity),t.fill()}resize(){const t=this.initialPosition;this.position=t&&(0,i.isPointInside)(t,this.container.canvas.size,i.Vector.origin)?t:this.calcPosition()}calcPosition(){const t=(0,i.calcPositionOrRandomFromSizeRanged)({size:this.container.canvas.size,position:this.options.position});return i.Vector.create(t.x,t.y)}updateParticlePosition(t,s){var o;if(t.destroyed)return;const e=this.container,r=e.canvas.size;if(t.needsNewPosition){const s=(0,i.calcPositionOrRandomFromSize)({size:r});t.position.setTo(s),t.velocity.setTo(t.initialVelocity),t.absorberOrbit=void 0,t.needsNewPosition=!1}if(this.options.orbits){if(void 0===t.absorberOrbit&&(t.absorberOrbit=i.Vector.create(0,0),t.absorberOrbit.length=(0,i.getDistance)(t.getPosition(),this.position),t.absorberOrbit.angle=(0,i.getRandom)()*Math.PI*2),t.absorberOrbit.length<=this.size&&!this.options.destroy){const s=Math.min(r.width,r.height);t.absorberOrbit.length=s*(.2*(0,i.getRandom)()-.1+1)}void 0===t.absorberOrbitDirection&&(t.absorberOrbitDirection=t.velocity.x>=0?"clockwise":"counter-clockwise");const n=t.absorberOrbit.length,a=t.absorberOrbit.angle,c=t.absorberOrbitDirection;t.velocity.setTo(i.Vector.origin);const l={x:"clockwise"===c?Math.cos:Math.sin,y:"clockwise"===c?Math.sin:Math.cos};t.position.x=this.position.x+n*l.x(a),t.position.y=this.position.y+n*l.y(a),t.absorberOrbit.length-=s.length,t.absorberOrbit.angle+=(null!==(o=t.retina.moveSpeed)&&void 0!==o?o:0)*e.retina.pixelRatio/100*e.retina.reduceFactor}else{const o=i.Vector.origin;o.length=s.length,o.angle=s.angle,t.velocity.addTo(o)}}}class a{constructor(i){this.container=i,this.array=[],this.absorbers=[],this.interactivityAbsorbers=[],i.getAbsorber=i=>void 0===i||"number"==typeof i?this.array[i||0]:this.array.find((t=>t.name===i)),i.addAbsorber=(i,t)=>this.addAbsorber(i,t)}addAbsorber(i,t){const s=new n(this,this.container,i,t);return this.array.push(s),s}draw(i){for(const t of this.array)t.draw(i)}handleClickMode(t){const s=this.absorbers,o=this.interactivityAbsorbers;if("absorber"===t){const t=(0,i.itemFromSingleOrMultiple)(o),e=null!=t?t:(0,i.itemFromSingleOrMultiple)(s),r=this.container.interactivity.mouse.clickPosition;this.addAbsorber(e,r)}}async init(){this.absorbers=this.container.actualOptions.absorbers,this.interactivityAbsorbers=this.container.actualOptions.interactivity.modes.absorbers,(0,i.executeOnSingleOrMultiple)(this.absorbers,(i=>{this.addAbsorber(i)}))}particleUpdate(i){for(const t of this.array)if(t.attract(i),i.destroyed)break}removeAbsorber(i){const t=this.array.indexOf(i);t>=0&&this.array.splice(t,1)}resize(){for(const i of this.array)i.resize()}stop(){this.array=[]}}class c{constructor(){this.id="absorbers"}getPlugin(i){return new a(i)}loadOptions(t,s){var o,e;(this.needsPlugin(t)||this.needsPlugin(s))&&((null==s?void 0:s.absorbers)&&(t.absorbers=(0,i.executeOnSingleOrMultiple)(s.absorbers,(i=>{const t=new r;return t.load(i),t}))),t.interactivity.modes.absorbers=(0,i.executeOnSingleOrMultiple)(null===(e=null===(o=null==s?void 0:s.interactivity)||void 0===o?void 0:o.modes)||void 0===e?void 0:e.absorbers,(i=>{const t=new r;return t.load(i),t})))}needsPlugin(t){var s,o,e;if(!t)return!1;const r=t.absorbers;return r instanceof Array?!!r.length:!!r||!(!(null===(e=null===(o=null===(s=t.interactivity)||void 0===s?void 0:s.events)||void 0===o?void 0:o.onClick)||void 0===e?void 0:e.mode)||!(0,i.isInArray)("absorber",t.interactivity.events.onClick.mode))}}async function l(i){const t=new c;await i.addPlugin(t)}})(),e})()));

package/tsparticles.plugin.absorbers.min.js.LICENSE.txt

@@ -0,0 +1,8 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v3.0.0-alpha.0
+ */

package/types/AbsorberContainer.d.ts

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

package/types/AbsorberInstance.d.ts

@@ -0,0 +1,31 @@
+import type { Container, ICoordinates, IRgb, Particle, RecursivePartial } from "@tsparticles/engine";
+import { RotateDirection, Vector } from "@tsparticles/engine";
+import type { Absorbers } from "./Absorbers";
+import type { IAbsorber } from "./Options/Interfaces/IAbsorber";
+import type { IAbsorberSizeLimit } from "./Options/Interfaces/IAbsorberSizeLimit";
+type OrbitingParticle = Particle & {
+    absorberOrbit?: Vector;
+    absorberOrbitDirection?: RotateDirection;
+    needsNewPosition?: boolean;
+};
+export declare class AbsorberInstance {
+    private readonly absorbers;
+    private readonly container;
+    color: IRgb;
+    limit: IAbsorberSizeLimit;
+    mass: number;
+    readonly name?: string;
+    opacity: number;
+    position: Vector;
+    size: number;
+    private dragging;
+    private readonly initialPosition?;
+    private readonly options;
+    constructor(absorbers: Absorbers, container: Container, options: RecursivePartial<IAbsorber>, position?: ICoordinates);
+    attract(particle: OrbitingParticle): void;
+    draw(context: CanvasRenderingContext2D): void;
+    resize(): void;
+    private calcPosition;
+    private updateParticlePosition;
+}
+export {};

package/types/Absorbers.d.ts

@@ -0,0 +1,20 @@
+import type { IContainerPlugin, ICoordinates, Particle, RecursivePartial, SingleOrMultiple } from "@tsparticles/engine";
+import type { Absorber } from "./Options/Classes/Absorber";
+import type { AbsorberContainer } from "./AbsorberContainer";
+import { AbsorberInstance } from "./AbsorberInstance";
+import type { IAbsorber } from "./Options/Interfaces/IAbsorber";
+export declare class Absorbers implements IContainerPlugin {
+    private readonly container;
+    absorbers: SingleOrMultiple<Absorber>;
+    array: AbsorberInstance[];
+    interactivityAbsorbers: SingleOrMultiple<Absorber>;
+    constructor(container: AbsorberContainer);
+    addAbsorber(options: RecursivePartial<IAbsorber>, position?: ICoordinates): AbsorberInstance;
+    draw(context: CanvasRenderingContext2D): void;
+    handleClickMode(mode: string): void;
+    init(): Promise<void>;
+    particleUpdate(particle: Particle): void;
+    removeAbsorber(absorber: AbsorberInstance): void;
+    resize(): void;
+    stop(): void;
+}

package/types/Enums/AbsorberClickMode.d.ts

@@ -0,0 +1,3 @@
+export declare const enum AbsorberClickMode {
+    absorber = "absorber"
+}

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

@@ -0,0 +1,16 @@
+import type { IOptionLoader, IRangedCoordinates, RecursivePartial } from "@tsparticles/engine";
+import { OptionsColor } from "@tsparticles/engine";
+import { AbsorberSize } from "./AbsorberSize";
+import type { IAbsorber } from "../Interfaces/IAbsorber";
+export declare class Absorber implements IAbsorber, IOptionLoader<IAbsorber> {
+    color: OptionsColor;
+    destroy: boolean;
+    draggable: boolean;
+    name?: string;
+    opacity: number;
+    orbits: boolean;
+    position?: RecursivePartial<IRangedCoordinates>;
+    size: AbsorberSize;
+    constructor();
+    load(data?: RecursivePartial<IAbsorber>): void;
+}

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

@@ -0,0 +1,10 @@
+import type { IOptionLoader, RecursivePartial } from "@tsparticles/engine";
+import { AbsorberSizeLimit } from "./AbsorberSizeLimit";
+import type { IAbsorberSize } from "../Interfaces/IAbsorberSize";
+import { ValueWithRandom } from "@tsparticles/engine";
+export declare class AbsorberSize extends ValueWithRandom implements IAbsorberSize, IOptionLoader<IAbsorberSize> {
+    density: number;
+    limit: AbsorberSizeLimit;
+    constructor();
+    load(data?: RecursivePartial<IAbsorberSize>): void;
+}

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

@@ -0,0 +1,8 @@
+import type { IOptionLoader, RecursivePartial } from "@tsparticles/engine";
+import type { IAbsorberSizeLimit } from "../Interfaces/IAbsorberSizeLimit";
+export declare class AbsorberSizeLimit implements IAbsorberSizeLimit, IOptionLoader<IAbsorberSizeLimit> {
+    mass: number;
+    radius: number;
+    constructor();
+    load(data?: RecursivePartial<IAbsorberSizeLimit>): void;
+}

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

@@ -0,0 +1,12 @@
+import type { IOptionsColor, IRangedCoordinates, RecursivePartial } from "@tsparticles/engine";
+import type { IAbsorberSize } from "./IAbsorberSize";
+export interface IAbsorber {
+    color: string | IOptionsColor;
+    destroy: boolean;
+    draggable: boolean;
+    name?: string;
+    opacity: number;
+    orbits: boolean;
+    position?: RecursivePartial<IRangedCoordinates>;
+    size: IAbsorberSize;
+}

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

@@ -0,0 +1,6 @@
+import type { IAbsorberSizeLimit } from "./IAbsorberSizeLimit";
+import type { IValueWithRandom } from "@tsparticles/engine";
+export interface IAbsorberSize extends IValueWithRandom {
+    density: number;
+    limit?: number | IAbsorberSizeLimit;
+}

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

@@ -0,0 +1,4 @@
+export interface IAbsorberSizeLimit {
+    mass: number;
+    radius: number;
+}

package/types/index.d.ts

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

package/types/types.d.ts

@@ -0,0 +1,19 @@
+import type { IOptions, Options, SingleOrMultiple } from "@tsparticles/engine";
+import type { Absorber } from "./Options/Classes/Absorber";
+import type { IAbsorber } from "./Options/Interfaces/IAbsorber";
+export type AbsorberOptions = Options & {
+    absorbers: SingleOrMultiple<Absorber>;
+    interactivity: {
+        modes: {
+            absorbers: SingleOrMultiple<Absorber>;
+        };
+    };
+};
+export type IAbsorberOptions = IOptions & {
+    absorbers: SingleOrMultiple<IAbsorber>;
+    interactivity: {
+        modes: {
+            absorbers: SingleOrMultiple<IAbsorber>;
+        };
+    };
+};

package/umd/AbsorberContainer.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});