tsparticles 1.42.2 → 1.43.0

package/cjs/Interactions/External/Trail/TrailMaker.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrailMaker = void 0;
+const ExternalInteractorBase_1 = require("../../../Core/Utils/ExternalInteractorBase");
+const Utils_1 = require("../../../Utils/Utils");
+class TrailMaker extends ExternalInteractorBase_1.ExternalInteractorBase {
+    constructor(container) {
+        super(container);
+        this.delay = 0;
+    }
+    async interact(delta) {
+        var _a, _b, _c, _d;
+        if (!this.container.retina.reduceFactor) {
+            return;
+        }
+        const container = this.container, options = container.actualOptions, trailOptions = options.interactivity.modes.trail, optDelay = (trailOptions.delay * 1000) / this.container.retina.reduceFactor;
+        if (this.delay < optDelay) {
+            this.delay += delta.value;
+        }
+        if (this.delay < optDelay) {
+            return;
+        }
+        let canEmit = true;
+        if (trailOptions.pauseOnStop) {
+            if (container.interactivity.mouse.position === this.lastPosition ||
+                (((_a = container.interactivity.mouse.position) === null || _a === void 0 ? void 0 : _a.x) === ((_b = this.lastPosition) === null || _b === void 0 ? void 0 : _b.x) &&
+                    ((_c = container.interactivity.mouse.position) === null || _c === void 0 ? void 0 : _c.y) === ((_d = this.lastPosition) === null || _d === void 0 ? void 0 : _d.y))) {
+                canEmit = false;
+            }
+        }
+        if (container.interactivity.mouse.position) {
+            this.lastPosition = {
+                x: container.interactivity.mouse.position.x,
+                y: container.interactivity.mouse.position.y,
+            };
+        }
+        else {
+            delete this.lastPosition;
+        }
+        if (canEmit) {
+            container.particles.push(trailOptions.quantity, container.interactivity.mouse, trailOptions.particles);
+        }
+        this.delay -= optDelay;
+    }
+    isEnabled() {
+        const container = this.container, options = container.actualOptions, mouse = container.interactivity.mouse, events = options.interactivity.events;
+        return ((mouse.clicking && mouse.inside && !!mouse.position && (0, Utils_1.isInArray)("trail", events.onClick.mode)) ||
+            (mouse.inside && !!mouse.position && (0, Utils_1.isInArray)("trail", events.onHover.mode)));
+    }
+    reset() {
+    }
+}
+exports.TrailMaker = TrailMaker;

package/cjs/Interactions/Particles/Attract/Attractor.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Attractor = void 0;
+const ParticlesInteractorBase_1 = require("../../../Core/Utils/ParticlesInteractorBase");
+const NumberUtils_1 = require("../../../Utils/NumberUtils");
+class Attractor extends ParticlesInteractorBase_1.ParticlesInteractorBase {
+    constructor(container) {
+        super(container);
+    }
+    async interact(p1) {
+        var _a;
+        const container = this.container, distance = (_a = p1.retina.attractDistance) !== null && _a !== void 0 ? _a : container.retina.attractDistance, pos1 = p1.getPosition(), query = container.particles.quadTree.queryCircle(pos1, distance);
+        for (const p2 of query) {
+            if (p1 === p2 || !p2.options.move.attract.enable || p2.destroyed || p2.spawning) {
+                continue;
+            }
+            const pos2 = p2.getPosition(), { dx, dy } = (0, NumberUtils_1.getDistances)(pos1, pos2), rotate = p1.options.move.attract.rotate, ax = dx / (rotate.x * 1000), ay = dy / (rotate.y * 1000), p1Factor = p2.size.value / p1.size.value, p2Factor = 1 / p1Factor;
+            p1.velocity.x -= ax * p1Factor;
+            p1.velocity.y -= ay * p1Factor;
+            p2.velocity.x += ax * p2Factor;
+            p2.velocity.y += ay * p2Factor;
+        }
+    }
+    isEnabled(particle) {
+        return particle.options.move.attract.enable;
+    }
+    reset() {
+    }
+}
+exports.Attractor = Attractor;

