@tsparticles/interaction-external-attract 3.0.0-alpha.0

package/tsparticles.interaction.external.attract.js

@@ -0,0 +1,294 @@
+/*!
+ * 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__, {
+  "Attract": () => (/* reexport */ Attract),
+  "loadExternalAttractInteraction": () => (/* binding */ loadExternalAttractInteraction)
+});
+
+// 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/Attract.js
+class Attract {
+  constructor() {
+    this.distance = 200;
+    this.duration = 0.4;
+    this.easing = "ease-out-quad";
+    this.factor = 1;
+    this.maxSpeed = 50;
+    this.speed = 1;
+  }
+  load(data) {
+    if (!data) {
+      return;
+    }
+    if (data.distance !== undefined) {
+      this.distance = data.distance;
+    }
+    if (data.duration !== undefined) {
+      this.duration = data.duration;
+    }
+    if (data.easing !== undefined) {
+      this.easing = data.easing;
+    }
+    if (data.factor !== undefined) {
+      this.factor = data.factor;
+    }
+    if (data.maxSpeed !== undefined) {
+      this.maxSpeed = data.maxSpeed;
+    }
+    if (data.speed !== undefined) {
+      this.speed = data.speed;
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/Attractor.js
+
+
+class Attractor extends engine_root_window_.ExternalInteractorBase {
+  constructor(engine, container) {
+    super(container);
+    this._engine = engine;
+    if (!container.attract) {
+      container.attract = {
+        particles: []
+      };
+    }
+    this.handleClickMode = mode => {
+      const options = this.container.actualOptions,
+        attract = options.interactivity.modes.attract;
+      if (!attract || mode !== "attract") {
+        return;
+      }
+      if (!container.attract) {
+        container.attract = {
+          particles: []
+        };
+      }
+      container.attract.clicking = true;
+      container.attract.count = 0;
+      for (const particle of container.attract.particles) {
+        if (!this.isEnabled(particle)) {
+          continue;
+        }
+        particle.velocity.setTo(particle.initialVelocity);
+      }
+      container.attract.particles = [];
+      container.attract.finish = false;
+      setTimeout(() => {
+        if (!container.destroyed) {
+          if (!container.attract) {
+            container.attract = {
+              particles: []
+            };
+          }
+          container.attract.clicking = false;
+        }
+      }, attract.duration * 1000);
+    };
+  }
+  clear() {}
+  init() {
+    const container = this.container,
+      attract = container.actualOptions.interactivity.modes.attract;
+    if (!attract) {
+      return;
+    }
+    container.retina.attractModeDistance = attract.distance * container.retina.pixelRatio;
+  }
+  async interact() {
+    const container = this.container,
+      options = container.actualOptions,
+      mouseMoveStatus = container.interactivity.status === engine_root_window_.mouseMoveEvent,
+      events = options.interactivity.events,
+      hoverEnabled = events.onHover.enable,
+      hoverMode = events.onHover.mode,
+      clickEnabled = events.onClick.enable,
+      clickMode = events.onClick.mode;
+    if (mouseMoveStatus && hoverEnabled && (0,engine_root_window_.isInArray)("attract", hoverMode)) {
+      this.hoverAttract();
+    } else if (clickEnabled && (0,engine_root_window_.isInArray)("attract", clickMode)) {
+      this.clickAttract();
+    }
+  }
+  isEnabled(particle) {
+    var _a;
+    const container = this.container,
+      options = container.actualOptions,
+      mouse = container.interactivity.mouse,
+      events = ((_a = particle === null || particle === void 0 ? void 0 : particle.interactivity) !== null && _a !== void 0 ? _a : options.interactivity).events;
+    if ((!mouse.position || !events.onHover.enable) && (!mouse.clickPosition || !events.onClick.enable)) {
+      return false;
+    }
+    const hoverMode = events.onHover.mode,
+      clickMode = events.onClick.mode;
+    return (0,engine_root_window_.isInArray)("attract", hoverMode) || (0,engine_root_window_.isInArray)("attract", clickMode);
+  }
+  loadModeOptions(options, ...sources) {
+    if (!options.attract) {
+      options.attract = new Attract();
+    }
+    for (const source of sources) {
+      options.attract.load(source === null || source === void 0 ? void 0 : source.attract);
+    }
+  }
+  reset() {}
+  clickAttract() {
+    const container = this.container;
+    if (!container.attract) {
+      container.attract = {
+        particles: []
+      };
+    }
+    if (!container.attract.finish) {
+      if (!container.attract.count) {
+        container.attract.count = 0;
+      }
+      container.attract.count++;
+      if (container.attract.count === container.particles.count) {
+        container.attract.finish = true;
+      }
+    }
+    if (container.attract.clicking) {
+      const mousePos = container.interactivity.mouse.clickPosition,
+        attractRadius = container.retina.attractModeDistance;
+      if (!attractRadius || attractRadius < 0 || !mousePos) {
+        return;
+      }
+      this.processAttract(mousePos, attractRadius, new engine_root_window_.Circle(mousePos.x, mousePos.y, attractRadius));
+    } else if (container.attract.clicking === false) {
+      container.attract.particles = [];
+    }
+    return;
+  }
+  hoverAttract() {
+    const container = this.container,
+      mousePos = container.interactivity.mouse.position,
+      attractRadius = container.retina.attractModeDistance;
+    if (!attractRadius || attractRadius < 0 || !mousePos) {
+      return;
+    }
+    this.processAttract(mousePos, attractRadius, new engine_root_window_.Circle(mousePos.x, mousePos.y, attractRadius));
+  }
+  processAttract(position, attractRadius, area) {
+    const container = this.container,
+      attractOptions = container.actualOptions.interactivity.modes.attract;
+    if (!attractOptions) {
+      return;
+    }
+    const query = container.particles.quadTree.query(area, p => this.isEnabled(p));
+    for (const particle of query) {
+      const {
+        dx,
+        dy,
+        distance
+      } = (0,engine_root_window_.getDistances)(particle.position, position);
+      const velocity = attractOptions.speed * attractOptions.factor;
+      const attractFactor = (0,engine_root_window_.clamp)((0,engine_root_window_.getEasing)(attractOptions.easing)(1 - distance / attractRadius) * velocity, 0, attractOptions.maxSpeed);
+      const normVec = engine_root_window_.Vector.create(distance === 0 ? velocity : dx / distance * attractFactor, distance === 0 ? velocity : dy / distance * attractFactor);
+      particle.position.subFrom(normVec);
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/index.js
+
+async function loadExternalAttractInteraction(engine) {
+  await engine.addInteractor("externalAttract", container => new Attractor(engine, container));
+}
+
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/tsparticles.interaction.external.attract.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see tsparticles.interaction.external.attract.min.js.LICENSE.txt */
+!function(t,e){if("object"==typeof exports&&"object"==typeof module)module.exports=e(require("@tsparticles/engine"));else if("function"==typeof define&&define.amd)define(["@tsparticles/engine"],e);else{var a="object"==typeof exports?e(require("@tsparticles/engine")):e(t.window);for(var i in a)("object"==typeof exports?exports:t)[i]=a[i]}}(this,(t=>(()=>{"use strict";var e={533:e=>{e.exports=t}},a={};function i(t){var r=a[t];if(void 0!==r)return r.exports;var c=a[t]={exports:{}};return e[t](c,c.exports,i),c.exports}i.d=(t,e)=>{for(var a in e)i.o(e,a)&&!i.o(t,a)&&Object.defineProperty(t,a,{enumerable:!0,get:e[a]})},i.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),i.r=t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})};var r={};return(()=>{i.r(r),i.d(r,{Attract:()=>e,loadExternalAttractInteraction:()=>c});var t=i(533);class e{constructor(){this.distance=200,this.duration=.4,this.easing="ease-out-quad",this.factor=1,this.maxSpeed=50,this.speed=1}load(t){t&&(void 0!==t.distance&&(this.distance=t.distance),void 0!==t.duration&&(this.duration=t.duration),void 0!==t.easing&&(this.easing=t.easing),void 0!==t.factor&&(this.factor=t.factor),void 0!==t.maxSpeed&&(this.maxSpeed=t.maxSpeed),void 0!==t.speed&&(this.speed=t.speed))}}class a extends t.ExternalInteractorBase{constructor(t,e){super(e),this._engine=t,e.attract||(e.attract={particles:[]}),this.handleClickMode=t=>{const a=this.container.actualOptions.interactivity.modes.attract;if(a&&"attract"===t){e.attract||(e.attract={particles:[]}),e.attract.clicking=!0,e.attract.count=0;for(const t of e.attract.particles)this.isEnabled(t)&&t.velocity.setTo(t.initialVelocity);e.attract.particles=[],e.attract.finish=!1,setTimeout((()=>{e.destroyed||(e.attract||(e.attract={particles:[]}),e.attract.clicking=!1)}),1e3*a.duration)}}}clear(){}init(){const t=this.container,e=t.actualOptions.interactivity.modes.attract;e&&(t.retina.attractModeDistance=e.distance*t.retina.pixelRatio)}async interact(){const e=this.container,a=e.actualOptions,i=e.interactivity.status===t.mouseMoveEvent,r=a.interactivity.events,c=r.onHover.enable,n=r.onHover.mode,o=r.onClick.enable,s=r.onClick.mode;i&&c&&(0,t.isInArray)("attract",n)?this.hoverAttract():o&&(0,t.isInArray)("attract",s)&&this.clickAttract()}isEnabled(e){var a;const i=this.container,r=i.actualOptions,c=i.interactivity.mouse,n=(null!==(a=null==e?void 0:e.interactivity)&&void 0!==a?a:r.interactivity).events;if(!(c.position&&n.onHover.enable||c.clickPosition&&n.onClick.enable))return!1;const o=n.onHover.mode,s=n.onClick.mode;return(0,t.isInArray)("attract",o)||(0,t.isInArray)("attract",s)}loadModeOptions(t,...a){t.attract||(t.attract=new e);for(const e of a)t.attract.load(null==e?void 0:e.attract)}reset(){}clickAttract(){const e=this.container;if(e.attract||(e.attract={particles:[]}),e.attract.finish||(e.attract.count||(e.attract.count=0),e.attract.count++,e.attract.count===e.particles.count&&(e.attract.finish=!0)),e.attract.clicking){const a=e.interactivity.mouse.clickPosition,i=e.retina.attractModeDistance;if(!i||i<0||!a)return;this.processAttract(a,i,new t.Circle(a.x,a.y,i))}else!1===e.attract.clicking&&(e.attract.particles=[])}hoverAttract(){const e=this.container,a=e.interactivity.mouse.position,i=e.retina.attractModeDistance;!i||i<0||!a||this.processAttract(a,i,new t.Circle(a.x,a.y,i))}processAttract(e,a,i){const r=this.container,c=r.actualOptions.interactivity.modes.attract;if(!c)return;const n=r.particles.quadTree.query(i,(t=>this.isEnabled(t)));for(const i of n){const{dx:r,dy:n,distance:o}=(0,t.getDistances)(i.position,e),s=c.speed*c.factor,d=(0,t.clamp)((0,t.getEasing)(c.easing)(1-o/a)*s,0,c.maxSpeed),l=t.Vector.create(0===o?s:r/o*d,0===o?s:n/o*d);i.position.subFrom(l)}}}async function c(t){await t.addInteractor("externalAttract",(e=>new a(t,e)))}})(),r})()));

package/tsparticles.interaction.external.attract.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/Attractor.d.ts

@@ -0,0 +1,17 @@
+import type { AttractContainer, AttractMode, IAttractMode } from "./Types";
+import { ExternalInteractorBase } from "@tsparticles/engine";
+import type { Engine, IModes, Modes, Particle, RecursivePartial } from "@tsparticles/engine";
+export declare class Attractor extends ExternalInteractorBase<AttractContainer> {
+    handleClickMode: (mode: string) => void;
+    private readonly _engine;
+    constructor(engine: Engine, container: AttractContainer);
+    clear(): void;
+    init(): void;
+    interact(): Promise<void>;
+    isEnabled(particle?: Particle): boolean;
+    loadModeOptions(options: Modes & AttractMode, ...sources: RecursivePartial<(IModes & IAttractMode) | undefined>[]): void;
+    reset(): void;
+    private clickAttract;
+    private hoverAttract;
+    private processAttract;
+}

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

@@ -0,0 +1,13 @@
+import type { EasingTypeAlt, IOptionLoader, RecursivePartial } from "@tsparticles/engine";
+import { EasingType } from "@tsparticles/engine";
+import type { IAttract } from "../Interfaces/IAttract";
+export declare class Attract implements IAttract, IOptionLoader<IAttract> {
+    distance: number;
+    duration: number;
+    easing: EasingType | EasingTypeAlt;
+    factor: number;
+    maxSpeed: number;
+    speed: number;
+    constructor();
+    load(data?: RecursivePartial<IAttract>): void;
+}

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

@@ -0,0 +1,7 @@
+import type { AttractMode } from "../../Types";
+import type { Options } from "@tsparticles/engine";
+export type AttractOptions = Options & {
+    interactivity: {
+        modes: AttractMode;
+    };
+};

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

@@ -0,0 +1,9 @@
+import type { EasingType, EasingTypeAlt } from "@tsparticles/engine";
+export interface IAttract {
+    distance: number;
+    duration: number;
+    easing: EasingType | EasingTypeAlt;
+    factor: number;
+    maxSpeed: number;
+    speed: number;
+}

package/types/Types.d.ts

@@ -0,0 +1,24 @@
+import type { Container, Particle } from "@tsparticles/engine";
+import type { Attract } from "./Options/Classes/Attract";
+import type { AttractOptions } from "./Options/Classes/AttractOptions";
+import type { IAttract } from "./Options/Interfaces/IAttract";
+export type IAttractMode = {
+    attract: IAttract;
+};
+export type AttractMode = {
+    attract?: Attract;
+};
+interface IContainerAttract {
+    clicking?: boolean;
+    count?: number;
+    finish?: boolean;
+    particles: Particle[];
+}
+export type AttractContainer = Container & {
+    actualOptions: AttractOptions;
+    attract?: IContainerAttract;
+    retina: {
+        attractModeDistance?: number;
+    };
+};
+export {};

package/types/index.d.ts

@@ -0,0 +1,4 @@
+import type { Engine } from "@tsparticles/engine";
+export declare function loadExternalAttractInteraction(engine: Engine): Promise<void>;
+export * from "./Options/Classes/Attract";
+export * from "./Options/Interfaces/IAttract";

package/umd/Attractor.js

@@ -0,0 +1,136 @@
+(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", "@tsparticles/engine", "./Options/Classes/Attract"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Attractor = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const Attract_1 = require("./Options/Classes/Attract");
+    class Attractor extends engine_1.ExternalInteractorBase {
+        constructor(engine, container) {
+            super(container);
+            this._engine = engine;
+            if (!container.attract) {
+                container.attract = { particles: [] };
+            }
+            this.handleClickMode = (mode) => {
+                const options = this.container.actualOptions, attract = options.interactivity.modes.attract;
+                if (!attract || mode !== "attract") {
+                    return;
+                }
+                if (!container.attract) {
+                    container.attract = { particles: [] };
+                }
+                container.attract.clicking = true;
+                container.attract.count = 0;
+                for (const particle of container.attract.particles) {
+                    if (!this.isEnabled(particle)) {
+                        continue;
+                    }
+                    particle.velocity.setTo(particle.initialVelocity);
+                }
+                container.attract.particles = [];
+                container.attract.finish = false;
+                setTimeout(() => {
+                    if (!container.destroyed) {
+                        if (!container.attract) {
+                            container.attract = { particles: [] };
+                        }
+                        container.attract.clicking = false;
+                    }
+                }, attract.duration * 1000);
+            };
+        }
+        clear() {
+        }
+        init() {
+            const container = this.container, attract = container.actualOptions.interactivity.modes.attract;
+            if (!attract) {
+                return;
+            }
+            container.retina.attractModeDistance = attract.distance * container.retina.pixelRatio;
+        }
+        async interact() {
+            const container = this.container, options = container.actualOptions, mouseMoveStatus = container.interactivity.status === engine_1.mouseMoveEvent, events = options.interactivity.events, hoverEnabled = events.onHover.enable, hoverMode = events.onHover.mode, clickEnabled = events.onClick.enable, clickMode = events.onClick.mode;
+            if (mouseMoveStatus && hoverEnabled && (0, engine_1.isInArray)("attract", hoverMode)) {
+                this.hoverAttract();
+            }
+            else if (clickEnabled && (0, engine_1.isInArray)("attract", clickMode)) {
+                this.clickAttract();
+            }
+        }
+        isEnabled(particle) {
+            var _a;
+            const container = this.container, options = container.actualOptions, mouse = container.interactivity.mouse, events = ((_a = particle === null || particle === void 0 ? void 0 : particle.interactivity) !== null && _a !== void 0 ? _a : options.interactivity).events;
+            if ((!mouse.position || !events.onHover.enable) && (!mouse.clickPosition || !events.onClick.enable)) {
+                return false;
+            }
+            const hoverMode = events.onHover.mode, clickMode = events.onClick.mode;
+            return (0, engine_1.isInArray)("attract", hoverMode) || (0, engine_1.isInArray)("attract", clickMode);
+        }
+        loadModeOptions(options, ...sources) {
+            if (!options.attract) {
+                options.attract = new Attract_1.Attract();
+            }
+            for (const source of sources) {
+                options.attract.load(source === null || source === void 0 ? void 0 : source.attract);
+            }
+        }
+        reset() {
+        }
+        clickAttract() {
+            const container = this.container;
+            if (!container.attract) {
+                container.attract = { particles: [] };
+            }
+            if (!container.attract.finish) {
+                if (!container.attract.count) {
+                    container.attract.count = 0;
+                }
+                container.attract.count++;
+                if (container.attract.count === container.particles.count) {
+                    container.attract.finish = true;
+                }
+            }
+            if (container.attract.clicking) {
+                const mousePos = container.interactivity.mouse.clickPosition, attractRadius = container.retina.attractModeDistance;
+                if (!attractRadius || attractRadius < 0 || !mousePos) {
+                    return;
+                }
+                this.processAttract(mousePos, attractRadius, new engine_1.Circle(mousePos.x, mousePos.y, attractRadius));
+            }
+            else if (container.attract.clicking === false) {
+                container.attract.particles = [];
+            }
+            return;
+        }
+        hoverAttract() {
+            const container = this.container, mousePos = container.interactivity.mouse.position, attractRadius = container.retina.attractModeDistance;
+            if (!attractRadius || attractRadius < 0 || !mousePos) {
+                return;
+            }
+            this.processAttract(mousePos, attractRadius, new engine_1.Circle(mousePos.x, mousePos.y, attractRadius));
+        }
+        processAttract(position, attractRadius, area) {
+            const container = this.container, attractOptions = container.actualOptions.interactivity.modes.attract;
+            if (!attractOptions) {
+                return;
+            }
+            const query = container.particles.quadTree.query(area, (p) => this.isEnabled(p));
+            for (const particle of query) {
+                const { dx, dy, distance } = (0, engine_1.getDistances)(particle.position, position);
+                const velocity = attractOptions.speed * attractOptions.factor;
+                const attractFactor = (0, engine_1.clamp)((0, engine_1.getEasing)(attractOptions.easing)(1 - distance / attractRadius) * velocity, 0, attractOptions.maxSpeed);
+                const normVec = engine_1.Vector.create(distance === 0 ? velocity : (dx / distance) * attractFactor, distance === 0 ? velocity : (dy / distance) * attractFactor);
+                particle.position.subFrom(normVec);
+            }
+        }
+    }
+    exports.Attractor = Attractor;
+});

package/umd/Options/Classes/Attract.js

@@ -0,0 +1,47 @@
+(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 });
+    exports.Attract = void 0;
+    class Attract {
+        constructor() {
+            this.distance = 200;
+            this.duration = 0.4;
+            this.easing = "ease-out-quad";
+            this.factor = 1;
+            this.maxSpeed = 50;
+            this.speed = 1;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.distance !== undefined) {
+                this.distance = data.distance;
+            }
+            if (data.duration !== undefined) {
+                this.duration = data.duration;
+            }
+            if (data.easing !== undefined) {
+                this.easing = data.easing;
+            }
+            if (data.factor !== undefined) {
+                this.factor = data.factor;
+            }
+            if (data.maxSpeed !== undefined) {
+                this.maxSpeed = data.maxSpeed;
+            }
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+        }
+    }
+    exports.Attract = Attract;
+});

package/umd/Options/Classes/AttractOptions.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 });
+});

package/umd/Options/Interfaces/IAttract.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 });
+});

package/umd/Types.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 });
+});

package/umd/index.js

@@ -0,0 +1,34 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(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", "./Attractor", "./Options/Classes/Attract", "./Options/Interfaces/IAttract"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadExternalAttractInteraction = void 0;
+    const Attractor_1 = require("./Attractor");
+    async function loadExternalAttractInteraction(engine) {
+        await engine.addInteractor("externalAttract", (container) => new Attractor_1.Attractor(engine, container));
+    }
+    exports.loadExternalAttractInteraction = loadExternalAttractInteraction;
+    __exportStar(require("./Options/Classes/Attract"), exports);
+    __exportStar(require("./Options/Interfaces/IAttract"), exports);
+});