tsparticles 1.42.2 → 1.43.0

package/esm/Core/Particles.js

@@ -10,10 +10,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _Particles_engine;
-import { InteractionManager, ParticlesMover, Point, QuadTree, Rectangle } from "./Utils";
-import { getRangeMax, getRangeMin, getRangeValue, randomInRange, setRangeValue } from "../Utils";
+import { calcPositionFromSize, getRangeMax, getRangeMin, getRangeValue, randomInRange, setRangeValue, } from "../Utils/NumberUtils";
+import { InteractionManager } from "./Utils/InteractionManager";
 import { Particle } from "./Particle";
 import { ParticlesOptions } from "../Options/Classes/Particles/ParticlesOptions";
+import { Point } from "./Utils/Point";
+import { QuadTree } from "./Utils/QuadTree";
+import { Rectangle } from "./Utils/Rectangle";
 export class Particles {
     constructor(engine, container) {
         this.container = container;
@@ -22,7 +25,6 @@ export class Particles {
         this.nextId = 0;
         this.array = [];
         this.zArray = [];
-        this.mover = new ParticlesMover(container);
         this.limit = 0;
         this.needsSort = false;
         this.lastZIndex = 0;
@@ -34,6 +36,7 @@ export class Particles {
         const canvasSize = this.container.canvas.size;
         this.linksColors = new Map();
         this.quadTree = new QuadTree(new Rectangle(-canvasSize.width / 4, -canvasSize.height / 4, (canvasSize.width * 3) / 2, (canvasSize.height * 3) / 2), 4);
+        this.movers = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getMovers(container, true);
         this.updaters = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getUpdaters(container, true);
     }
     get count() {
@@ -41,8 +44,7 @@ export class Particles {
     }
     init() {
         var _a;
-        const container = this.container;
-        const options = container.actualOptions;
+        const container = this.container, options = container.actualOptions;
         this.lastZIndex = 0;
         this.needsSort = false;
         this.freqs.links = new Map();
@@ -98,8 +100,7 @@ export class Particles {
         this.removeAt(this.array.indexOf(particle), undefined, group, override);
     }
     async update(delta) {
-        const container = this.container;
-        const particlesToDelete = [];
+        const container = this.container, particlesToDelete = [];
         container.pathGenerator.update();
         for (const [, plugin] of container.plugins) {
             if (plugin.update !== undefined) {
@@ -122,7 +123,11 @@ export class Particles {
                     plugin.particleUpdate(particle, delta);
                 }
             }
-            this.mover.move(particle, delta);
+            for (const mover of this.movers) {
+                if (mover.isEnabled(particle)) {
+                    mover.move(particle, delta);
+                }
+            }
             if (particle.destroyed) {
                 particlesToDelete.push(particle);
                 continue;
@@ -144,10 +149,9 @@ export class Particles {
         delete container.canvas.resizeFactor;
     }
     async draw(delta) {
-        const container = this.container;
-        container.canvas.clear();
-        const canvasSize = this.container.canvas.size;
+        const container = this.container, canvasSize = this.container.canvas.size;
         this.quadTree = new QuadTree(new Rectangle(-canvasSize.width / 4, -canvasSize.height / 4, (canvasSize.width * 3) / 2, (canvasSize.height * 3) / 2), 4);
+        container.canvas.clear();
         await this.update(delta);
         if (this.needsSort) {
             this.zArray.sort((a, b) => b.position.z - a.position.z || a.id - b.id);
@@ -199,8 +203,7 @@ export class Particles {
             options.size.value.max /= factor;
         }
         options.load(splitOptions.particles);
-        const offset = splitOptions.sizeOffset ? setRangeValue(-parent.size.value, parent.size.value) : 0;
-        const position = {
+        const offset = splitOptions.sizeOffset ? setRangeValue(-parent.size.value, parent.size.value) : 0, position = {
             x: parent.position.x + randomInRange(offset),
             y: parent.position.y + randomInRange(offset),
         };
@@ -251,13 +254,10 @@ export class Particles {
     addManualParticles() {
         const container = this.container, options = container.actualOptions;
         for (const particle of options.manualParticles) {
-            const pos = particle.position
-                ? {
-                    x: (particle.position.x * container.canvas.size.width) / 100,
-                    y: (particle.position.y * container.canvas.size.height) / 100,
-                }
-                : undefined;
-            this.addParticle(pos, particle.options);
+            this.addParticle(calcPositionFromSize({
+                size: container.canvas.size,
+                position: particle.position,
+            }), particle.options);
         }
     }
     setDensity() {
@@ -267,17 +267,15 @@ export class Particles {
         }
         this.applyDensity(options.particles, options.manualParticles.length);
     }
+    handleClickMode(mode) {
+        this.interactionManager.handleClickMode(mode);
+    }
     applyDensity(options, manualCount, group) {
         var _a;
         if (!((_a = options.number.density) === null || _a === void 0 ? void 0 : _a.enable)) {
             return;
         }
-        const numberOptions = options.number;
-        const densityFactor = this.initDensityFactor(numberOptions.density);
-        const optParticlesNumber = numberOptions.value;
-        const optParticlesLimit = numberOptions.limit > 0 ? numberOptions.limit : optParticlesNumber;
-        const particlesNumber = Math.min(optParticlesNumber, optParticlesLimit) * densityFactor + manualCount;
-        const particlesCount = Math.min(this.count, this.array.filter((t) => t.group === group).length);
+        const numberOptions = options.number, densityFactor = this.initDensityFactor(numberOptions.density), optParticlesNumber = numberOptions.value, optParticlesLimit = numberOptions.limit > 0 ? numberOptions.limit : optParticlesNumber, particlesNumber = Math.min(optParticlesNumber, optParticlesLimit) * densityFactor + manualCount, particlesCount = Math.min(this.count, this.array.filter((t) => t.group === group).length);
         this.limit = numberOptions.limit * densityFactor;
         if (particlesCount < particlesNumber) {
             this.push(Math.abs(particlesNumber - particlesCount), undefined, options, group);

package/esm/Core/Retina.js

@@ -1,11 +1,11 @@
-import { getRangeValue, isSsr } from "../Utils";
+import { getRangeValue } from "../Utils/NumberUtils";
+import { isSsr } from "../Utils/Utils";
 export class Retina {
     constructor(container) {
         this.container = container;
     }
     init() {
-        const container = this.container;
-        const options = container.actualOptions;
+        const container = this.container, options = container.actualOptions;
         this.pixelRatio = !options.detectRetina || isSsr() ? 1 : window.devicePixelRatio;
         const motionOptions = this.container.actualOptions.motion;
         if (motionOptions && (motionOptions.disable || motionOptions.reduce.value)) {
@@ -45,9 +45,6 @@ export class Retina {
         this.linksWidth = particles.links.width * ratio;
         this.sizeAnimationSpeed = getRangeValue(particles.size.animation.speed) * ratio;
         this.maxSpeed = getRangeValue(particles.move.gravity.maxSpeed) * ratio;
-        if (particles.orbit.radius !== undefined) {
-            this.orbitRadius = getRangeValue(particles.orbit.radius) * this.container.retina.pixelRatio;
-        }
         const modes = options.interactivity.modes;
         this.connectModeDistance = modes.connect.distance * ratio;
         this.connectModeRadius = modes.connect.radius * ratio;
@@ -62,19 +59,13 @@ export class Retina {
         }
     }
     initParticle(particle) {
-        const options = particle.options;
-        const ratio = this.pixelRatio;
-        const moveDistance = options.move.distance;
-        const props = particle.retina;
+        const options = particle.options, ratio = this.pixelRatio, moveDistance = options.move.distance, props = particle.retina;
         props.attractDistance = getRangeValue(options.move.attract.distance) * ratio;
         props.linksDistance = options.links.distance * ratio;
         props.linksWidth = options.links.width * ratio;
         props.moveDrift = getRangeValue(options.move.drift) * ratio;
         props.moveSpeed = getRangeValue(options.move.speed) * ratio;
         props.sizeAnimationSpeed = getRangeValue(options.size.animation.speed) * ratio;
-        if (particle.spin) {
-            props.spinAcceleration = getRangeValue(options.move.spin.acceleration) * ratio;
-        }
         const maxDistance = props.maxDistance;
         maxDistance.horizontal = moveDistance.horizontal !== undefined ? moveDistance.horizontal * ratio : undefined;
         maxDistance.vertical = moveDistance.vertical !== undefined ? moveDistance.vertical * ratio : undefined;

package/esm/Core/Utils/Circle.js

@@ -1,5 +1,5 @@
 import { Range } from "./Range";
-import { getDistance } from "../../Utils";
+import { getDistance } from "../../Utils/NumberUtils";
 export class Circle extends Range {
     constructor(x, y, radius) {
         super(x, y);
@@ -9,22 +9,13 @@ export class Circle extends Range {
         return getDistance(point, this.position) <= this.radius;
     }
     intersects(range) {
-        const rect = range;
-        const circle = range;
-        const pos1 = this.position;
-        const pos2 = range.position;
-        const xDist = Math.abs(pos2.x - pos1.x);
-        const yDist = Math.abs(pos2.y - pos1.y);
-        const r = this.radius;
+        const rect = range, circle = range, pos1 = this.position, pos2 = range.position, xDist = Math.abs(pos2.x - pos1.x), yDist = Math.abs(pos2.y - pos1.y), r = this.radius;
         if (circle.radius !== undefined) {
-            const rSum = r + circle.radius;
-            const dist = Math.sqrt(xDist * xDist + yDist + yDist);
+            const rSum = r + circle.radius, dist = Math.sqrt(xDist * xDist + yDist + yDist);
             return rSum > dist;
         }
         else if (rect.size !== undefined) {
-            const w = rect.size.width;
-            const h = rect.size.height;
-            const edges = Math.pow(xDist - w, 2) + Math.pow(yDist - h, 2);
+            const w = rect.size.width, h = rect.size.height, edges = Math.pow(xDist - w, 2) + Math.pow(yDist - h, 2);
             if (xDist > r + w || yDist > r + h) {
                 return false;
             }

package/esm/Core/Utils/CircleWarp.js

@@ -4,10 +4,7 @@ export class CircleWarp extends Circle {
     constructor(x, y, radius, canvasSize) {
         super(x, y, radius);
         this.canvasSize = canvasSize;
-        this.canvasSize = {
-            height: canvasSize.height,
-            width: canvasSize.width,
-        };
+        this.canvasSize = Object.assign({}, canvasSize);
     }
     contains(point) {
         if (super.contains(point)) {
@@ -37,9 +34,7 @@ export class CircleWarp extends Circle {
         if (super.intersects(range)) {
             return true;
         }
-        const rect = range;
-        const circle = range;
-        const newPos = {
+        const rect = range, circle = range, newPos = {
             x: range.position.x - this.canvasSize.width,
             y: range.position.y - this.canvasSize.height,
         };

package/esm/Core/Utils/EventListeners.js

@@ -1,5 +1,5 @@
-import { isSsr, itemFromArray } from "../../Utils";
 import { Constants } from "./Constants";
+import { isSsr } from "../../Utils/Utils";
 function manageListener(element, event, handler, add, options) {
     if (add) {
         let addOptions = { passive: true };
@@ -42,9 +42,7 @@ export class EventListeners {
     }
     manageListeners(add) {
         var _a;
-        const container = this.container;
-        const options = container.actualOptions;
-        const detectType = options.interactivity.detectsOn;
+        const container = this.container, options = container.actualOptions, detectType = options.interactivity.detectsOn;
         let mouseLeaveEvent = Constants.mouseLeaveEvent;
         if (detectType === "window") {
             container.interactivity.element = window;
@@ -130,8 +128,7 @@ export class EventListeners {
         this.resizeTimeout = setTimeout(async () => { var _a; return await ((_a = this.container.canvas) === null || _a === void 0 ? void 0 : _a.windowResize()); }, 500);
     }
     handleVisibilityChange() {
-        const container = this.container;
-        const options = container.actualOptions;
+        const container = this.container, options = container.actualOptions;
         this.mouseTouchFinish();
         if (!options.pauseOnBlur) {
             return;
@@ -160,9 +157,8 @@ export class EventListeners {
     }
     mouseTouchMove(e) {
         var _a, _b, _c, _d, _e, _f, _g;
-        const container = this.container;
-        const options = container.actualOptions;
-        if (((_a = container.interactivity) === null || _a === void 0 ? void 0 : _a.element) === undefined) {
+        const container = this.container, options = container.actualOptions;
+        if (!((_a = container.interactivity) === null || _a === void 0 ? void 0 : _a.element)) {
             return;
         }
         container.interactivity.mouse.inside = true;
@@ -229,7 +225,7 @@ export class EventListeners {
     }
     mouseTouchFinish() {
         const interactivity = this.container.interactivity;
-        if (interactivity === undefined) {
+        if (!interactivity) {
             return;
         }
         const mouse = interactivity.mouse;
@@ -241,21 +237,20 @@ export class EventListeners {
         mouse.clicking = false;
     }
     mouseTouchClick(e) {
-        const container = this.container;
-        const options = container.actualOptions;
-        const mouse = container.interactivity.mouse;
+        const container = this.container, options = container.actualOptions, mouse = container.interactivity.mouse;
         mouse.inside = true;
         let handled = false;
         const mousePosition = mouse.position;
-        if (mousePosition === undefined || !options.interactivity.events.onClick.enable) {
+        if (!mousePosition || !options.interactivity.events.onClick.enable) {
             return;
         }
         for (const [, plugin] of container.plugins) {
-            if (plugin.clickPositionValid !== undefined) {
-                handled = plugin.clickPositionValid(mousePosition);
-                if (handled) {
-                    break;
-                }
+            if (!plugin.clickPositionValid) {
+                continue;
+            }
+            handled = plugin.clickPositionValid(mousePosition);
+            if (handled) {
+                break;
             }
         }
         if (!handled) {
@@ -264,19 +259,16 @@ export class EventListeners {
         mouse.clicking = false;
     }
     doMouseTouchClick(e) {
-        const container = this.container;
-        const options = container.actualOptions;
+        const container = this.container, options = container.actualOptions;
         if (this.canPush) {
             const mousePos = container.interactivity.mouse.position;
-            if (mousePos) {
-                container.interactivity.mouse.clickPosition = {
-                    x: mousePos.x,
-                    y: mousePos.y,
-                };
-            }
-            else {
+            if (!mousePos) {
                 return;
             }
+            container.interactivity.mouse.clickPosition = {
+                x: mousePos.x,
+                y: mousePos.y,
+            };
             container.interactivity.mouse.clickTime = new Date().getTime();
             const onClick = options.interactivity.events.onClick;
             if (onClick.mode instanceof Array) {
@@ -293,77 +285,14 @@ export class EventListeners {
         }
     }
     handleThemeChange(e) {
-        const mediaEvent = e;
-        const themeName = mediaEvent.matches
+        const mediaEvent = e, themeName = mediaEvent.matches
             ? this.container.options.defaultDarkTheme
-            : this.container.options.defaultLightTheme;
-        const theme = this.container.options.themes.find((theme) => theme.name === themeName);
+            : this.container.options.defaultLightTheme, theme = this.container.options.themes.find((theme) => theme.name === themeName);
         if (theme && theme.default.auto) {
             this.container.loadTheme(themeName);
         }
     }
     handleClickMode(mode) {
-        const container = this.container;
-        const options = container.actualOptions;
-        const pushNb = options.interactivity.modes.push.quantity;
-        const removeNb = options.interactivity.modes.remove.quantity;
-        switch (mode) {
-            case "push": {
-                if (pushNb > 0) {
-                    const pushOptions = options.interactivity.modes.push;
-                    const group = itemFromArray([undefined, ...pushOptions.groups]);
-                    const groupOptions = group !== undefined ? container.actualOptions.particles.groups[group] : undefined;
-                    container.particles.push(pushNb, container.interactivity.mouse, groupOptions, group);
-                }
-                break;
-            }
-            case "remove":
-                container.particles.removeQuantity(removeNb);
-                break;
-            case "bubble":
-                container.bubble.clicking = true;
-                break;
-            case "repulse":
-                container.repulse.clicking = true;
-                container.repulse.count = 0;
-                for (const particle of container.repulse.particles) {
-                    particle.velocity.setTo(particle.initialVelocity);
-                }
-                container.repulse.particles = [];
-                container.repulse.finish = false;
-                setTimeout(() => {
-                    if (!container.destroyed) {
-                        container.repulse.clicking = false;
-                    }
-                }, options.interactivity.modes.repulse.duration * 1000);
-                break;
-            case "attract":
-                container.attract.clicking = true;
-                container.attract.count = 0;
-                for (const particle of container.attract.particles) {
-                    particle.velocity.setTo(particle.initialVelocity);
-                }
-                container.attract.particles = [];
-                container.attract.finish = false;
-                setTimeout(() => {
-                    if (!container.destroyed) {
-                        container.attract.clicking = false;
-                    }
-                }, options.interactivity.modes.attract.duration * 1000);
-                break;
-            case "pause":
-                if (container.getAnimationStatus()) {
-                    container.pause();
-                }
-                else {
-                    container.play();
-                }
-                break;
-        }
-        for (const [, plugin] of container.plugins) {
-            if (plugin.handleClickMode) {
-                plugin.handleClickMode(mode);
-            }
-        }
+        this.container.handleClickMode(mode);
     }
 }

package/esm/Core/Utils/FrameManager.js

@@ -12,8 +12,7 @@ export class FrameManager {
                 return;
             }
             (_a = container.lastFrameTime) !== null && _a !== void 0 ? _a : (container.lastFrameTime = timestamp);
-            const deltaValue = timestamp - container.lastFrameTime;
-            const delta = {
+            const deltaValue = timestamp - container.lastFrameTime, delta = {
                 value: deltaValue,
                 factor: (60 * deltaValue) / 1000,
             };

package/esm/Core/Utils/InteractionManager.js

@@ -51,5 +51,12 @@ export class InteractionManager {
             }
         }
     }
+    handleClickMode(mode) {
+        for (const interactor of this.externalInteractors) {
+            if (interactor.handleClickMode) {
+                interactor.handleClickMode(mode);
+            }
+        }
+    }
 }
 _InteractionManager_engine = new WeakMap();

package/esm/Core/Utils/Plugins.js

@@ -11,8 +11,10 @@ export class Plugins {
         __classPrivateFieldSet(this, _Plugins_engine, engine, "f");
         this.plugins = [];
         this.interactorsInitializers = new Map();
+        this.moversInitializers = new Map();
         this.updatersInitializers = new Map();
         this.interactors = new Map();
+        this.movers = new Map();
         this.updaters = new Map();
         this.presets = new Map();
         this.drawers = new Map();
@@ -49,14 +51,14 @@ export class Plugins {
             this.presets.set(presetKey, options);
         }
     }
+    getShapeDrawer(type) {
+        return this.drawers.get(type);
+    }
     addShapeDrawer(type, drawer) {
         if (!this.getShapeDrawer(type)) {
             this.drawers.set(type, drawer);
         }
     }
-    getShapeDrawer(type) {
-        return this.drawers.get(type);
-    }
     getSupportedShapes() {
         return this.drawers.keys();
     }
@@ -90,5 +92,16 @@ export class Plugins {
     addParticleUpdater(name, initUpdater) {
         this.updatersInitializers.set(name, initUpdater);
     }
+    getMovers(container, force = false) {
+        let res = this.movers.get(container);
+        if (!res || force) {
+            res = [...this.moversInitializers.values()].map((t) => t(container));
+            this.movers.set(container, res);
+        }
+        return res;
+    }
+    addParticleMover(name, initMover) {
+        this.moversInitializers.set(name, initMover);
+    }
 }
 _Plugins_engine = new WeakMap();

package/esm/Core/Utils/QuadTree.js

@@ -1,7 +1,7 @@
 import { Circle } from "./Circle";
 import { CircleWarp } from "./CircleWarp";
 import { Rectangle } from "./Rectangle";
-import { getDistance } from "../../Utils";
+import { getDistance } from "../../Utils/NumberUtils";
 export class QuadTree {
     constructor(rectangle, capacity) {
         this.rectangle = rectangle;
@@ -9,18 +9,6 @@ export class QuadTree {
         this.points = [];
         this.divided = false;
     }
-    subdivide() {
-        const x = this.rectangle.position.x;
-        const y = this.rectangle.position.y;
-        const w = this.rectangle.size.width;
-        const h = this.rectangle.size.height;
-        const capacity = this.capacity;
-        this.northEast = new QuadTree(new Rectangle(x, y, w / 2, h / 2), capacity);
-        this.northWest = new QuadTree(new Rectangle(x + w / 2, y, w / 2, h / 2), capacity);
-        this.southEast = new QuadTree(new Rectangle(x, y + h / 2, w / 2, h / 2), capacity);
-        this.southWest = new QuadTree(new Rectangle(x + w / 2, y + h / 2, w / 2, h / 2), capacity);
-        this.divided = true;
-    }
     insert(point) {
         var _a, _b, _c, _d, _e;
         if (!this.rectangle.contains(point.position)) {
@@ -42,8 +30,7 @@ export class QuadTree {
         return this.query(new Circle(position.x, position.y, radius));
     }
     queryCircleWarp(position, radius, containerOrSize) {
-        const container = containerOrSize;
-        const size = containerOrSize;
+        const container = containerOrSize, size = containerOrSize;
         return this.query(new CircleWarp(position.x, position.y, radius, container.canvas !== undefined ? container.canvas.size : size));
     }
     queryRectangle(position, size) {
@@ -55,20 +42,26 @@ export class QuadTree {
         if (!range.intersects(this.rectangle)) {
             return [];
         }
-        else {
-            for (const p of this.points) {
-                if (!range.contains(p.position) && getDistance(range.position, p.position) > p.particle.getRadius()) {
-                    continue;
-                }
-                res.push(p.particle);
-            }
-            if (this.divided) {
-                (_a = this.northEast) === null || _a === void 0 ? void 0 : _a.query(range, res);
-                (_b = this.northWest) === null || _b === void 0 ? void 0 : _b.query(range, res);
-                (_c = this.southEast) === null || _c === void 0 ? void 0 : _c.query(range, res);
-                (_d = this.southWest) === null || _d === void 0 ? void 0 : _d.query(range, res);
+        for (const p of this.points) {
+            if (!range.contains(p.position) && getDistance(range.position, p.position) > p.particle.getRadius()) {
+                continue;
             }
+            res.push(p.particle);
+        }
+        if (this.divided) {
+            (_a = this.northEast) === null || _a === void 0 ? void 0 : _a.query(range, res);
+            (_b = this.northWest) === null || _b === void 0 ? void 0 : _b.query(range, res);
+            (_c = this.southEast) === null || _c === void 0 ? void 0 : _c.query(range, res);
+            (_d = this.southWest) === null || _d === void 0 ? void 0 : _d.query(range, res);
         }
         return res;
     }
+    subdivide() {
+        const x = this.rectangle.position.x, y = this.rectangle.position.y, w = this.rectangle.size.width, h = this.rectangle.size.height, capacity = this.capacity;
+        this.northEast = new QuadTree(new Rectangle(x, y, w / 2, h / 2), capacity);
+        this.northWest = new QuadTree(new Rectangle(x + w / 2, y, w / 2, h / 2), capacity);
+        this.southEast = new QuadTree(new Rectangle(x, y + h / 2, w / 2, h / 2), capacity);
+        this.southWest = new QuadTree(new Rectangle(x + w / 2, y + h / 2, w / 2, h / 2), capacity);
+        this.divided = true;
+    }
 }

package/esm/Core/Utils/Rectangle.js

@@ -8,27 +8,18 @@ export class Rectangle extends Range {
         };
     }
     contains(point) {
-        const w = this.size.width;
-        const h = this.size.height;
-        const pos = this.position;
+        const w = this.size.width, h = this.size.height, pos = this.position;
         return point.x >= pos.x && point.x <= pos.x + w && point.y >= pos.y && point.y <= pos.y + h;
     }
     intersects(range) {
-        const rect = range;
-        const circle = range;
-        const w = this.size.width;
-        const h = this.size.height;
-        const pos1 = this.position;
-        const pos2 = range.position;
+        const rect = range, circle = range, w = this.size.width, h = this.size.height, pos1 = this.position, pos2 = range.position;
         if (circle.radius !== undefined) {
             return circle.intersects(this);
         }
-        else if (rect.size !== undefined) {
-            const size2 = rect.size;
-            const w2 = size2.width;
-            const h2 = size2.height;
-            return pos2.x < pos1.x + w && pos2.x + w2 > pos1.x && pos2.y < pos1.y + h && pos2.y + h2 > pos1.y;
+        if (!rect.size) {
+            return false;
         }
-        return false;
+        const size2 = rect.size, w2 = size2.width, h2 = size2.height;
+        return pos2.x < pos1.x + w && pos2.x + w2 > pos1.x && pos2.y < pos1.y + h && pos2.y + h2 > pos1.y;
     }
 }

package/esm/Core/Utils/Vector.js

@@ -1,18 +1,16 @@
 export class Vector {
-    constructor(x, y) {
-        let defX, defY;
-        if (y === undefined) {
-            if (typeof x === "number") {
-                throw new Error("tsParticles - Vector not initialized correctly");
-            }
-            const coords = x;
-            [defX, defY] = [coords.x, coords.y];
+    constructor(xOrCoords, y) {
+        if (typeof xOrCoords !== "number" && xOrCoords) {
+            this.x = xOrCoords.x;
+            this.y = xOrCoords.y;
+        }
+        else if (xOrCoords !== undefined && y !== undefined) {
+            this.x = xOrCoords;
+            this.y = y;
         }
         else {
-            [defX, defY] = [x, y];
+            throw new Error("tsParticles - Vector not initialized correctly");
         }
-        this.x = defX;
-        this.y = defY;
     }
     static clone(source) {
         return Vector.create(source.x, source.y);
@@ -30,7 +28,7 @@ export class Vector {
         this.updateFromAngle(angle, this.length);
     }
     get length() {
-        return Math.sqrt(this.x ** 2 + this.y ** 2);
+        return Math.sqrt(this.getLengthSq());
     }
     set length(length) {
         this.updateFromAngle(this.angle, length);
@@ -78,9 +76,9 @@ export class Vector {
     copy() {
         return Vector.clone(this);
     }
-    setTo(velocity) {
-        this.x = velocity.x;
-        this.y = velocity.y;
+    setTo(v) {
+        this.x = v.x;
+        this.y = v.y;
     }
     rotate(angle) {
         return Vector.create(this.x * Math.cos(angle) - this.y * Math.sin(angle), this.x * Math.sin(angle) + this.y * Math.cos(angle));