package/cjs/Interactions/Particles/Collisions/Collider.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collider = void 0;
+const Utils_1 = require("../../../Utils/Utils");
+const NumberUtils_1 = require("../../../Utils/NumberUtils");
+const ParticlesInteractorBase_1 = require("../../../Core/Utils/ParticlesInteractorBase");
+function bounce(p1, p2) {
+    (0, Utils_1.circleBounce)((0, Utils_1.circleBounceDataFromParticle)(p1), (0, Utils_1.circleBounceDataFromParticle)(p2));
+}
+function destroy(p1, p2) {
+    if (!p1.unbreakable && !p2.unbreakable) {
+        bounce(p1, p2);
+    }
+    if (p1.getRadius() === undefined && p2.getRadius() !== undefined) {
+        p1.destroy();
+    }
+    else if (p1.getRadius() !== undefined && p2.getRadius() === undefined) {
+        p2.destroy();
+    }
+    else if (p1.getRadius() !== undefined && p2.getRadius() !== undefined) {
+        if (p1.getRadius() >= p2.getRadius()) {
+            p2.destroy();
+        }
+        else {
+            p1.destroy();
+        }
+    }
+}
+class Collider extends ParticlesInteractorBase_1.ParticlesInteractorBase {
+    constructor(container) {
+        super(container);
+    }
+    isEnabled(particle) {
+        return particle.options.collisions.enable;
+    }
+    reset() {
+    }
+    async interact(p1) {
+        const container = this.container, pos1 = p1.getPosition(), radius1 = p1.getRadius(), query = container.particles.quadTree.queryCircle(pos1, radius1 * 2);
+        for (const p2 of query) {
+            if (p1 === p2 ||
+                !p2.options.collisions.enable ||
+                p1.options.collisions.mode !== p2.options.collisions.mode ||
+                p2.destroyed ||
+                p2.spawning) {
+                continue;
+            }
+            const pos2 = p2.getPosition();
+            if (Math.round(pos1.z) !== Math.round(pos2.z)) {
+                continue;
+            }
+            const dist = (0, NumberUtils_1.getDistance)(pos1, pos2), radius2 = p2.getRadius(), distP = radius1 + radius2;
+            if (dist <= distP) {
+                this.resolveCollision(p1, p2);
+            }
+        }
+    }
+    resolveCollision(p1, p2) {
+        switch (p1.options.collisions.mode) {
+            case "absorb":
+                this.absorb(p1, p2);
+                break;
+            case "bounce":
+                bounce(p1, p2);
+                break;
+            case "destroy":
+                destroy(p1, p2);
+                break;
+        }
+    }
+    absorb(p1, p2) {
+        const container = this.container, fps = container.fpsLimit / 1000;
+        if (p1.getRadius() === undefined && p2.getRadius() !== undefined) {
+            p1.destroy();
+        }
+        else if (p1.getRadius() !== undefined && p2.getRadius() === undefined) {
+            p2.destroy();
+        }
+        else if (p1.getRadius() !== undefined && p2.getRadius() !== undefined) {
+            if (p1.getRadius() >= p2.getRadius()) {
+                const factor = (0, NumberUtils_1.clamp)(p1.getRadius() / p2.getRadius(), 0, p2.getRadius()) * fps;
+                p1.size.value += factor;
+                p2.size.value -= factor;
+                if (p2.getRadius() <= container.retina.pixelRatio) {
+                    p2.size.value = 0;
+                    p2.destroy();
+                }
+            }
+            else {
+                const factor = (0, NumberUtils_1.clamp)(p2.getRadius() / p1.getRadius(), 0, p1.getRadius()) * fps;
+                p1.size.value -= factor;
+                p2.size.value += factor;
+                if (p1.getRadius() <= container.retina.pixelRatio) {
+                    p1.size.value = 0;
+                    p1.destroy();
+                }
+            }
+        }
+    }
+}
+exports.Collider = Collider;

