@tsparticles/move-base 3.0.0-alpha.0

package/tsparticles.move.base.js

@@ -0,0 +1,287 @@
+/*!
+ * 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__, {
+  "loadBaseMover": () => (/* binding */ loadBaseMover)
+});
+
+// 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/Utils.js
+
+function applyDistance(particle) {
+  const initialPosition = particle.initialPosition,
+    {
+      dx,
+      dy
+    } = (0,engine_root_window_.getDistances)(initialPosition, particle.position),
+    dxFixed = Math.abs(dx),
+    dyFixed = Math.abs(dy),
+    hDistance = particle.retina.maxDistance.horizontal,
+    vDistance = particle.retina.maxDistance.vertical;
+  if (!hDistance && !vDistance) {
+    return;
+  }
+  if ((hDistance && dxFixed >= hDistance || vDistance && dyFixed >= vDistance) && !particle.misplaced) {
+    particle.misplaced = !!hDistance && dxFixed > hDistance || !!vDistance && dyFixed > vDistance;
+    if (hDistance) {
+      particle.velocity.x = particle.velocity.y / 2 - particle.velocity.x;
+    }
+    if (vDistance) {
+      particle.velocity.y = particle.velocity.x / 2 - particle.velocity.y;
+    }
+  } else if ((!hDistance || dxFixed < hDistance) && (!vDistance || dyFixed < vDistance) && particle.misplaced) {
+    particle.misplaced = false;
+  } else if (particle.misplaced) {
+    const pos = particle.position,
+      vel = particle.velocity;
+    if (hDistance && (pos.x < initialPosition.x && vel.x < 0 || pos.x > initialPosition.x && vel.x > 0)) {
+      vel.x *= -(0,engine_root_window_.getRandom)();
+    }
+    if (vDistance && (pos.y < initialPosition.y && vel.y < 0 || pos.y > initialPosition.y && vel.y > 0)) {
+      vel.y *= -(0,engine_root_window_.getRandom)();
+    }
+  }
+}
+function spin(particle, moveSpeed) {
+  const container = particle.container;
+  if (!particle.spin) {
+    return;
+  }
+  const updateFunc = {
+    x: particle.spin.direction === "clockwise" ? Math.cos : Math.sin,
+    y: particle.spin.direction === "clockwise" ? Math.sin : Math.cos
+  };
+  particle.position.x = particle.spin.center.x + particle.spin.radius * updateFunc.x(particle.spin.angle);
+  particle.position.y = particle.spin.center.y + particle.spin.radius * updateFunc.y(particle.spin.angle);
+  particle.spin.radius += particle.spin.acceleration;
+  const maxCanvasSize = Math.max(container.canvas.size.width, container.canvas.size.height);
+  if (particle.spin.radius > maxCanvasSize / 2) {
+    particle.spin.radius = maxCanvasSize / 2;
+    particle.spin.acceleration *= -1;
+  } else if (particle.spin.radius < 0) {
+    particle.spin.radius = 0;
+    particle.spin.acceleration *= -1;
+  }
+  particle.spin.angle += moveSpeed / 100 * (1 - particle.spin.radius / maxCanvasSize);
+}
+function applyPath(particle, delta) {
+  var _a;
+  const particlesOptions = particle.options,
+    pathOptions = particlesOptions.move.path,
+    pathEnabled = pathOptions.enable;
+  if (!pathEnabled) {
+    return;
+  }
+  if (particle.lastPathTime <= particle.pathDelay) {
+    particle.lastPathTime += delta.value;
+    return;
+  }
+  const path = (_a = particle.pathGenerator) === null || _a === void 0 ? void 0 : _a.generate(particle);
+  if (path) {
+    particle.velocity.addTo(path);
+  }
+  if (pathOptions.clamp) {
+    particle.velocity.x = (0,engine_root_window_.clamp)(particle.velocity.x, -1, 1);
+    particle.velocity.y = (0,engine_root_window_.clamp)(particle.velocity.y, -1, 1);
+  }
+  particle.lastPathTime -= particle.pathDelay;
+}
+function getProximitySpeedFactor(particle) {
+  return particle.slow.inRange ? particle.slow.factor : 1;
+}
+;// CONCATENATED MODULE: ./dist/browser/BaseMover.js
+
+
+class BaseMover {
+  init(particle) {
+    var _a;
+    const container = particle.container,
+      options = particle.options,
+      gravityOptions = options.move.gravity,
+      spinOptions = options.move.spin;
+    particle.gravity = {
+      enable: gravityOptions.enable,
+      acceleration: (0,engine_root_window_.getRangeValue)(gravityOptions.acceleration),
+      inverse: gravityOptions.inverse
+    };
+    if (spinOptions.enable) {
+      const spinPos = (_a = spinOptions.position) !== null && _a !== void 0 ? _a : {
+          x: 50,
+          y: 50
+        },
+        spinCenter = {
+          x: spinPos.x / 100 * container.canvas.size.width,
+          y: spinPos.y / 100 * container.canvas.size.height
+        },
+        pos = particle.getPosition(),
+        distance = (0,engine_root_window_.getDistance)(pos, spinCenter),
+        spinAcceleration = (0,engine_root_window_.getRangeValue)(spinOptions.acceleration);
+      particle.retina.spinAcceleration = spinAcceleration * container.retina.pixelRatio;
+      particle.spin = {
+        center: spinCenter,
+        direction: particle.velocity.x >= 0 ? "clockwise" : "counter-clockwise",
+        angle: particle.velocity.angle,
+        radius: distance,
+        acceleration: particle.retina.spinAcceleration
+      };
+    }
+  }
+  isEnabled(particle) {
+    return !particle.destroyed && particle.options.move.enable;
+  }
+  move(particle, delta) {
+    var _a, _b, _c;
+    var _d, _e;
+    const particleOptions = particle.options,
+      moveOptions = particleOptions.move;
+    if (!moveOptions.enable) {
+      return;
+    }
+    const container = particle.container,
+      slowFactor = getProximitySpeedFactor(particle),
+      baseSpeed = ((_a = (_d = particle.retina).moveSpeed) !== null && _a !== void 0 ? _a : _d.moveSpeed = (0,engine_root_window_.getRangeValue)(moveOptions.speed) * container.retina.pixelRatio) * container.retina.reduceFactor,
+      moveDrift = (_b = (_e = particle.retina).moveDrift) !== null && _b !== void 0 ? _b : _e.moveDrift = (0,engine_root_window_.getRangeValue)(particle.options.move.drift) * container.retina.pixelRatio,
+      maxSize = (0,engine_root_window_.getRangeMax)(particleOptions.size.value) * container.retina.pixelRatio,
+      sizeFactor = moveOptions.size ? particle.getRadius() / maxSize : 1,
+      speedFactor = sizeFactor * slowFactor * (delta.factor || 1),
+      diffFactor = 2,
+      moveSpeed = baseSpeed * speedFactor / diffFactor;
+    if (moveOptions.spin.enable) {
+      spin(particle, moveSpeed);
+    } else {
+      applyPath(particle, delta);
+      const gravityOptions = particle.gravity,
+        gravityFactor = (gravityOptions === null || gravityOptions === void 0 ? void 0 : gravityOptions.enable) && gravityOptions.inverse ? -1 : 1;
+      if ((gravityOptions === null || gravityOptions === void 0 ? void 0 : gravityOptions.enable) && moveSpeed) {
+        particle.velocity.y += gravityFactor * (gravityOptions.acceleration * delta.factor) / (60 * moveSpeed);
+      }
+      if (moveDrift && moveSpeed) {
+        particle.velocity.x += moveDrift * delta.factor / (60 * moveSpeed);
+      }
+      const decay = particle.moveDecay;
+      if (decay != 1) {
+        particle.velocity.multTo(decay);
+      }
+      const velocity = particle.velocity.mult(moveSpeed),
+        maxSpeed = (_c = particle.retina.maxSpeed) !== null && _c !== void 0 ? _c : container.retina.maxSpeed;
+      if ((gravityOptions === null || gravityOptions === void 0 ? void 0 : gravityOptions.enable) && maxSpeed > 0 && (!gravityOptions.inverse && velocity.y >= 0 && velocity.y >= maxSpeed || gravityOptions.inverse && velocity.y <= 0 && velocity.y <= -maxSpeed)) {
+        velocity.y = gravityFactor * maxSpeed;
+        if (moveSpeed) {
+          particle.velocity.y = velocity.y / moveSpeed;
+        }
+      }
+      const zIndexOptions = particle.options.zIndex,
+        zVelocityFactor = (1 - particle.zIndexFactor) ** zIndexOptions.velocityRate;
+      if (zVelocityFactor != 1) {
+        velocity.multTo(zVelocityFactor);
+      }
+      particle.position.addTo(velocity);
+      if (moveOptions.vibrate) {
+        particle.position.x += Math.sin(particle.position.x * Math.cos(particle.position.y));
+        particle.position.y += Math.cos(particle.position.y * Math.sin(particle.position.x));
+      }
+    }
+    applyDistance(particle);
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/index.js
+
+async function loadBaseMover(engine) {
+  engine.addMover("base", () => new BaseMover());
+}
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/tsparticles.move.base.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see tsparticles.move.base.min.js.LICENSE.txt */
+!function(e,i){if("object"==typeof exports&&"object"==typeof module)module.exports=i(require("@tsparticles/engine"));else if("function"==typeof define&&define.amd)define(["@tsparticles/engine"],i);else{var t="object"==typeof exports?i(require("@tsparticles/engine")):i(e.window);for(var n in t)("object"==typeof exports?exports:e)[n]=t[n]}}(this,(e=>(()=>{"use strict";var i={533:i=>{i.exports=e}},t={};function n(e){var o=t[e];if(void 0!==o)return o.exports;var a=t[e]={exports:{}};return i[e](a,a.exports,n),a.exports}n.d=(e,i)=>{for(var t in i)n.o(i,t)&&!n.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:i[t]})},n.o=(e,i)=>Object.prototype.hasOwnProperty.call(e,i),n.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var o={};return(()=>{n.r(o),n.d(o,{loadBaseMover:()=>t});var e=n(533);class i{init(i){var t;const n=i.container,o=i.options,a=o.move.gravity,s=o.move.spin;if(i.gravity={enable:a.enable,acceleration:(0,e.getRangeValue)(a.acceleration),inverse:a.inverse},s.enable){const o=null!==(t=s.position)&&void 0!==t?t:{x:50,y:50},a={x:o.x/100*n.canvas.size.width,y:o.y/100*n.canvas.size.height},r=i.getPosition(),c=(0,e.getDistance)(r,a),l=(0,e.getRangeValue)(s.acceleration);i.retina.spinAcceleration=l*n.retina.pixelRatio,i.spin={center:a,direction:i.velocity.x>=0?"clockwise":"counter-clockwise",angle:i.velocity.angle,radius:c,acceleration:i.retina.spinAcceleration}}}isEnabled(e){return!e.destroyed&&e.options.move.enable}move(i,t){var n,o,a,s,r;const c=i.options,l=c.move;if(!l.enable)return;const p=i.container,v=function(e){return e.slow.inRange?e.slow.factor:1}(i),y=(null!==(n=(s=i.retina).moveSpeed)&&void 0!==n?n:s.moveSpeed=(0,e.getRangeValue)(l.speed)*p.retina.pixelRatio)*p.retina.reduceFactor,d=null!==(o=(r=i.retina).moveDrift)&&void 0!==o?o:r.moveDrift=(0,e.getRangeValue)(i.options.move.drift)*p.retina.pixelRatio,u=(0,e.getRangeMax)(c.size.value)*p.retina.pixelRatio,x=y*((l.size?i.getRadius()/u:1)*v*(t.factor||1))/2;if(l.spin.enable)!function(e,i){const t=e.container;if(!e.spin)return;const n={x:"clockwise"===e.spin.direction?Math.cos:Math.sin,y:"clockwise"===e.spin.direction?Math.sin:Math.cos};e.position.x=e.spin.center.x+e.spin.radius*n.x(e.spin.angle),e.position.y=e.spin.center.y+e.spin.radius*n.y(e.spin.angle),e.spin.radius+=e.spin.acceleration;const o=Math.max(t.canvas.size.width,t.canvas.size.height);e.spin.radius>o/2?(e.spin.radius=o/2,e.spin.acceleration*=-1):e.spin.radius<0&&(e.spin.radius=0,e.spin.acceleration*=-1),e.spin.angle+=i/100*(1-e.spin.radius/o)}(i,x);else{!function(i,t){var n;const o=i.options.move.path;if(!o.enable)return;if(i.lastPathTime<=i.pathDelay)return void(i.lastPathTime+=t.value);const a=null===(n=i.pathGenerator)||void 0===n?void 0:n.generate(i);a&&i.velocity.addTo(a),o.clamp&&(i.velocity.x=(0,e.clamp)(i.velocity.x,-1,1),i.velocity.y=(0,e.clamp)(i.velocity.y,-1,1)),i.lastPathTime-=i.pathDelay}(i,t);const n=i.gravity,o=(null==n?void 0:n.enable)&&n.inverse?-1:1;(null==n?void 0:n.enable)&&x&&(i.velocity.y+=o*(n.acceleration*t.factor)/(60*x)),d&&x&&(i.velocity.x+=d*t.factor/(60*x));const s=i.moveDecay;1!=s&&i.velocity.multTo(s);const r=i.velocity.mult(x),c=null!==(a=i.retina.maxSpeed)&&void 0!==a?a:p.retina.maxSpeed;(null==n?void 0:n.enable)&&c>0&&(!n.inverse&&r.y>=0&&r.y>=c||n.inverse&&r.y<=0&&r.y<=-c)&&(r.y=o*c,x&&(i.velocity.y=r.y/x));const v=i.options.zIndex,y=(1-i.zIndexFactor)**v.velocityRate;1!=y&&r.multTo(y),i.position.addTo(r),l.vibrate&&(i.position.x+=Math.sin(i.position.x*Math.cos(i.position.y)),i.position.y+=Math.cos(i.position.y*Math.sin(i.position.x)))}!function(i){const t=i.initialPosition,{dx:n,dy:o}=(0,e.getDistances)(t,i.position),a=Math.abs(n),s=Math.abs(o),r=i.retina.maxDistance.horizontal,c=i.retina.maxDistance.vertical;if(r||c)if((r&&a>=r||c&&s>=c)&&!i.misplaced)i.misplaced=!!r&&a>r||!!c&&s>c,r&&(i.velocity.x=i.velocity.y/2-i.velocity.x),c&&(i.velocity.y=i.velocity.x/2-i.velocity.y);else if((!r||a<r)&&(!c||s<c)&&i.misplaced)i.misplaced=!1;else if(i.misplaced){const n=i.position,o=i.velocity;r&&(n.x<t.x&&o.x<0||n.x>t.x&&o.x>0)&&(o.x*=-(0,e.getRandom)()),c&&(n.y<t.y&&o.y<0||n.y>t.y&&o.y>0)&&(o.y*=-(0,e.getRandom)())}}(i)}}async function t(e){e.addMover("base",(()=>new i))}})(),o})()));

