@tsparticles/engine 3.2.1 → 3.3.0

package/types/Utils/TypeUtils.d.ts

@@ -0,0 +1,6 @@
+export declare function isBoolean(arg: unknown): arg is boolean;
+export declare function isString(arg: unknown): arg is string;
+export declare function isNumber(arg: unknown): arg is number;
+export declare function isFunction(arg: unknown): arg is Function;
+export declare function isObject<T extends object>(arg: unknown): arg is T;
+export declare function isArray<T>(arg: unknown): arg is T[];

package/types/Utils/Utils.d.ts

@@ -47,11 +47,5 @@ export declare function findItemFromSingleOrMultiple<T>(obj: SingleOrMultiple<T>
 export declare function initParticleNumericAnimationValue(options: RangedAnimationValueWithRandom, pxRatio: number): IParticleNumericValueAnimation;
 export declare function getPosition(position: ICoordinatesWithMode, canvasSize: IDimension): ICoordinates;
 export declare function getSize(size: IDimensionWithMode, canvasSize: IDimension): IDimension;
-export declare function isBoolean(arg: unknown): arg is boolean;
-export declare function isString(arg: unknown): arg is string;
-export declare function isNumber(arg: unknown): arg is number;
-export declare function isFunction(arg: unknown): arg is Function;
-export declare function isObject<T extends object>(arg: unknown): arg is T;
-export declare function isArray<T>(arg: unknown): arg is T[];
 export declare function updateAnimation(particle: Particle, data: IParticleNumericValueAnimation, changeDirection: boolean, destroyType: DestroyType | keyof typeof DestroyType, delta: IDelta): void;
 export {};

package/types/exports.d.ts

@@ -1,12 +1,9 @@
-export * from "./Core/Utils/Circle.js";
 export * from "./Core/Utils/Constants.js";
 export * from "./Core/Utils/ExternalInteractorBase.js";
 export * from "./Core/Utils/ParticlesInteractorBase.js";
 export * from "./Core/Utils/Point.js";
-export * from "./Core/Utils/Range.js";
-export * from "./Core/Utils/Rectangle.js";
-export * from "./Core/Utils/Vector.js";
-export * from "./Core/Utils/Vector3d.js";
+export * from "./Core/Utils/Ranges.js";
+export * from "./Core/Utils/Vectors.js";
 export * from "./Enums/Directions/MoveDirection.js";
 export * from "./Enums/Directions/RotateDirection.js";
 export * from "./Enums/Directions/OutModeDirection.js";
@@ -86,3 +83,4 @@ export * from "./Utils/NumberUtils.js";
 export * from "./Utils/OptionsUtils.js";
 export * from "./Utils/RgbColorManager.js";
 export * from "./Utils/Utils.js";
+export * from "./Utils/TypeUtils.js";

package/umd/Core/Canvas.js

@@ -282,11 +282,11 @@
         drawAsync(cb) {
             const ctx = this._context;
             if (!ctx) {
-                return Promise.resolve(undefined);
+                return undefined;
             }
             return cb(ctx);
         }
-        async drawParticle(particle, delta) {
+        drawParticle(particle, delta) {
             if (particle.spawning || particle.destroyed) {
                 return;
             }
@@ -305,13 +305,13 @@
             if (!fColor && !sColor) {
                 return;
             }
-            await this.drawAsync(async (ctx) => {
+            this.draw((ctx) => {
                 const container = this.container, options = container.actualOptions, zIndexOptions = particle.options.zIndex, zIndexFactorOffset = 1, zIndexFactor = zIndexFactorOffset - particle.zIndexFactor, zOpacityFactor = zIndexFactor ** zIndexOptions.opacityRate, defaultOpacity = 1, opacity = particle.bubble.opacity ?? particle.opacity?.value ?? defaultOpacity, strokeOpacity = particle.strokeOpacity ?? opacity, zOpacity = opacity * zOpacityFactor, zStrokeOpacity = strokeOpacity * zOpacityFactor, transform = {}, colorStyles = {
                     fill: fColor ? (0, ColorUtils_js_1.getStyleFromHsl)(fColor, zOpacity) : undefined,
                 };
                 colorStyles.stroke = sColor ? (0, ColorUtils_js_1.getStyleFromHsl)(sColor, zStrokeOpacity) : colorStyles.fill;
                 this._applyPreDrawUpdaters(ctx, particle, radius, zOpacity, colorStyles, transform);
-                await (0, CanvasUtils_js_1.drawParticle)({
+                (0, CanvasUtils_js_1.drawParticle)({
                     container,
                     context: ctx,
                     particle,
@@ -327,11 +327,11 @@
                 this._applyPostDrawUpdaters(particle);
             });
         }
-        async drawParticlePlugin(plugin, particle, delta) {
-            await this.drawAsync((ctx) => (0, CanvasUtils_js_1.drawParticlePlugin)(ctx, plugin, particle, delta));
+        drawParticlePlugin(plugin, particle, delta) {
+            this.draw((ctx) => (0, CanvasUtils_js_1.drawParticlePlugin)(ctx, plugin, particle, delta));
         }
-        async drawPlugin(plugin, delta) {
-            await this.drawAsync((ctx) => (0, CanvasUtils_js_1.drawPlugin)(ctx, plugin, delta));
+        drawPlugin(plugin, delta) {
+            this.draw((ctx) => (0, CanvasUtils_js_1.drawPlugin)(ctx, plugin, delta));
         }
         async init() {
             this._safeMutationObserver((obs) => obs.disconnect());
@@ -484,7 +484,7 @@
                 return;
             }
             const container = this.container, needsRefresh = container.updateActualOptions();
-            await container.particles.setDensity();
+            container.particles.setDensity();
             this._applyResizePlugins();
             if (needsRefresh) {
                 await container.refresh();

package/umd/Core/Container.js

@@ -45,14 +45,14 @@
                         continue;
                     }
                     if (entry.isIntersecting) {
-                        this.play();
+                        void this.play();
                     }
                     else {
                         this.pause();
                     }
                 }
             };
-            this._nextFrame = async (timestamp) => {
+            this._nextFrame = (timestamp) => {
                 try {
                     if (!this._smooth &&
                         this._lastFrameTime !== undefined &&
@@ -68,7 +68,7 @@
                         this.draw(false);
                         return;
                     }
-                    await this.particles.draw(delta);
+                    this.particles.draw(delta);
                     if (!this.alive()) {
                         this.destroy();
                         return;
@@ -249,14 +249,14 @@
                 return;
             }
             let refreshTime = force;
-            const frame = async (timestamp) => {
+            const frame = (timestamp) => {
                 if (refreshTime) {
                     this._lastFrameTime = undefined;
                     refreshTime = false;
                 }
-                await this._nextFrame(timestamp);
+                this._nextFrame(timestamp);
             };
-            this._drawAnimationFrame = requestAnimationFrame((timestamp) => void frame(timestamp));
+            this._drawAnimationFrame = requestAnimationFrame((timestamp) => frame(timestamp));
         }
         async export(type, options = {}) {
             for (const [, plugin] of this.plugins) {
@@ -328,7 +328,7 @@
             }
             this._engine.dispatchEvent("containerInit", { container: this });
             await this.particles.init();
-            await this.particles.setDensity();
+            this.particles.setDensity();
             for (const [, plugin] of this.plugins) {
                 plugin.particlesSetup?.();
             }

package/umd/Core/Engine.js

@@ -86,7 +86,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
             return res;
         }
         get version() {
-            return "3.2.1";
+            return "3.3.0";
         }
         addConfig(config) {
             const key = config.key ?? config.name ?? "default";

package/umd/Core/Particle.js

@@ -4,19 +4,18 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../Utils/NumberUtils.js", "../Utils/Utils.js", "./Utils/Constants.js", "../Utils/ColorUtils.js", "../Options/Classes/Interactivity/Interactivity.js", "./Utils/Vector.js", "./Utils/Vector3d.js", "../Utils/CanvasUtils.js", "../Utils/OptionsUtils.js"], factory);
+        define(["require", "exports", "./Utils/Vectors.js", "../Utils/NumberUtils.js", "../Utils/Utils.js", "./Utils/Constants.js", "../Utils/ColorUtils.js", "../Options/Classes/Interactivity/Interactivity.js", "../Utils/CanvasUtils.js", "../Utils/OptionsUtils.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Particle = void 0;
+    const Vectors_js_1 = require("./Utils/Vectors.js");
     const NumberUtils_js_1 = require("../Utils/NumberUtils.js");
     const Utils_js_1 = require("../Utils/Utils.js");
     const Constants_js_1 = require("./Utils/Constants.js");
     const ColorUtils_js_1 = require("../Utils/ColorUtils.js");
     const Interactivity_js_1 = require("../Options/Classes/Interactivity/Interactivity.js");
-    const Vector_js_1 = require("./Utils/Vector.js");
-    const Vector3d_js_1 = require("./Utils/Vector3d.js");
     const CanvasUtils_js_1 = require("../Utils/CanvasUtils.js");
     const OptionsUtils_js_1 = require("../Utils/OptionsUtils.js");
     const defaultRetryCount = 0, double = 2, half = 0.5, squareExp = 2;
@@ -59,13 +58,13 @@
                 for (const [, plugin] of container.plugins) {
                     const pluginPos = plugin.particlePosition !== undefined ? plugin.particlePosition(position, this) : undefined;
                     if (pluginPos) {
-                        return Vector3d_js_1.Vector3d.create(pluginPos.x, pluginPos.y, zIndex);
+                        return Vectors_js_1.Vector3d.create(pluginPos.x, pluginPos.y, zIndex);
                     }
                 }
                 const canvasSize = container.canvas.size, exactPosition = (0, NumberUtils_js_1.calcExactPositionOrRandomFromSize)({
                     size: canvasSize,
                     position: position,
-                }), pos = Vector3d_js_1.Vector3d.create(exactPosition.x, exactPosition.y, zIndex), radius = this.getRadius(), outModes = this.options.move.outModes, fixHorizontal = (outMode) => {
+                }), pos = Vectors_js_1.Vector3d.create(exactPosition.x, exactPosition.y, zIndex), radius = this.getRadius(), outModes = this.options.move.outModes, fixHorizontal = (outMode) => {
                     fixOutMode({
                         outMode,
                         checkModes: ["bounce"],
@@ -161,7 +160,7 @@
                         this.outType = "outside";
                         break;
                 }
-                this.offset = Vector_js_1.Vector.origin;
+                this.offset = Vectors_js_1.Vector.origin;
             };
             this._engine = engine;
         }
@@ -188,12 +187,12 @@
                 },
             });
         }
-        async draw(delta) {
+        draw(delta) {
             const container = this.container, canvas = container.canvas;
             for (const [, plugin] of container.plugins) {
-                await canvas.drawParticlePlugin(plugin, this, delta);
+                canvas.drawParticlePlugin(plugin, this, delta);
             }
-            await canvas.drawParticle(this, delta);
+            canvas.drawParticle(this, delta);
         }
         getFillColor() {
             return this._getRollColor(this.bubble.color ?? (0, ColorUtils_js_1.getHslFromAnimation)(this.color));
@@ -214,7 +213,7 @@
         getStrokeColor() {
             return this._getRollColor(this.bubble.color ?? (0, ColorUtils_js_1.getHslFromAnimation)(this.strokeColor));
         }
-        async init(id, position, overrideOptions, group) {
+        init(id, position, overrideOptions, group) {
             const container = this.container, engine = this._engine;
             this.id = id;
             this.group = group;
@@ -278,7 +277,7 @@
             if (pathOptions.generator) {
                 this.pathGenerator = this._engine.getPathGenerator(pathOptions.generator);
                 if (this.pathGenerator && container.addPath(pathOptions.generator, this.pathGenerator)) {
-                    await this.pathGenerator.init(container);
+                    this.pathGenerator.init(container);
                 }
             }
             container.retina.initParticle(this);
@@ -307,7 +306,7 @@
                 }
             }
             if (effectDrawer?.loadEffect) {
-                await effectDrawer.loadEffect(this);
+                effectDrawer.loadEffect(this);
             }
             let shapeDrawer = container.shapeDrawers.get(this.shape);
             if (!shapeDrawer) {
@@ -317,7 +316,7 @@
                 }
             }
             if (shapeDrawer?.loadShape) {
-                await shapeDrawer.loadShape(this);
+                shapeDrawer.loadShape(this);
             }
             const sideCountFunc = shapeDrawer?.getSidesCount;
             if (sideCountFunc) {
@@ -326,13 +325,13 @@
             this.spawning = false;
             this.shadowColor = (0, ColorUtils_js_1.rangeColorToRgb)(this.options.shadow.color);
             for (const updater of particles.updaters) {
-                await updater.init(this);
+                updater.init(this);
             }
             for (const mover of particles.movers) {
-                await mover.init?.(this);
+                mover.init?.(this);
             }
-            await effectDrawer?.particleInit?.(container, this);
-            await shapeDrawer?.particleInit?.(container, this);
+            effectDrawer?.particleInit?.(container, this);
+            shapeDrawer?.particleInit?.(container, this);
             for (const [, plugin] of container.plugins) {
                 plugin.particleCreated?.(this);
             }

package/umd/Core/Particles.js

@@ -1,49 +1,26 @@
-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", "./Utils/Point.js", "./Utils/QuadTree.js", "./Utils/Rectangle.js", "./Utils/Constants.js"], factory);
+        define(["require", "exports", "../Utils/Utils.js", "./Utils/InteractionManager.js", "./Particle.js", "./Utils/Point.js", "./Utils/QuadTree.js", "./Utils/Ranges.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 Ranges_js_1 = require("./Utils/Ranges.js");
     const Constants_js_1 = require("./Utils/Constants.js");
     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);
+        return new Ranges_js_1.Rectangle(posOffset * width, posOffset * height, sizeFactor * width, sizeFactor * height);
     };
     class Particles {
         constructor(engine, container) {
@@ -52,7 +29,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
                     this._pool.push(particle);
                 }
             };
-            this._applyDensity = async (options, manualCount, group) => {
+            this._applyDensity = (options, manualCount, group) => {
                 const numberOptions = options.number;
                 if (!options.number.density?.enable) {
                     if (group === undefined) {
@@ -71,7 +48,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
                     this._groupLimits.set(group, numberOptions.limit.value * densityFactor);
                 }
                 if (particlesCount < particlesNumber) {
-                    await this.push(Math.abs(particlesNumber - particlesCount), undefined, options, group);
+                    this.push(Math.abs(particlesNumber - particlesCount), undefined, options, group);
                 }
                 else if (particlesCount > particlesNumber) {
                     this.removeQuantity(particlesCount - particlesNumber, group);
@@ -85,14 +62,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
                 const canvas = container.canvas.element, pxRatio = container.retina.pixelRatio;
                 return (canvas.width * canvas.height) / (densityOptions.height * densityOptions.width * pxRatio ** squareExp);
             };
-            this._pushParticle = async (position, overrideOptions, group, initializer) => {
+            this._pushParticle = (position, overrideOptions, group, initializer) => {
                 try {
                     let particle = this._pool.pop();
                     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);
+                        particle = new Particle_js_1.Particle(this._engine, this._container);
                     }
-                    await particle.init(this._nextId, position, overrideOptions, group);
+                    particle.init(this._nextId, position, overrideOptions, group);
                     let canAdd = true;
                     if (initializer) {
                         canAdd = initializer(particle);
@@ -153,13 +129,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
         get count() {
             return this._array.length;
         }
-        async addManualParticles() {
+        addManualParticles() {
             const container = this._container, options = container.actualOptions;
             for (const particle of options.manualParticles) {
-                await this.addParticle(particle.position ? (0, Utils_js_1.getPosition)(particle.position, container.canvas.size) : undefined, particle.options);
+                this.addParticle(particle.position ? (0, Utils_js_1.getPosition)(particle.position, container.canvas.size) : undefined, particle.options);
             }
         }
-        async addParticle(position, overrideOptions, group, initializer) {
+        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") {
@@ -174,7 +150,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
                     }
                 }
             }
-            return await this._pushParticle(position, overrideOptions, group, initializer);
+            return this._pushParticle(position, overrideOptions, group, initializer);
         }
         clear() {
             this._array = [];
@@ -187,15 +163,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
             this.movers = [];
             this.updaters = [];
         }
-        async draw(delta) {
+        draw(delta) {
             const container = this._container, canvas = container.canvas;
             canvas.clear();
-            await this.update(delta);
+            this.update(delta);
             for (const [, plugin] of container.plugins) {
-                await canvas.drawPlugin(plugin, delta);
+                canvas.drawPlugin(plugin, delta);
             }
             for (const p of this._zArray) {
-                await p.draw(delta);
+                p.draw(delta);
             }
         }
         filter(condition) {
@@ -224,17 +200,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
                     break;
                 }
             }
-            await this.addManualParticles();
+            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++) {
-                        await this.addParticle(undefined, groupOptions, group);
+                        this.addParticle(undefined, groupOptions, group);
                     }
                 }
                 for (let i = this.count; i < particlesOptions.number.value; i++) {
-                    await this.addParticle();
+                    this.addParticle();
                 }
             }
         }
@@ -247,18 +223,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
             this.updaters = await this._engine.getUpdaters(container, true);
             await this._interactionManager.init();
             for (const [, pathGenerator] of container.pathGenerators) {
-                await pathGenerator.init(container);
+                pathGenerator.init(container);
             }
         }
-        async push(nb, mouse, overrideOptions, group) {
+        push(nb, mouse, overrideOptions, group) {
             for (let i = 0; i < nb; i++) {
-                await this.addParticle(mouse?.position, overrideOptions, group);
+                this.addParticle(mouse?.position, overrideOptions, group);
             }
         }
         async redraw() {
             this.clear();
             await this.init();
-            await this.draw({ value: 0, factor: 0 });
+            this.draw({ value: 0, factor: 0 });
         }
         remove(particle, group, override) {
             this.removeAt(this._array.indexOf(particle), undefined, group, override);
@@ -279,12 +255,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
             const defaultIndex = 0;
             this.removeAt(defaultIndex, quantity, group);
         }
-        async setDensity() {
+        setDensity() {
             const options = this._container.actualOptions, groups = options.particles.groups, manualCount = 0;
             for (const group in groups) {
-                await this._applyDensity(groups[group], manualCount, group);
+                this._applyDensity(groups[group], manualCount, group);
             }
-            await this._applyDensity(options.particles, options.manualParticles.length);
+            this._applyDensity(options.particles, options.manualParticles.length);
         }
         setLastZIndex(zIndex) {
             this._lastZIndex = zIndex;
@@ -293,14 +269,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
         setResizeFactor(factor) {
             this._resizeFactor = factor;
         }
-        async update(delta) {
+        update(delta) {
             const container = this._container, particlesToDelete = new Set();
             this.quadTree = new QuadTree_js_1.QuadTree(qTreeRectangle(container.canvas.size), qTreeCapacity);
             for (const [, pathGenerator] of container.pathGenerators) {
                 pathGenerator.update();
             }
             for (const [, plugin] of container.plugins) {
-                await plugin.update?.(delta);
+                plugin.update?.(delta);
             }
             const resizeFactor = this._resizeFactor;
             for (const particle of this._array) {
@@ -320,7 +296,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
                 }
                 for (const mover of this.movers) {
                     if (mover.isEnabled(particle)) {
-                        await mover.move(particle, delta);
+                        mover.move(particle, delta);
                     }
                 }
                 if (particle.destroyed) {
@@ -343,13 +319,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
                 }
                 this._addToPool(...particlesToDelete);
             }
-            await this._interactionManager.externalInteract(delta);
+            this._interactionManager.externalInteract(delta);
             for (const particle of this._array) {
                 for (const updater of this.updaters) {
-                    await updater.update(particle, delta);
+                    updater.update(particle, delta);
                 }
                 if (!particle.destroyed && !particle.spawning) {
-                    await this._interactionManager.particlesInteract(particle, delta);
+                    this._interactionManager.particlesInteract(particle, delta);
                 }
             }
             delete this._resizeFactor;

package/umd/Core/Utils/EventListeners.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../../Utils/Utils.js", "./Constants.js"], factory);
+        define(["require", "exports", "../../Utils/Utils.js", "./Constants.js", "../../Utils/TypeUtils.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -12,11 +12,12 @@
     exports.EventListeners = void 0;
     const Utils_js_1 = require("../../Utils/Utils.js");
     const Constants_js_1 = require("./Constants.js");
+    const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
     const double = 2;
     function manageListener(element, event, handler, add, options) {
         if (add) {
             let addOptions = { passive: true };
-            if ((0, Utils_js_1.isBoolean)(options)) {
+            if ((0, TypeUtils_js_1.isBoolean)(options)) {
                 addOptions.capture = options;
             }
             else if (options !== undefined) {
@@ -68,10 +69,10 @@
                 else {
                     container.pageHidden = false;
                     if (container.animationStatus) {
-                        container.play(true);
+                        void container.play(true);
                     }
                     else {
-                        container.draw(true);
+                        void container.draw(true);
                     }
                 }
             };

package/umd/Core/Utils/InteractionManager.js

@@ -18,10 +18,10 @@
             this._externalInteractors = [];
             this._particleInteractors = [];
         }
-        async externalInteract(delta) {
+        externalInteract(delta) {
             for (const interactor of this._externalInteractors) {
                 if (interactor.isEnabled()) {
-                    await interactor.interact(delta);
+                    interactor.interact(delta);
                 }
             }
         }
@@ -46,13 +46,13 @@
                 interactor.init();
             }
         }
-        async particlesInteract(particle, delta) {
+        particlesInteract(particle, delta) {
             for (const interactor of this._externalInteractors) {
                 interactor.clear(particle, delta);
             }
             for (const interactor of this._particleInteractors) {
                 if (interactor.isEnabled(particle)) {
-                    await interactor.interact(particle, delta);
+                    interactor.interact(particle, delta);
                 }
             }
         }

package/umd/Core/Utils/QuadTree.js

@@ -4,14 +4,13 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./Circle.js", "./Rectangle.js", "../../Utils/NumberUtils.js"], factory);
+        define(["require", "exports", "./Ranges.js", "../../Utils/NumberUtils.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.QuadTree = void 0;
-    const Circle_js_1 = require("./Circle.js");
-    const Rectangle_js_1 = require("./Rectangle.js");
+    const Ranges_js_1 = require("./Ranges.js");
     const NumberUtils_js_1 = require("../../Utils/NumberUtils.js");
     const half = 0.5, double = 2, subdivideCount = 4;
     class QuadTree {
@@ -22,7 +21,7 @@
                 const { x, y } = this.rectangle.position, { width, height } = this.rectangle.size, { capacity } = this;
                 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._subs.push(new QuadTree(new Ranges_js_1.Rectangle(x + width * half * fixedIndex, y + height * half * (Math.round(i * half) - fixedIndex), width * half, height * half), capacity));
                 }
                 this._divided = true;
             };
@@ -43,8 +42,8 @@
             }
             return this._subs.some((sub) => sub.insert(point));
         }
-        query(range, check, found) {
-            const res = found ?? [];
+        query(range, check) {
+            const res = [];
             if (!range.intersects(this.rectangle)) {
                 return [];
             }
@@ -58,16 +57,16 @@
             }
             if (this._divided) {
                 for (const sub of this._subs) {
-                    sub.query(range, check, res);
+                    res.push(...sub.query(range, check));
                 }
             }
             return res;
         }
         queryCircle(position, radius, check) {
-            return this.query(new Circle_js_1.Circle(position.x, position.y, radius), check);
+            return this.query(new Ranges_js_1.Circle(position.x, position.y, radius), check);
         }
         queryRectangle(position, size, check) {
-            return this.query(new Rectangle_js_1.Rectangle(position.x, position.y, size.width, size.height), check);
+            return this.query(new Ranges_js_1.Rectangle(position.x, position.y, size.width, size.height), check);
         }
     }
     exports.QuadTree = QuadTree;