package/cjs/Interactions/Particles/Links/LinkInstance.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkInstance = void 0;
+const ColorUtils_1 = require("../../../Utils/ColorUtils");
+const CanvasUtils_1 = require("../../../Utils/CanvasUtils");
+const NumberUtils_1 = require("../../../Utils/NumberUtils");
+class LinkInstance {
+    constructor(container) {
+        this.container = container;
+    }
+    particleCreated(particle) {
+        const linkParticle = particle;
+        linkParticle.links = [];
+    }
+    particleDestroyed(particle) {
+        const linkParticle = particle;
+        linkParticle.links = [];
+    }
+    drawParticle(context, particle) {
+        const linkParticle = particle, container = this.container, particles = container.particles, pOptions = particle.options;
+        if (linkParticle.links.length <= 0) {
+            return;
+        }
+        context.save();
+        const p1Links = linkParticle.links.filter((l) => {
+            const linkFreq = container.particles.getLinkFrequency(linkParticle, l.destination);
+            return linkFreq <= pOptions.links.frequency;
+        });
+        for (const link of p1Links) {
+            const p2 = link.destination;
+            if (pOptions.links.triangles.enable) {
+                const links = p1Links.map((l) => l.destination), vertices = p2.links.filter((t) => {
+                    const linkFreq = container.particles.getLinkFrequency(p2, t.destination);
+                    return linkFreq <= p2.options.links.frequency && links.indexOf(t.destination) >= 0;
+                });
+                if (vertices.length) {
+                    for (const vertex of vertices) {
+                        const p3 = vertex.destination, triangleFreq = particles.getTriangleFrequency(linkParticle, p2, p3);
+                        if (triangleFreq > pOptions.links.triangles.frequency) {
+                            continue;
+                        }
+                        this.drawLinkTriangle(linkParticle, link, vertex);
+                    }
+                }
+            }
+            if (link.opacity > 0 && container.retina.linksWidth > 0) {
+                this.drawLinkLine(linkParticle, link);
+            }
+        }
+        context.restore();
+    }
+    drawLinkTriangle(p1, link1, link2) {
+        var _a;
+        const container = this.container, options = container.actualOptions, p2 = link1.destination, p3 = link2.destination, triangleOptions = p1.options.links.triangles, opacityTriangle = (_a = triangleOptions.opacity) !== null && _a !== void 0 ? _a : (link1.opacity + link2.opacity) / 2;
+        if (opacityTriangle <= 0) {
+            return;
+        }
+        const pos1 = p1.getPosition(), pos2 = p2.getPosition(), pos3 = p3.getPosition();
+        container.canvas.draw((ctx) => {
+            if ((0, NumberUtils_1.getDistance)(pos1, pos2) > container.retina.linksDistance ||
+                (0, NumberUtils_1.getDistance)(pos3, pos2) > container.retina.linksDistance ||
+                (0, NumberUtils_1.getDistance)(pos3, pos1) > container.retina.linksDistance) {
+                return;
+            }
+            let colorTriangle = (0, ColorUtils_1.colorToRgb)(triangleOptions.color);
+            if (!colorTriangle) {
+                const linksOptions = p1.options.links, linkColor = linksOptions.id !== undefined
+                    ? container.particles.linksColors.get(linksOptions.id)
+                    : container.particles.linksColor;
+                colorTriangle = (0, ColorUtils_1.getLinkColor)(p1, p2, linkColor);
+            }
+            if (!colorTriangle) {
+                return;
+            }
+            (0, CanvasUtils_1.drawLinkTriangle)(ctx, pos1, pos2, pos3, options.backgroundMask.enable, options.backgroundMask.composite, colorTriangle, opacityTriangle);
+        });
+    }
+    drawLinkLine(p1, link) {
+        const container = this.container, options = container.actualOptions, p2 = link.destination, pos1 = p1.getPosition(), pos2 = p2.getPosition();
+        let opacity = link.opacity;
+        container.canvas.draw((ctx) => {
+            var _a, _b;
+            let colorLine;
+            const twinkle = p1.options.twinkle.lines;
+            if (twinkle.enable) {
+                const twinkleFreq = twinkle.frequency, twinkleRgb = (0, ColorUtils_1.colorToRgb)(twinkle.color), twinkling = Math.random() < twinkleFreq;
+                if (twinkling && twinkleRgb) {
+                    colorLine = twinkleRgb;
+                    opacity = (0, NumberUtils_1.getRangeValue)(twinkle.opacity);
+                }
+            }
+            if (!colorLine) {
+                const linksOptions = p1.options.links, linkColor = linksOptions.id !== undefined
+                    ? container.particles.linksColors.get(linksOptions.id)
+                    : container.particles.linksColor;
+                colorLine = (0, ColorUtils_1.getLinkColor)(p1, p2, linkColor);
+            }
+            if (!colorLine) {
+                return;
+            }
+            const width = (_a = p1.retina.linksWidth) !== null && _a !== void 0 ? _a : container.retina.linksWidth, maxDistance = (_b = p1.retina.linksDistance) !== null && _b !== void 0 ? _b : container.retina.linksDistance;
+            (0, CanvasUtils_1.drawLinkLine)(ctx, width, pos1, pos2, maxDistance, container.canvas.size, p1.options.links.warp, options.backgroundMask.enable, options.backgroundMask.composite, colorLine, opacity, p1.options.links.shadow);
+        });
+    }
+}
+exports.LinkInstance = LinkInstance;