package/tsparticles.move.base.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/BaseMover.d.ts

@@ -0,0 +1,7 @@
+import type { IDelta, IParticleMover, Particle } from "@tsparticles/engine";
+import type { MoveParticle } from "./Types";
+export declare class BaseMover implements IParticleMover {
+    init(particle: MoveParticle): void;
+    isEnabled(particle: Particle): boolean;
+    move(particle: MoveParticle, delta: IDelta): void;
+}

package/types/IParticleGravity.d.ts

@@ -0,0 +1,5 @@
+export interface IParticleGravity {
+    acceleration: number;
+    enable: boolean;
+    inverse: boolean;
+}

package/types/IParticleSpin.d.ts

@@ -0,0 +1,8 @@
+import type { ICoordinates, RotateDirection } from "@tsparticles/engine";
+export interface IParticleSpin {
+    acceleration: number;
+    angle: number;
+    center: ICoordinates;
+    direction: RotateDirection;
+    radius: number;
+}

package/types/Types.d.ts

@@ -0,0 +1,10 @@
+import type { IParticleGravity } from "./IParticleGravity";
+import type { IParticleSpin } from "./IParticleSpin";
+import type { Particle } from "@tsparticles/engine";
+export type MoveParticle = Particle & {
+    gravity?: IParticleGravity;
+    retina: {
+        spinAcceleration?: number;
+    };
+    spin?: IParticleSpin;
+};

