@tsparticles/move-base 3.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Matteo Bruni
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+[![banner](https://particles.js.org/images/banner2.png)](https://particles.js.org)
+
+# tsParticles Standard Mover
+
+[![jsDelivr](https://data.jsdelivr.com/v1/package/npm/tsparticles-move-base/badge)](https://www.jsdelivr.com/package/npm/tsparticles-move-base)
+[![npmjs](https://badge.fury.io/js/tsparticles-move-base.svg)](https://www.npmjs.com/package/tsparticles-move-base)
+[![npmjs](https://img.shields.io/npm/dt/tsparticles-move-base)](https://www.npmjs.com/package/tsparticles-move-base) [![GitHub Sponsors](https://img.shields.io/github/sponsors/matteobruni)](https://github.com/sponsors/matteobruni)
+
+[tsParticles](https://github.com/matteobruni/tsparticles) move plugin for standard movement effect.
+
+## How to use it
+
+### CDN / Vanilla JS / jQuery
+
+The CDN/Vanilla version JS has one required file in vanilla configuration:
+
+Including the `tsparticles.move.base.min.js` file will export the function to load the interaction plugin:
+
+```javascript
+loadBaseMover;
+```
+
+### Usage
+
+Once the scripts are loaded you can set up `tsParticles` and the interaction plugin like this:
+
+```javascript
+(async () => {
+  await loadBaseMover(tsParticles);
+
+  await tsParticles.load({
+    id: "tsparticles",
+    options: {
+      /* options */
+    },
+  });
+})();
+```
+
+### ESM / CommonJS
+
+This package is compatible also with ES or CommonJS modules, firstly this needs to be installed, like this:
+
+```shell
+$ npm install tsparticles-move-base
+```
+
+or
+
+```shell
+$ yarn add tsparticles-move-base
+```
+
+Then you need to import it in the app, like this:
+
+```javascript
+const { tsParticles } = require("tsparticles-engine");
+const { loadBaseMover } = require("tsparticles-move-base");
+
+loadBaseMover(tsParticles); // awaitable
+```
+
+or
+
+```javascript
+import { tsParticles } from "tsparticles-engine";
+import { loadBaseMover } from "tsparticles-move-base";
+
+loadBaseMover(tsParticles); // awaitable
+```

package/browser/BaseMover.js

@@ -0,0 +1,78 @@
+import { getDistance, getRangeMax, getRangeValue } from "@tsparticles/engine";
+import { applyDistance, applyPath, getProximitySpeedFactor, spin } from "./Utils";
+export 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: 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 = getDistance(pos, spinCenter), spinAcceleration = 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 = getRangeValue(moveOptions.speed) * container.retina.pixelRatio)) *
+            container.retina.reduceFactor, moveDrift = ((_b = (_e = particle.retina).moveDrift) !== null && _b !== void 0 ? _b : (_e.moveDrift = getRangeValue(particle.options.move.drift) * container.retina.pixelRatio)), maxSize = 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);
+    }
+}

package/browser/IParticleGravity.js

@@ -0,0 +1 @@
+export {};

package/browser/IParticleSpin.js

@@ -0,0 +1 @@
+export {};

package/browser/Types.js

@@ -0,0 +1 @@
+export {};

package/browser/Utils.js

@@ -0,0 +1,74 @@
+import { clamp, getDistances, getRandom } from "@tsparticles/engine";
+export function applyDistance(particle) {
+    const initialPosition = particle.initialPosition, { dx, dy } = 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 *= -getRandom();
+        }
+        if (vDistance && ((pos.y < initialPosition.y && vel.y < 0) || (pos.y > initialPosition.y && vel.y > 0))) {
+            vel.y *= -getRandom();
+        }
+    }
+}
+export 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);
+}
+export 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 = clamp(particle.velocity.x, -1, 1);
+        particle.velocity.y = clamp(particle.velocity.y, -1, 1);
+    }
+    particle.lastPathTime -= particle.pathDelay;
+}
+export function getProximitySpeedFactor(particle) {
+    return particle.slow.inRange ? particle.slow.factor : 1;
+}

package/browser/index.js

@@ -0,0 +1,4 @@
+import { BaseMover } from "./BaseMover";
+export async function loadBaseMover(engine) {
+    engine.addMover("base", () => new BaseMover());
+}

package/cjs/BaseMover.js

@@ -0,0 +1,82 @@
+"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 = Math.pow((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/cjs/IParticleGravity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/IParticleSpin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/Types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/Utils.js

@@ -0,0 +1,81 @@
+"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/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBaseMover = void 0;
+const BaseMover_1 = require("./BaseMover");
+function loadBaseMover(engine) {
+    return __awaiter(this, void 0, void 0, function* () {
+        engine.addMover("base", () => new BaseMover_1.BaseMover());
+    });
+}
+exports.loadBaseMover = loadBaseMover;

package/esm/BaseMover.js

@@ -0,0 +1,78 @@
+import { getDistance, getRangeMax, getRangeValue } from "@tsparticles/engine";
+import { applyDistance, applyPath, getProximitySpeedFactor, spin } from "./Utils";
+export 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: 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 = getDistance(pos, spinCenter), spinAcceleration = 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 = getRangeValue(moveOptions.speed) * container.retina.pixelRatio)) *
+            container.retina.reduceFactor, moveDrift = ((_b = (_e = particle.retina).moveDrift) !== null && _b !== void 0 ? _b : (_e.moveDrift = getRangeValue(particle.options.move.drift) * container.retina.pixelRatio)), maxSize = 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);
+    }
+}

package/esm/IParticleGravity.js

@@ -0,0 +1 @@
+export {};

package/esm/IParticleSpin.js

@@ -0,0 +1 @@
+export {};

package/esm/Types.js

@@ -0,0 +1 @@
+export {};

package/esm/Utils.js

@@ -0,0 +1,74 @@
+import { clamp, getDistances, getRandom } from "@tsparticles/engine";
+export function applyDistance(particle) {
+    const initialPosition = particle.initialPosition, { dx, dy } = 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 *= -getRandom();
+        }
+        if (vDistance && ((pos.y < initialPosition.y && vel.y < 0) || (pos.y > initialPosition.y && vel.y > 0))) {
+            vel.y *= -getRandom();
+        }
+    }
+}
+export 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);
+}
+export 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 = clamp(particle.velocity.x, -1, 1);
+        particle.velocity.y = clamp(particle.velocity.y, -1, 1);
+    }
+    particle.lastPathTime -= particle.pathDelay;
+}
+export function getProximitySpeedFactor(particle) {
+    return particle.slow.inRange ? particle.slow.factor : 1;
+}

package/esm/index.js

@@ -0,0 +1,4 @@
+import { BaseMover } from "./BaseMover";
+export async function loadBaseMover(engine) {
+    engine.addMover("base", () => new BaseMover());
+}