package/cjs/Interactions/Particles/Links/Linker.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Linker = void 0;
+const Circle_1 = require("../../../Core/Utils/Circle");
+const CircleWarp_1 = require("../../../Core/Utils/CircleWarp");
+const ParticlesInteractorBase_1 = require("../../../Core/Utils/ParticlesInteractorBase");
+const NumberUtils_1 = require("../../../Utils/NumberUtils");
+const ColorUtils_1 = require("../../../Utils/ColorUtils");
+function getLinkDistance(pos1, pos2, optDistance, canvasSize, warp) {
+    let distance = (0, NumberUtils_1.getDistance)(pos1, pos2);
+    if (!warp || distance <= optDistance) {
+        return distance;
+    }
+    const pos2NE = {
+        x: pos2.x - canvasSize.width,
+        y: pos2.y,
+    };
+    distance = (0, NumberUtils_1.getDistance)(pos1, pos2NE);
+    if (distance <= optDistance) {
+        return distance;
+    }
+    const pos2SE = {
+        x: pos2.x - canvasSize.width,
+        y: pos2.y - canvasSize.height,
+    };
+    distance = (0, NumberUtils_1.getDistance)(pos1, pos2SE);
+    if (distance <= optDistance) {
+        return distance;
+    }
+    const pos2SW = {
+        x: pos2.x,
+        y: pos2.y - canvasSize.height,
+    };
+    distance = (0, NumberUtils_1.getDistance)(pos1, pos2SW);
+    return distance;
+}
+class Linker extends ParticlesInteractorBase_1.ParticlesInteractorBase {
+    constructor(container) {
+        super(container);
+    }
+    isEnabled(particle) {
+        return particle.options.links.enable;
+    }
+    reset() {
+    }
+    async interact(p1) {
+        var _a;
+        p1.links = [];
+        const pos1 = p1.getPosition(), container = this.container, canvasSize = container.canvas.size;
+        if (pos1.x < 0 || pos1.y < 0 || pos1.x > canvasSize.width || pos1.y > canvasSize.height) {
+            return;
+        }
+        const linkOpt1 = p1.options.links, optOpacity = linkOpt1.opacity, optDistance = (_a = p1.retina.linksDistance) !== null && _a !== void 0 ? _a : container.retina.linksDistance, warp = linkOpt1.warp, range = warp
+            ? new CircleWarp_1.CircleWarp(pos1.x, pos1.y, optDistance, canvasSize)
+            : new Circle_1.Circle(pos1.x, pos1.y, optDistance), query = container.particles.quadTree.query(range);
+        for (const p2 of query) {
+            const linkOpt2 = p2.options.links;
+            if (p1 === p2 ||
+                !linkOpt2.enable ||
+                linkOpt1.id !== linkOpt2.id ||
+                p2.spawning ||
+                p2.destroyed ||
+                p1.links.map((t) => t.destination).indexOf(p2) !== -1 ||
+                p2.links.map((t) => t.destination).indexOf(p1) !== -1) {
+                continue;
+            }
+            const pos2 = p2.getPosition();
+            if (pos2.x < 0 || pos2.y < 0 || pos2.x > canvasSize.width || pos2.y > canvasSize.height) {
+                continue;
+            }
+            const distance = getLinkDistance(pos1, pos2, optDistance, canvasSize, warp && linkOpt2.warp);
+            if (distance > optDistance) {
+                return;
+            }
+            const opacityLine = (1 - distance / optDistance) * optOpacity;
+            this.setColor(p1);
+            p1.links.push({
+                destination: p2,
+                opacity: opacityLine,
+            });
+        }
+    }
+    setColor(p1) {
+        const container = this.container, linksOptions = p1.options.links;
+        let linkColor = linksOptions.id === undefined
+            ? container.particles.linksColor
+            : container.particles.linksColors.get(linksOptions.id);
+        if (!linkColor) {
+            const optColor = linksOptions.color;
+            linkColor = (0, ColorUtils_1.getLinkRandomColor)(optColor, linksOptions.blink, linksOptions.consent);
+            if (linksOptions.id === undefined) {
+                container.particles.linksColor = linkColor;
+            }
+            else {
+                container.particles.linksColors.set(linksOptions.id, linkColor);
+            }
+        }
+    }
+}
+exports.Linker = Linker;