package/types/Utils.d.ts

@@ -0,0 +1,6 @@
+import type { IDelta, Particle } from "@tsparticles/engine";
+import type { MoveParticle } from "./Types";
+export declare function applyDistance(particle: MoveParticle): void;
+export declare function spin(particle: MoveParticle, moveSpeed: number): void;
+export declare function applyPath(particle: Particle, delta: IDelta): void;
+export declare function getProximitySpeedFactor(particle: Particle): number;

package/types/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "@tsparticles/engine";
+export declare function loadBaseMover(engine: Engine): Promise<void>;

package/umd/BaseMover.js

@@ -0,0 +1,92 @@
+(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", "./Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BaseMover = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const Utils_1 = require("./Utils");
+    class BaseMover {
+        init(particle) {
+            var _a;
+            const container = particle.container, options = particle.options, gravityOptions = options.move.gravity, spinOptions = options.move.spin;
+            particle.gravity = {
+                enable: gravityOptions.enable,
+                acceleration: (0, engine_1.getRangeValue)(gravityOptions.acceleration),
+                inverse: gravityOptions.inverse,
+            };
+            if (spinOptions.enable) {
+                const spinPos = (_a = spinOptions.position) !== null && _a !== void 0 ? _a : { x: 50, y: 50 }, spinCenter = {
+                    x: (spinPos.x / 100) * container.canvas.size.width,
+                    y: (spinPos.y / 100) * container.canvas.size.height,
+                }, pos = particle.getPosition(), distance = (0, engine_1.getDistance)(pos, spinCenter), spinAcceleration = (0, engine_1.getRangeValue)(spinOptions.acceleration);
+                particle.retina.spinAcceleration = spinAcceleration * container.retina.pixelRatio;
+                particle.spin = {
+                    center: spinCenter,
+                    direction: particle.velocity.x >= 0 ? "clockwise" : "counter-clockwise",
+                    angle: particle.velocity.angle,
+                    radius: distance,
+                    acceleration: particle.retina.spinAcceleration,
+                };
+            }
+        }
+        isEnabled(particle) {
+            return !particle.destroyed && particle.options.move.enable;
+        }
+        move(particle, delta) {
+            var _a, _b, _c;
+            var _d, _e;
+            const particleOptions = particle.options, moveOptions = particleOptions.move;
+            if (!moveOptions.enable) {
+                return;
+            }
+            const container = particle.container, slowFactor = (0, Utils_1.getProximitySpeedFactor)(particle), baseSpeed = ((_a = (_d = particle.retina).moveSpeed) !== null && _a !== void 0 ? _a : (_d.moveSpeed = (0, engine_1.getRangeValue)(moveOptions.speed) * container.retina.pixelRatio)) *
+                container.retina.reduceFactor, moveDrift = ((_b = (_e = particle.retina).moveDrift) !== null && _b !== void 0 ? _b : (_e.moveDrift = (0, engine_1.getRangeValue)(particle.options.move.drift) * container.retina.pixelRatio)), maxSize = (0, engine_1.getRangeMax)(particleOptions.size.value) * container.retina.pixelRatio, sizeFactor = moveOptions.size ? particle.getRadius() / maxSize : 1, speedFactor = sizeFactor * slowFactor * (delta.factor || 1), diffFactor = 2, moveSpeed = (baseSpeed * speedFactor) / diffFactor;
+            if (moveOptions.spin.enable) {
+                (0, Utils_1.spin)(particle, moveSpeed);
+            }
+            else {
+                (0, Utils_1.applyPath)(particle, delta);
+                const gravityOptions = particle.gravity, gravityFactor = (gravityOptions === null || gravityOptions === void 0 ? void 0 : gravityOptions.enable) && gravityOptions.inverse ? -1 : 1;
+                if ((gravityOptions === null || gravityOptions === void 0 ? void 0 : gravityOptions.enable) && moveSpeed) {
+                    particle.velocity.y +=
+                        (gravityFactor * (gravityOptions.acceleration * delta.factor)) / (60 * moveSpeed);
+                }
+                if (moveDrift && moveSpeed) {
+                    particle.velocity.x += (moveDrift * delta.factor) / (60 * moveSpeed);
+                }
+                const decay = particle.moveDecay;
+                if (decay != 1) {
+                    particle.velocity.multTo(decay);
+                }
+                const velocity = particle.velocity.mult(moveSpeed), maxSpeed = (_c = particle.retina.maxSpeed) !== null && _c !== void 0 ? _c : container.retina.maxSpeed;
+                if ((gravityOptions === null || gravityOptions === void 0 ? void 0 : gravityOptions.enable) &&
+                    maxSpeed > 0 &&
+                    ((!gravityOptions.inverse && velocity.y >= 0 && velocity.y >= maxSpeed) ||
+                        (gravityOptions.inverse && velocity.y <= 0 && velocity.y <= -maxSpeed))) {
+                    velocity.y = gravityFactor * maxSpeed;
+                    if (moveSpeed) {
+                        particle.velocity.y = velocity.y / moveSpeed;
+                    }
+                }
+                const zIndexOptions = particle.options.zIndex, zVelocityFactor = (1 - particle.zIndexFactor) ** zIndexOptions.velocityRate;
+                if (zVelocityFactor != 1) {
+                    velocity.multTo(zVelocityFactor);
+                }
+                particle.position.addTo(velocity);
+                if (moveOptions.vibrate) {
+                    particle.position.x += Math.sin(particle.position.x * Math.cos(particle.position.y));
+                    particle.position.y += Math.cos(particle.position.y * Math.sin(particle.position.x));
+                }
+            }
+            (0, Utils_1.applyDistance)(particle);
+        }
+    }
+    exports.BaseMover = BaseMover;
+});

