@tsparticles/engine 3.0.3 → 3.2.0

package/umd/Core/Particles.js

@@ -1,23 +1,46 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 (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", "../Utils/Utils.js", "./Utils/InteractionManager.js", "./Particle.js", "./Utils/Point.js", "./Utils/QuadTree.js", "./Utils/Rectangle.js", "./Utils/Constants.js"], factory);
+        define(["require", "exports", "../Utils/Utils.js", "./Utils/InteractionManager.js", "./Utils/Point.js", "./Utils/QuadTree.js", "./Utils/Rectangle.js", "./Utils/Constants.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Particles = void 0;
     const Utils_js_1 = require("../Utils/Utils.js");
     const InteractionManager_js_1 = require("./Utils/InteractionManager.js");
-    const Particle_js_1 = require("./Particle.js");
     const Point_js_1 = require("./Utils/Point.js");
     const QuadTree_js_1 = require("./Utils/QuadTree.js");
     const Rectangle_js_1 = require("./Utils/Rectangle.js");
     const Constants_js_1 = require("./Utils/Constants.js");
-    const qTreeCapacity = 4;
+    const qTreeCapacity = 4, squareExp = 2, defaultRemoveQuantity = 1;
     const qTreeRectangle = (canvasSize) => {
         const { height, width } = canvasSize, posOffset = -0.25, sizeFactor = 1.5;
         return new Rectangle_js_1.Rectangle(posOffset * width, posOffset * height, sizeFactor * width, sizeFactor * height);
@@ -29,7 +52,7 @@
                     this._pool.push(particle);
                 }
             };
-            this._applyDensity = (options, manualCount, group) => {
+            this._applyDensity = async (options, manualCount, group) => {
                 const numberOptions = options.number;
                 if (!options.number.density?.enable) {
                     if (group === undefined) {
@@ -40,7 +63,7 @@
                     }
                     return;
                 }
-                const densityFactor = this._initDensityFactor(numberOptions.density), optParticlesNumber = numberOptions.value, optParticlesLimit = numberOptions.limit.value > 0 ? numberOptions.limit.value : optParticlesNumber, particlesNumber = Math.min(optParticlesNumber, optParticlesLimit) * densityFactor + manualCount, particlesCount = Math.min(this.count, this.filter((t) => t.group === group).length);
+                const densityFactor = this._initDensityFactor(numberOptions.density), optParticlesNumber = numberOptions.value, minLimit = 0, optParticlesLimit = numberOptions.limit.value > minLimit ? numberOptions.limit.value : optParticlesNumber, particlesNumber = Math.min(optParticlesNumber, optParticlesLimit) * densityFactor + manualCount, particlesCount = Math.min(this.count, this.filter((t) => t.group === group).length);
                 if (group === undefined) {
                     this._limit = numberOptions.limit.value * densityFactor;
                 }
@@ -48,29 +71,28 @@
                     this._groupLimits.set(group, numberOptions.limit.value * densityFactor);
                 }
                 if (particlesCount < particlesNumber) {
-                    this.push(Math.abs(particlesNumber - particlesCount), undefined, options, group);
+                    await this.push(Math.abs(particlesNumber - particlesCount), undefined, options, group);
                 }
                 else if (particlesCount > particlesNumber) {
                     this.removeQuantity(particlesCount - particlesNumber, group);
                 }
             };
             this._initDensityFactor = (densityOptions) => {
-                const container = this._container;
+                const container = this._container, defaultFactor = 1;
                 if (!container.canvas.element || !densityOptions.enable) {
-                    return 1;
+                    return defaultFactor;
                 }
                 const canvas = container.canvas.element, pxRatio = container.retina.pixelRatio;
-                return (canvas.width * canvas.height) / (densityOptions.height * densityOptions.width * pxRatio ** 2);
+                return (canvas.width * canvas.height) / (densityOptions.height * densityOptions.width * pxRatio ** squareExp);
             };
-            this._pushParticle = (position, overrideOptions, group, initializer) => {
+            this._pushParticle = async (position, overrideOptions, group, initializer) => {
                 try {
                     let particle = this._pool.pop();
-                    if (particle) {
-                        particle.init(this._nextId, position, overrideOptions, group);
-                    }
-                    else {
-                        particle = new Particle_js_1.Particle(this._engine, this._nextId, this._container, position, overrideOptions, group);
+                    if (!particle) {
+                        const { Particle } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./Particle.js"))) : new Promise((resolve_1, reject_1) => { require(["./Particle.js"], resolve_1, reject_1); }).then(__importStar));
+                        particle = new Particle(this._engine, this._container);
                     }
+                    await particle.init(this._nextId, position, overrideOptions, group);
                     let canAdd = true;
                     if (initializer) {
                         canAdd = initializer(particle);
@@ -91,7 +113,6 @@
                 }
                 catch (e) {
                     (0, Utils_js_1.getLogger)().warning(`${Constants_js_1.errorPrefix} adding particle: ${e}`);
-                    return;
                 }
             };
             this._removeParticle = (index, group, override) => {
@@ -99,9 +120,9 @@
                 if (!particle || particle.group !== group) {
                     return false;
                 }
-                const zIdx = this._zArray.indexOf(particle);
-                this._array.splice(index, 1);
-                this._zArray.splice(zIdx, 1);
+                const zIdx = this._zArray.indexOf(particle), deleteCount = 1;
+                this._array.splice(index, deleteCount);
+                this._zArray.splice(zIdx, deleteCount);
                 particle.destroy(override);
                 this._engine.dispatchEvent("particleRemoved", {
                     container: this._container,
@@ -123,26 +144,27 @@
             this._needsSort = false;
             this._lastZIndex = 0;
             this._interactionManager = new InteractionManager_js_1.InteractionManager(engine, container);
+            this._pluginsInitialized = false;
             const canvasSize = container.canvas.size;
             this.quadTree = new QuadTree_js_1.QuadTree(qTreeRectangle(canvasSize), qTreeCapacity);
-            this.movers = this._engine.getMovers(container, true);
-            this.updaters = this._engine.getUpdaters(container, true);
+            this.movers = [];
+            this.updaters = [];
         }
         get count() {
             return this._array.length;
         }
-        addManualParticles() {
+        async addManualParticles() {
             const container = this._container, options = container.actualOptions;
             for (const particle of options.manualParticles) {
-                this.addParticle(particle.position ? (0, Utils_js_1.getPosition)(particle.position, container.canvas.size) : undefined, particle.options);
+                await this.addParticle(particle.position ? (0, Utils_js_1.getPosition)(particle.position, container.canvas.size) : undefined, particle.options);
             }
         }
-        addParticle(position, overrideOptions, group, initializer) {
-            const limitOptions = this._container.actualOptions.particles.number.limit, limit = group === undefined ? this._limit : this._groupLimits.get(group) ?? this._limit, currentCount = this.count;
-            if (limit > 0) {
+        async addParticle(position, overrideOptions, group, initializer) {
+            const limitOptions = this._container.actualOptions.particles.number.limit, limit = group === undefined ? this._limit : this._groupLimits.get(group) ?? this._limit, currentCount = this.count, minLimit = 0;
+            if (limit > minLimit) {
                 if (limitOptions.mode === "delete") {
-                    const countToRemove = currentCount + 1 - limit;
-                    if (countToRemove > 0) {
+                    const countOffset = 1, minCount = 0, countToRemove = currentCount + countOffset - limit;
+                    if (countToRemove > minCount) {
                         this.removeQuantity(countToRemove);
                     }
                 }
@@ -152,11 +174,12 @@
                     }
                 }
             }
-            return this._pushParticle(position, overrideOptions, group, initializer);
+            return await this._pushParticle(position, overrideOptions, group, initializer);
         }
         clear() {
             this._array = [];
             this._zArray = [];
+            this._pluginsInitialized = false;
         }
         destroy() {
             this._array = [];
@@ -169,10 +192,10 @@
             canvas.clear();
             await this.update(delta);
             for (const [, plugin] of container.plugins) {
-                canvas.drawPlugin(plugin, delta);
+                await canvas.drawPlugin(plugin, delta);
             }
             for (const p of this._zArray) {
-                p.draw(delta);
+                await p.draw(delta);
             }
         }
         filter(condition) {
@@ -187,13 +210,12 @@
         handleClickMode(mode) {
             this._interactionManager.handleClickMode(mode);
         }
-        init() {
+        async init() {
             const container = this._container, options = container.actualOptions;
             this._lastZIndex = 0;
             this._needsSort = false;
+            await this.initPlugins();
             let handled = false;
-            this.updaters = this._engine.getUpdaters(container, true);
-            this._interactionManager.init();
             for (const [, plugin] of container.plugins) {
                 if (plugin.particlesInitialization !== undefined) {
                     handled = plugin.particlesInitialization();
@@ -202,55 +224,67 @@
                     break;
                 }
             }
-            this._interactionManager.init();
-            for (const [, pathGenerator] of container.pathGenerators) {
-                pathGenerator.init(container);
-            }
-            this.addManualParticles();
+            await this.addManualParticles();
             if (!handled) {
                 const particlesOptions = options.particles, groups = particlesOptions.groups;
                 for (const group in groups) {
                     const groupOptions = groups[group];
                     for (let i = this.count, j = 0; j < groupOptions.number?.value && i < particlesOptions.number.value; i++, j++) {
-                        this.addParticle(undefined, groupOptions, group);
+                        await this.addParticle(undefined, groupOptions, group);
                     }
                 }
                 for (let i = this.count; i < particlesOptions.number.value; i++) {
-                    this.addParticle();
+                    await this.addParticle();
                 }
             }
         }
-        push(nb, mouse, overrideOptions, group) {
+        async initPlugins() {
+            if (this._pluginsInitialized) {
+                return;
+            }
+            const container = this._container;
+            this.movers = await this._engine.getMovers(container, true);
+            this.updaters = await this._engine.getUpdaters(container, true);
+            await this._interactionManager.init();
+            for (const [, pathGenerator] of container.pathGenerators) {
+                await pathGenerator.init(container);
+            }
+        }
+        async push(nb, mouse, overrideOptions, group) {
             for (let i = 0; i < nb; i++) {
-                this.addParticle(mouse?.position, overrideOptions, group);
+                await this.addParticle(mouse?.position, overrideOptions, group);
             }
         }
         async redraw() {
             this.clear();
-            this.init();
+            await this.init();
             await this.draw({ value: 0, factor: 0 });
         }
         remove(particle, group, override) {
             this.removeAt(this._array.indexOf(particle), undefined, group, override);
         }
-        removeAt(index, quantity = 1, group, override) {
-            if (index < 0 || index > this.count) {
+        removeAt(index, quantity = defaultRemoveQuantity, group, override) {
+            const minIndex = 0;
+            if (index < minIndex || index > this.count) {
                 return;
             }
             let deleted = 0;
             for (let i = index; deleted < quantity && i < this.count; i++) {
-                this._removeParticle(i--, group, override) && deleted++;
+                if (this._removeParticle(i--, group, override)) {
+                    deleted++;
+                }
             }
         }
         removeQuantity(quantity, group) {
-            this.removeAt(0, quantity, group);
+            const defaultIndex = 0;
+            this.removeAt(defaultIndex, quantity, group);
         }
-        setDensity() {
-            const options = this._container.actualOptions, groups = options.particles.groups;
+        async setDensity() {
+            const options = this._container.actualOptions, groups = options.particles.groups, manualCount = 0;
             for (const group in groups) {
-                this._applyDensity(groups[group], 0, group);
+                await this._applyDensity(groups[group], manualCount, group);
             }
-            this._applyDensity(options.particles, options.manualParticles.length);
+            await this._applyDensity(options.particles, options.manualParticles.length);
         }
         setLastZIndex(zIndex) {
             this._lastZIndex = zIndex;
@@ -266,7 +300,7 @@
                 pathGenerator.update();
             }
             for (const [, plugin] of container.plugins) {
-                plugin.update && (await plugin.update(delta));
+                await plugin.update?.(delta);
             }
             const resizeFactor = this._resizeFactor;
             for (const particle of this._array) {
@@ -277,15 +311,17 @@
                     particle.initialPosition.y *= resizeFactor.height;
                 }
                 particle.ignoresResizeRatio = false;
-                await this._interactionManager.reset(particle);
+                this._interactionManager.reset(particle);
                 for (const [, plugin] of this._container.plugins) {
                     if (particle.destroyed) {
                         break;
                     }
-                    plugin.particleUpdate && plugin.particleUpdate(particle, delta);
+                    plugin.particleUpdate?.(particle, delta);
                 }
                 for (const mover of this.movers) {
-                    mover.isEnabled(particle) && mover.move(particle, delta);
+                    if (mover.isEnabled(particle)) {
+                        await mover.move(particle, delta);
+                    }
                 }
                 if (particle.destroyed) {
                     particlesToDelete.add(particle);
@@ -310,7 +346,7 @@
             await this._interactionManager.externalInteract(delta);
             for (const particle of this._array) {
                 for (const updater of this.updaters) {
-                    updater.update(particle, delta);
+                    await updater.update(particle, delta);
                 }
                 if (!particle.destroyed && !particle.spawning) {
                     await this._interactionManager.particlesInteract(particle, delta);
@@ -320,7 +356,8 @@
             if (this._needsSort) {
                 const zArray = this._zArray;
                 zArray.sort((a, b) => b.position.z - a.position.z || a.id - b.id);
-                this._lastZIndex = zArray[zArray.length - 1].position.z;
+                const lengthOffset = 1;
+                this._lastZIndex = zArray[zArray.length - lengthOffset].position.z;
                 this._needsSort = false;
             }
         }

package/umd/Core/Retina.js

@@ -12,16 +12,17 @@
     exports.Retina = void 0;
     const NumberUtils_js_1 = require("../Utils/NumberUtils.js");
     const Utils_js_1 = require("../Utils/Utils.js");
+    const defaultRatio = 1, defaultReduceFactor = 1;
     class Retina {
         constructor(container) {
             this.container = container;
-            this.pixelRatio = 1;
-            this.reduceFactor = 1;
+            this.pixelRatio = defaultRatio;
+            this.reduceFactor = defaultReduceFactor;
         }
         init() {
             const container = this.container, options = container.actualOptions;
-            this.pixelRatio = !options.detectRetina || (0, Utils_js_1.isSsr)() ? 1 : window.devicePixelRatio;
-            this.reduceFactor = 1;
+            this.pixelRatio = !options.detectRetina || (0, Utils_js_1.isSsr)() ? defaultRatio : window.devicePixelRatio;
+            this.reduceFactor = defaultReduceFactor;
             const ratio = this.pixelRatio, canvas = container.canvas;
             if (canvas.element) {
                 const element = canvas.element;

package/umd/Core/Utils/Circle.js

@@ -13,6 +13,7 @@
     const Range_js_1 = require("./Range.js");
     const Rectangle_js_1 = require("./Rectangle.js");
     const NumberUtils_js_1 = require("../../Utils/NumberUtils.js");
+    const squareExp = 2;
     class Circle extends Range_js_1.Range {
         constructor(x, y, radius) {
             super(x, y);
@@ -24,12 +25,12 @@
         intersects(range) {
             const pos1 = this.position, pos2 = range.position, distPos = { x: Math.abs(pos2.x - pos1.x), y: Math.abs(pos2.y - pos1.y) }, r = this.radius;
             if (range instanceof Circle) {
-                const rSum = r + range.radius, dist = Math.sqrt(distPos.x ** 2 + distPos.y ** 2);
+                const rSum = r + range.radius, dist = Math.sqrt(distPos.x ** squareExp + distPos.y ** squareExp);
                 return rSum > dist;
             }
             else if (range instanceof Rectangle_js_1.Rectangle) {
-                const { width, height } = range.size, edges = Math.pow(distPos.x - width, 2) + Math.pow(distPos.y - height, 2);
-                return (edges <= r ** 2 ||
+                const { width, height } = range.size, edges = Math.pow(distPos.x - width, squareExp) + Math.pow(distPos.y - height, squareExp);
+                return (edges <= r ** squareExp ||
                     (distPos.x <= r + width && distPos.y <= r + height) ||
                     distPos.x <= width ||
                     distPos.y <= height);

package/umd/Core/Utils/Constants.js

@@ -9,7 +9,7 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.errorPrefix = exports.visibilityChangeEvent = exports.resizeEvent = exports.touchCancelEvent = exports.touchMoveEvent = exports.touchEndEvent = exports.touchStartEvent = exports.mouseMoveEvent = exports.mouseOutEvent = exports.mouseLeaveEvent = exports.mouseUpEvent = exports.mouseDownEvent = exports.generatedAttribute = void 0;
+    exports.millisecondsToSeconds = exports.halfRandom = exports.percentDenominator = exports.errorPrefix = exports.visibilityChangeEvent = exports.resizeEvent = exports.touchCancelEvent = exports.touchMoveEvent = exports.touchEndEvent = exports.touchStartEvent = exports.mouseMoveEvent = exports.mouseOutEvent = exports.mouseLeaveEvent = exports.mouseUpEvent = exports.mouseDownEvent = exports.generatedAttribute = void 0;
     exports.generatedAttribute = "generated";
     exports.mouseDownEvent = "pointerdown";
     exports.mouseUpEvent = "pointerup";
@@ -23,4 +23,7 @@
     exports.resizeEvent = "resize";
     exports.visibilityChangeEvent = "visibilitychange";
     exports.errorPrefix = "tsParticles - Error";
+    exports.percentDenominator = 100;
+    exports.halfRandom = 0.5;
+    exports.millisecondsToSeconds = 1000;
 });

package/umd/Core/Utils/EventListeners.js

@@ -12,6 +12,7 @@
     exports.EventListeners = void 0;
     const Utils_js_1 = require("../../Utils/Utils.js");
     const Constants_js_1 = require("./Constants.js");
+    const double = 2;
     function manageListener(element, event, handler, add, options) {
         if (add) {
             let addOptions = { passive: true };
@@ -44,13 +45,14 @@
                     (0, Utils_js_1.executeOnSingleOrMultiple)(onClick.mode, (mode) => this.container.handleClickMode(mode));
                 }
                 if (e.type === "touchend") {
-                    setTimeout(() => this._mouseTouchFinish(), 500);
+                    const touchDelay = 500;
+                    setTimeout(() => this._mouseTouchFinish(), touchDelay);
                 }
             };
             this._handleThemeChange = (e) => {
                 const mediaEvent = e, container = this.container, options = container.options, defaultThemes = options.defaultThemes, themeName = mediaEvent.matches ? defaultThemes.dark : defaultThemes.light, theme = options.themes.find((theme) => theme.name === themeName);
                 if (theme && theme.default.auto) {
-                    container.loadTheme(themeName);
+                    void container.loadTheme(themeName);
                 }
             };
             this._handleVisibilityChange = () => {
@@ -65,7 +67,7 @@
                 }
                 else {
                     container.pageHidden = false;
-                    if (container.getAnimationStatus()) {
+                    if (container.animationStatus) {
                         container.play(true);
                     }
                     else {
@@ -73,15 +75,16 @@
                     }
                 }
             };
-            this._handleWindowResize = async () => {
+            this._handleWindowResize = () => {
                 if (this._resizeTimeout) {
                     clearTimeout(this._resizeTimeout);
                     delete this._resizeTimeout;
                 }
-                this._resizeTimeout = setTimeout(async () => {
+                const handleResize = async () => {
                     const canvas = this.container.canvas;
-                    canvas && (await canvas.windowResize());
-                }, this.container.actualOptions.interactivity.events.resize.delay * 1000);
+                    await canvas?.windowResize();
+                };
+                this._resizeTimeout = setTimeout(() => void handleResize(), this.container.actualOptions.interactivity.events.resize.delay * Constants_js_1.millisecondsToSeconds);
             };
             this._manageInteractivityListeners = (mouseLeaveTmpEvent, add) => {
                 const handlers = this._handlers, container = this.container, options = container.actualOptions;
@@ -167,12 +170,12 @@
                     delete this._resizeObserver;
                 }
                 else if (!this._resizeObserver && add && canvasEl) {
-                    this._resizeObserver = new ResizeObserver(async (entries) => {
+                    this._resizeObserver = new ResizeObserver((entries) => {
                         const entry = entries.find((e) => e.target === canvasEl);
                         if (!entry) {
                             return;
                         }
-                        await this._handleWindowResize();
+                        this._handleWindowResize();
                     });
                     this._resizeObserver.observe(canvasEl);
                 }
@@ -223,7 +226,7 @@
             };
             this._mouseTouchMove = (e) => {
                 const container = this.container, options = container.actualOptions, interactivity = container.interactivity, canvasEl = container.canvas.element;
-                if (!interactivity || !interactivity.element) {
+                if (!interactivity?.element) {
                     return;
                 }
                 interactivity.mouse.inside = true;
@@ -245,8 +248,8 @@
                         if (source && target && canvasEl) {
                             const sourceRect = source.getBoundingClientRect(), targetRect = target.getBoundingClientRect(), canvasRect = canvasEl.getBoundingClientRect();
                             pos = {
-                                x: mouseEvent.offsetX + 2 * sourceRect.left - (targetRect.left + canvasRect.left),
-                                y: mouseEvent.offsetY + 2 * sourceRect.top - (targetRect.top + canvasRect.top),
+                                x: mouseEvent.offsetX + double * sourceRect.left - (targetRect.left + canvasRect.left),
+                                y: mouseEvent.offsetY + double * sourceRect.top - (targetRect.top + canvasRect.top),
                             };
                         }
                         else {
@@ -266,10 +269,10 @@
                 else {
                     this._canPush = e.type !== "touchmove";
                     if (canvasEl) {
-                        const touchEvent = e, lastTouch = touchEvent.touches[touchEvent.touches.length - 1], canvasRect = canvasEl.getBoundingClientRect();
+                        const touchEvent = e, lengthOffset = 1, lastTouch = touchEvent.touches[touchEvent.touches.length - lengthOffset], canvasRect = canvasEl.getBoundingClientRect(), defaultCoordinate = 0;
                         pos = {
-                            x: lastTouch.clientX - (canvasRect.left ?? 0),
-                            y: lastTouch.clientY - (canvasRect.top ?? 0),
+                            x: lastTouch.clientX - (canvasRect.left ?? defaultCoordinate),
+                            y: lastTouch.clientY - (canvasRect.top ?? defaultCoordinate),
                         };
                     }
                 }

package/umd/Core/Utils/ExternalInteractorBase.js

@@ -12,8 +12,8 @@
     exports.ExternalInteractorBase = void 0;
     class ExternalInteractorBase {
         constructor(container) {
-            this.container = container;
             this.type = "external";
+            this.container = container;
         }
     }
     exports.ExternalInteractorBase = ExternalInteractorBase;

package/umd/Core/Utils/InteractionManager.js

@@ -14,21 +14,24 @@
         constructor(engine, container) {
             this.container = container;
             this._engine = engine;
-            this._interactors = engine.getInteractors(this.container, true);
+            this._interactors = [];
             this._externalInteractors = [];
             this._particleInteractors = [];
         }
         async externalInteract(delta) {
             for (const interactor of this._externalInteractors) {
-                interactor.isEnabled() && (await interactor.interact(delta));
+                if (interactor.isEnabled()) {
+                    await interactor.interact(delta);
+                }
             }
         }
         handleClickMode(mode) {
             for (const interactor of this._externalInteractors) {
-                interactor.handleClickMode && interactor.handleClickMode(mode);
+                interactor.handleClickMode?.(mode);
             }
         }
-        init() {
+        async init() {
+            this._interactors = await this._engine.getInteractors(this.container, true);
             this._externalInteractors = [];
             this._particleInteractors = [];
             for (const interactor of this._interactors) {
@@ -48,15 +51,21 @@
                 interactor.clear(particle, delta);
             }
             for (const interactor of this._particleInteractors) {
-                interactor.isEnabled(particle) && (await interactor.interact(particle, delta));
+                if (interactor.isEnabled(particle)) {
+                    await interactor.interact(particle, delta);
+                }
             }
         }
-        async reset(particle) {
+        reset(particle) {
             for (const interactor of this._externalInteractors) {
-                interactor.isEnabled() && interactor.reset(particle);
+                if (interactor.isEnabled()) {
+                    interactor.reset(particle);
+                }
             }
             for (const interactor of this._particleInteractors) {
-                interactor.isEnabled(particle) && interactor.reset(particle);
+                if (interactor.isEnabled(particle)) {
+                    interactor.reset(particle);
+                }
             }
         }
     }

package/umd/Core/Utils/ParticlesInteractorBase.js

@@ -12,8 +12,8 @@
     exports.ParticlesInteractorBase = void 0;
     class ParticlesInteractorBase {
         constructor(container) {
-            this.container = container;
             this.type = "particles";
+            this.container = container;
         }
     }
     exports.ParticlesInteractorBase = ParticlesInteractorBase;

package/umd/Core/Utils/QuadTree.js

@@ -13,14 +13,16 @@
     const Circle_js_1 = require("./Circle.js");
     const Rectangle_js_1 = require("./Rectangle.js");
     const NumberUtils_js_1 = require("../../Utils/NumberUtils.js");
+    const half = 0.5, double = 2, subdivideCount = 4;
     class QuadTree {
         constructor(rectangle, capacity) {
             this.rectangle = rectangle;
             this.capacity = capacity;
             this._subdivide = () => {
                 const { x, y } = this.rectangle.position, { width, height } = this.rectangle.size, { capacity } = this;
-                for (let i = 0; i < 4; i++) {
-                    this._subs.push(new QuadTree(new Rectangle_js_1.Rectangle(x + width * 0.5 * (i % 2), y + height * 0.5 * (Math.round(i * 0.5) - (i % 2)), width * 0.5, height * 0.5), capacity));
+                for (let i = 0; i < subdivideCount; i++) {
+                    const fixedIndex = i % double;
+                    this._subs.push(new QuadTree(new Rectangle_js_1.Rectangle(x + width * half * fixedIndex, y + height * half * (Math.round(i * half) - fixedIndex), width * half, height * half), capacity));
                 }
                 this._divided = true;
             };
@@ -42,7 +44,7 @@
             return this._subs.some((sub) => sub.insert(point));
         }
         query(range, check, found) {
-            const res = found || [];
+            const res = found ?? [];
             if (!range.intersects(this.rectangle)) {
                 return [];
             }

package/umd/Core/Utils/Vector.js

@@ -11,12 +11,17 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Vector = void 0;
     const Vector3d_js_1 = require("./Vector3d.js");
+    const origin = {
+        x: 0,
+        y: 0,
+        z: 0,
+    };
     class Vector extends Vector3d_js_1.Vector3d {
         constructor(xOrCoords, y) {
-            super(xOrCoords, y, 0);
+            super(xOrCoords, y, origin.z);
         }
         static get origin() {
-            return Vector.create(0, 0);
+            return Vector.create(origin.x, origin.y);
         }
         static clone(source) {
             return Vector.create(source.x, source.y);