package/cjs/Movers/Base/BaseMover.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMover = void 0;
+const Utils_1 = require("./Utils");
+const NumberUtils_1 = require("../../Utils/NumberUtils");
+class BaseMover {
+    init(particle) {
+        var _a;
+        const container = particle.container, options = particle.options, spinOptions = options.move.spin;
+        if (spinOptions.enable) {
+            const spinPos = (_a = spinOptions.position) !== null && _a !== void 0 ? _a : { x: 50, y: 50 };
+            const spinCenter = {
+                x: (spinPos.x / 100) * container.canvas.size.width,
+                y: (spinPos.y / 100) * container.canvas.size.height,
+            };
+            const pos = particle.getPosition();
+            const distance = (0, NumberUtils_1.getDistance)(pos, spinCenter);
+            const spinAcceleration = (0, NumberUtils_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, NumberUtils_1.getRangeValue)(moveOptions.speed) * container.retina.pixelRatio)) *
+            container.retina.reduceFactor, moveDrift = ((_b = (_e = particle.retina).moveDrift) !== null && _b !== void 0 ? _b : (_e.moveDrift = (0, NumberUtils_1.getRangeValue)(particle.options.move.drift) * container.retina.pixelRatio)), maxSize = (0, NumberUtils_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;
+        (0, Utils_1.applyPath)(particle, delta);
+        const gravityOptions = particle.gravity, gravityFactor = gravityOptions.enable && gravityOptions.inverse ? -1 : 1;
+        if (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.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 (moveOptions.spin.enable) {
+            (0, Utils_1.spin)(particle, moveSpeed);
+        }
+        else {
+            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/Movers/Base/Utils.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProximitySpeedFactor = exports.applyPath = exports.spin = exports.applyDistance = void 0;
+const NumberUtils_1 = require("../../Utils/NumberUtils");
+const Utils_1 = require("../../Utils/Utils");
+function applyDistance(particle) {
+    const initialPosition = particle.initialPosition;
+    const { dx, dy } = (0, NumberUtils_1.getDistances)(initialPosition, particle.position);
+    const dxFixed = Math.abs(dx), dyFixed = Math.abs(dy);
+    const hDistance = particle.retina.maxDistance.horizontal;
+    const 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 *= -Math.random();
+        }
+        if (vDistance && ((pos.y < initialPosition.y && vel.y < 0) || (pos.y > initialPosition.y && vel.y > 0))) {
+            vel.y *= -Math.random();
+        }
+    }
+}
+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) {
+    const particlesOptions = particle.options;
+    const pathOptions = particlesOptions.move.path;
+    const pathEnabled = pathOptions.enable;
+    if (!pathEnabled) {
+        return;
+    }
+    const container = particle.container;
+    if (particle.lastPathTime <= particle.pathDelay) {
+        particle.lastPathTime += delta.value;
+        return;
+    }
+    const path = container.pathGenerator.generate(particle);
+    particle.velocity.addTo(path);
+    if (pathOptions.clamp) {
+        particle.velocity.x = (0, NumberUtils_1.clamp)(particle.velocity.x, -1, 1);
+        particle.velocity.y = (0, NumberUtils_1.clamp)(particle.velocity.y, -1, 1);
+    }
+    particle.lastPathTime -= particle.pathDelay;
+}
+exports.applyPath = applyPath;
+function getProximitySpeedFactor(particle) {
+    const container = particle.container;
+    const options = container.actualOptions;
+    const active = (0, Utils_1.isInArray)("slow", options.interactivity.events.onHover.mode);
+    if (!active) {
+        return 1;
+    }
+    const mousePos = particle.container.interactivity.mouse.position;
+    if (!mousePos) {
+        return 1;
+    }
+    const particlePos = particle.getPosition();
+    const dist = (0, NumberUtils_1.getDistance)(mousePos, particlePos);
+    const radius = container.retina.slowModeRadius;
+    if (dist > radius) {
+        return 1;
+    }
+    const proximityFactor = dist / radius || 0;
+    const slowFactor = options.interactivity.modes.slow.factor;
+    return proximityFactor / slowFactor;
+}
+exports.getProximitySpeedFactor = getProximitySpeedFactor;

package/cjs/Movers/Base/index.js

@@ -0,0 +1,8 @@
+"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;

package/cjs/Movers/Parallax/ParallaxMover.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParallaxMover = void 0;
+const Utils_1 = require("../../Utils/Utils");
+class ParallaxMover {
+    init() {
+    }
+    isEnabled(particle) {
+        return (!(0, Utils_1.isSsr)() &&
+            !particle.destroyed &&
+            particle.container.actualOptions.interactivity.events.onHover.parallax.enable);
+    }
+    move(particle) {
+        const container = particle.container, options = container.actualOptions;
+        if ((0, Utils_1.isSsr)() || !options.interactivity.events.onHover.parallax.enable) {
+            return;
+        }
+        const parallaxForce = options.interactivity.events.onHover.parallax.force, mousePos = container.interactivity.mouse.position;
+        if (!mousePos) {
+            return;
+        }
+        const canvasCenter = {
+            x: container.canvas.size.width / 2,
+            y: container.canvas.size.height / 2,
+        }, parallaxSmooth = options.interactivity.events.onHover.parallax.smooth, factor = particle.getRadius() / parallaxForce, centerDistance = {
+            x: (mousePos.x - canvasCenter.x) * factor,
+            y: (mousePos.y - canvasCenter.y) * factor,
+        };
+        particle.offset.x += (centerDistance.x - particle.offset.x) / parallaxSmooth;
+        particle.offset.y += (centerDistance.y - particle.offset.y) / parallaxSmooth;
+    }
+}
+exports.ParallaxMover = ParallaxMover;

package/cjs/Movers/Parallax/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadParallaxMover = void 0;
+const ParallaxMover_1 = require("./ParallaxMover");
+async function loadParallaxMover(engine) {
+    engine.addMover("parallax", () => new ParallaxMover_1.ParallaxMover());
+}
+exports.loadParallaxMover = loadParallaxMover;