package/umd/IParticleGravity.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/IParticleSpin.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/Utils.js

@@ -0,0 +1,91 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getProximitySpeedFactor = exports.applyPath = exports.spin = exports.applyDistance = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    function applyDistance(particle) {
+        const initialPosition = particle.initialPosition, { dx, dy } = (0, engine_1.getDistances)(initialPosition, particle.position), dxFixed = Math.abs(dx), dyFixed = Math.abs(dy), hDistance = particle.retina.maxDistance.horizontal, vDistance = particle.retina.maxDistance.vertical;
+        if (!hDistance && !vDistance) {
+            return;
+        }
+        if (((hDistance && dxFixed >= hDistance) || (vDistance && dyFixed >= vDistance)) && !particle.misplaced) {
+            particle.misplaced = (!!hDistance && dxFixed > hDistance) || (!!vDistance && dyFixed > vDistance);
+            if (hDistance) {
+                particle.velocity.x = particle.velocity.y / 2 - particle.velocity.x;
+            }
+            if (vDistance) {
+                particle.velocity.y = particle.velocity.x / 2 - particle.velocity.y;
+            }
+        }
+        else if ((!hDistance || dxFixed < hDistance) && (!vDistance || dyFixed < vDistance) && particle.misplaced) {
+            particle.misplaced = false;
+        }
+        else if (particle.misplaced) {
+            const pos = particle.position, vel = particle.velocity;
+            if (hDistance && ((pos.x < initialPosition.x && vel.x < 0) || (pos.x > initialPosition.x && vel.x > 0))) {
+                vel.x *= -(0, engine_1.getRandom)();
+            }
+            if (vDistance && ((pos.y < initialPosition.y && vel.y < 0) || (pos.y > initialPosition.y && vel.y > 0))) {
+                vel.y *= -(0, engine_1.getRandom)();
+            }
+        }
+    }
+    exports.applyDistance = applyDistance;
+    function spin(particle, moveSpeed) {
+        const container = particle.container;
+        if (!particle.spin) {
+            return;
+        }
+        const updateFunc = {
+            x: particle.spin.direction === "clockwise" ? Math.cos : Math.sin,
+            y: particle.spin.direction === "clockwise" ? Math.sin : Math.cos,
+        };
+        particle.position.x = particle.spin.center.x + particle.spin.radius * updateFunc.x(particle.spin.angle);
+        particle.position.y = particle.spin.center.y + particle.spin.radius * updateFunc.y(particle.spin.angle);
+        particle.spin.radius += particle.spin.acceleration;
+        const maxCanvasSize = Math.max(container.canvas.size.width, container.canvas.size.height);
+        if (particle.spin.radius > maxCanvasSize / 2) {
+            particle.spin.radius = maxCanvasSize / 2;
+            particle.spin.acceleration *= -1;
+        }
+        else if (particle.spin.radius < 0) {
+            particle.spin.radius = 0;
+            particle.spin.acceleration *= -1;
+        }
+        particle.spin.angle += (moveSpeed / 100) * (1 - particle.spin.radius / maxCanvasSize);
+    }
+    exports.spin = spin;
+    function applyPath(particle, delta) {
+        var _a;
+        const particlesOptions = particle.options, pathOptions = particlesOptions.move.path, pathEnabled = pathOptions.enable;
+        if (!pathEnabled) {
+            return;
+        }
+        if (particle.lastPathTime <= particle.pathDelay) {
+            particle.lastPathTime += delta.value;
+            return;
+        }
+        const path = (_a = particle.pathGenerator) === null || _a === void 0 ? void 0 : _a.generate(particle);
+        if (path) {
+            particle.velocity.addTo(path);
+        }
+        if (pathOptions.clamp) {
+            particle.velocity.x = (0, engine_1.clamp)(particle.velocity.x, -1, 1);
+            particle.velocity.y = (0, engine_1.clamp)(particle.velocity.y, -1, 1);
+        }
+        particle.lastPathTime -= particle.pathDelay;
+    }
+    exports.applyPath = applyPath;
+    function getProximitySpeedFactor(particle) {
+        return particle.slow.inRange ? particle.slow.factor : 1;
+    }
+    exports.getProximitySpeedFactor = getProximitySpeedFactor;
+});

package/umd/index.js

@@ -0,0 +1,18 @@
+(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", "./BaseMover"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadBaseMover = void 0;
+    const BaseMover_1 = require("./BaseMover");
+    async function loadBaseMover(engine) {
+        engine.addMover("base", () => new BaseMover_1.BaseMover());
+    }
+    exports.loadBaseMover = loadBaseMover;
+});