@tsparticles/plugin-emitters 3.0.0-alpha.0

package/cjs/Options/Classes/EmitterSize.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmitterSize = void 0;
+class EmitterSize {
+    constructor() {
+        this.mode = "percent";
+        this.height = 0;
+        this.width = 0;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.mode !== undefined) {
+            this.mode = data.mode;
+        }
+        if (data.height !== undefined) {
+            this.height = data.height;
+        }
+        if (data.width !== undefined) {
+            this.width = data.width;
+        }
+    }
+}
+exports.EmitterSize = EmitterSize;

package/cjs/Options/Interfaces/IEmitter.js

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

package/cjs/Options/Interfaces/IEmitterLife.js

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

package/cjs/Options/Interfaces/IEmitterRate.js

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

package/cjs/Options/Interfaces/IEmitterSize.js

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

package/cjs/ShapeManager.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShapeManager = void 0;
+const shapes = new Map();
+class ShapeManager {
+    constructor(engine) {
+        this._engine = engine;
+    }
+    addShape(name, drawer) {
+        if (!this.getShape(name)) {
+            shapes.set(name, drawer);
+        }
+    }
+    getShape(name) {
+        return shapes.get(name);
+    }
+    getSupportedShapes() {
+        return shapes.keys();
+    }
+}
+exports.ShapeManager = ShapeManager;

package/cjs/Shapes/Circle/CircleShape.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircleShape = void 0;
+const engine_1 = require("@tsparticles/engine");
+class CircleShape {
+    randomPosition(position, size, fill) {
+        const generateTheta = (x, y) => {
+            const u = (0, engine_1.getRandom)() / 4.0, theta = Math.atan((y / x) * Math.tan(2 * Math.PI * u)), v = (0, engine_1.getRandom)();
+            if (v < 0.25) {
+                return theta;
+            }
+            else if (v < 0.5) {
+                return Math.PI - theta;
+            }
+            else if (v < 0.75) {
+                return Math.PI + theta;
+            }
+            else {
+                return -theta;
+            }
+        }, radius = (x, y, theta) => (x * y) / Math.sqrt(Math.pow((y * Math.cos(theta)), 2) + Math.pow((x * Math.sin(theta)), 2)), [a, b] = [size.width / 2, size.height / 2], randomTheta = generateTheta(a, b), maxRadius = radius(a, b, randomTheta), randomRadius = fill ? maxRadius * Math.sqrt((0, engine_1.getRandom)()) : maxRadius;
+        return {
+            x: position.x + randomRadius * Math.cos(randomTheta),
+            y: position.y + randomRadius * Math.sin(randomTheta),
+        };
+    }
+}
+exports.CircleShape = CircleShape;

package/cjs/Shapes/Square/SquareShape.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SquareShape = void 0;
+const engine_1 = require("@tsparticles/engine");
+function randomSquareCoordinate(position, offset) {
+    return position + offset * ((0, engine_1.getRandom)() - 0.5);
+}
+class SquareShape {
+    randomPosition(position, size, fill) {
+        if (fill) {
+            return {
+                x: randomSquareCoordinate(position.x, size.width),
+                y: randomSquareCoordinate(position.y, size.height),
+            };
+        }
+        else {
+            const halfW = size.width / 2, halfH = size.height / 2, side = Math.floor((0, engine_1.getRandom)() * 4), v = ((0, engine_1.getRandom)() - 0.5) * 2;
+            switch (side) {
+                case 0:
+                    return {
+                        x: position.x + v * halfW,
+                        y: position.y - halfH,
+                    };
+                case 1:
+                    return {
+                        x: position.x - halfW,
+                        y: position.y + v * halfH,
+                    };
+                case 2:
+                    return {
+                        x: position.x + v * halfW,
+                        y: position.y + halfH,
+                    };
+                case 3:
+                default:
+                    return {
+                        x: position.x + halfW,
+                        y: position.y + v * halfH,
+                    };
+            }
+        }
+    }
+}
+exports.SquareShape = SquareShape;

package/cjs/index.js

@@ -0,0 +1,142 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEmittersPlugin = void 0;
+const engine_1 = require("@tsparticles/engine");
+const CircleShape_1 = require("./Shapes/Circle/CircleShape");
+const Emitter_1 = require("./Options/Classes/Emitter");
+const Emitters_1 = require("./Emitters");
+const ShapeManager_1 = require("./ShapeManager");
+const SquareShape_1 = require("./Shapes/Square/SquareShape");
+class EmittersPlugin {
+    constructor(engine) {
+        this._engine = engine;
+        this.id = "emitters";
+    }
+    getPlugin(container) {
+        return new Emitters_1.Emitters(this._engine, container);
+    }
+    loadOptions(options, source) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
+            return;
+        }
+        if (source === null || source === void 0 ? void 0 : source.emitters) {
+            options.emitters = (0, engine_1.executeOnSingleOrMultiple)(source.emitters, (emitter) => {
+                const tmp = new Emitter_1.Emitter();
+                tmp.load(emitter);
+                return tmp;
+            });
+        }
+        const interactivityEmitters = (_b = (_a = source === null || source === void 0 ? void 0 : source.interactivity) === null || _a === void 0 ? void 0 : _a.modes) === null || _b === void 0 ? void 0 : _b.emitters;
+        if (interactivityEmitters) {
+            if (interactivityEmitters instanceof Array) {
+                options.interactivity.modes.emitters = {
+                    random: {
+                        count: 1,
+                        enable: true,
+                    },
+                    value: interactivityEmitters.map((s) => {
+                        const tmp = new Emitter_1.Emitter();
+                        tmp.load(s);
+                        return tmp;
+                    }),
+                };
+            }
+            else {
+                const emitterMode = interactivityEmitters;
+                if (emitterMode.value !== undefined) {
+                    if (emitterMode.value instanceof Array) {
+                        options.interactivity.modes.emitters = {
+                            random: {
+                                count: (_c = emitterMode.random.count) !== null && _c !== void 0 ? _c : 1,
+                                enable: (_d = emitterMode.random.enable) !== null && _d !== void 0 ? _d : false,
+                            },
+                            value: emitterMode.value.map((s) => {
+                                const tmp = new Emitter_1.Emitter();
+                                tmp.load(s);
+                                return tmp;
+                            }),
+                        };
+                    }
+                    else {
+                        const tmp = new Emitter_1.Emitter();
+                        tmp.load(emitterMode.value);
+                        options.interactivity.modes.emitters = {
+                            random: {
+                                count: (_e = emitterMode.random.count) !== null && _e !== void 0 ? _e : 1,
+                                enable: (_f = emitterMode.random.enable) !== null && _f !== void 0 ? _f : false,
+                            },
+                            value: tmp,
+                        };
+                    }
+                }
+                else {
+                    const emitterOptions = (options.interactivity.modes.emitters = {
+                        random: {
+                            count: 1,
+                            enable: false,
+                        },
+                        value: new Emitter_1.Emitter(),
+                    });
+                    emitterOptions.value.load(interactivityEmitters);
+                }
+            }
+        }
+    }
+    needsPlugin(options) {
+        var _a, _b, _c;
+        if (!options) {
+            return false;
+        }
+        const emitters = options.emitters;
+        return ((emitters instanceof Array && !!emitters.length) ||
+            emitters !== undefined ||
+            (!!((_c = (_b = (_a = options.interactivity) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.onClick) === null || _c === void 0 ? void 0 : _c.mode) &&
+                (0, engine_1.isInArray)("emitter", options.interactivity.events.onClick.mode)));
+    }
+}
+function loadEmittersPlugin(engine) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!engine.emitterShapeManager) {
+            engine.emitterShapeManager = new ShapeManager_1.ShapeManager(engine);
+        }
+        if (!engine.addEmitterShape) {
+            engine.addEmitterShape = (name, shape) => {
+                var _a;
+                (_a = engine.emitterShapeManager) === null || _a === void 0 ? void 0 : _a.addShape(name, shape);
+            };
+        }
+        const plugin = new EmittersPlugin(engine);
+        yield engine.addPlugin(plugin);
+        engine.addEmitterShape("circle", new CircleShape_1.CircleShape());
+        engine.addEmitterShape("square", new SquareShape_1.SquareShape());
+    });
+}
+exports.loadEmittersPlugin = loadEmittersPlugin;
+__exportStar(require("./EmitterContainer"), exports);
+__exportStar(require("./EmittersEngine"), exports);
+__exportStar(require("./Enums/EmitterClickMode"), exports);
+__exportStar(require("./Enums/EmitterShapeType"), exports);

package/cjs/types.js

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

package/esm/EmitterContainer.js

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

package/esm/EmitterInstance.js

@@ -0,0 +1,257 @@
+import { Vector, calcPositionOrRandomFromSizeRanged, deepExtend, getRangeValue, isPointInside, itemFromSingleOrMultiple, randomInRange, rangeColorToHsl, } from "@tsparticles/engine";
+import { Emitter } from "./Options/Classes/Emitter";
+import { EmitterSize } from "./Options/Classes/EmitterSize";
+export class EmitterInstance {
+    constructor(engine, emitters, container, options, position) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        var _h;
+        this.emitters = emitters;
+        this.container = container;
+        this._engine = engine;
+        this._currentDuration = 0;
+        this._currentEmitDelay = 0;
+        this._currentSpawnDelay = 0;
+        this._initialPosition = position;
+        if (options instanceof Emitter) {
+            this.options = options;
+        }
+        else {
+            this.options = new Emitter();
+            this.options.load(options);
+        }
+        this._spawnDelay = (((_a = this.options.life.delay) !== null && _a !== void 0 ? _a : 0) * 1000) / this.container.retina.reduceFactor;
+        this.position = (_b = this._initialPosition) !== null && _b !== void 0 ? _b : this.calcPosition();
+        this.name = this.options.name;
+        this._shape = (_c = this._engine.emitterShapeManager) === null || _c === void 0 ? void 0 : _c.getShape(this.options.shape);
+        this.fill = this.options.fill;
+        this._firstSpawn = !this.options.life.wait;
+        this._startParticlesAdded = false;
+        let particlesOptions = deepExtend({}, this.options.particles);
+        particlesOptions !== null && particlesOptions !== void 0 ? particlesOptions : (particlesOptions = {});
+        (_d = particlesOptions.move) !== null && _d !== void 0 ? _d : (particlesOptions.move = {});
+        (_e = (_h = particlesOptions.move).direction) !== null && _e !== void 0 ? _e : (_h.direction = this.options.direction);
+        if (this.options.spawnColor) {
+            this.spawnColor = rangeColorToHsl(this.options.spawnColor);
+        }
+        this._paused = !this.options.autoPlay;
+        this._particlesOptions = particlesOptions;
+        this.size =
+            (_f = this.options.size) !== null && _f !== void 0 ? _f : (() => {
+                const size = new EmitterSize();
+                size.load({
+                    height: 0,
+                    mode: "percent",
+                    width: 0,
+                });
+                return size;
+            })();
+        this._lifeCount = (_g = this.options.life.count) !== null && _g !== void 0 ? _g : -1;
+        this._immortal = this._lifeCount <= 0;
+        this._engine.dispatchEvent("emitterCreated", {
+            container,
+            data: {
+                emitter: this,
+            },
+        });
+        this.play();
+    }
+    externalPause() {
+        this._paused = true;
+        this.pause();
+    }
+    externalPlay() {
+        this._paused = false;
+        this.play();
+    }
+    getPosition() {
+        if (this.options.domId) {
+            const container = this.container, element = document.getElementById(this.options.domId);
+            if (element) {
+                const elRect = element.getBoundingClientRect();
+                return {
+                    x: (elRect.x + elRect.width / 2) * container.retina.pixelRatio,
+                    y: (elRect.y + elRect.height / 2) * container.retina.pixelRatio,
+                };
+            }
+        }
+        return this.position;
+    }
+    getSize() {
+        const container = this.container;
+        if (this.options.domId) {
+            const element = document.getElementById(this.options.domId);
+            if (element) {
+                const elRect = element.getBoundingClientRect();
+                return {
+                    width: elRect.width * container.retina.pixelRatio,
+                    height: elRect.height * container.retina.pixelRatio,
+                };
+            }
+        }
+        return {
+            width: this.size.mode === "percent"
+                ? (container.canvas.size.width * this.size.width) / 100
+                : this.size.width,
+            height: this.size.mode === "percent"
+                ? (container.canvas.size.height * this.size.height) / 100
+                : this.size.height,
+        };
+    }
+    pause() {
+        if (this._paused) {
+            return;
+        }
+        delete this._emitDelay;
+    }
+    play() {
+        var _a;
+        if (this._paused) {
+            return;
+        }
+        if (!(this.container.retina.reduceFactor &&
+            (this._lifeCount > 0 || this._immortal || !this.options.life.count) &&
+            (this._firstSpawn || this._currentSpawnDelay >= ((_a = this._spawnDelay) !== null && _a !== void 0 ? _a : 0)))) {
+            return;
+        }
+        if (this._emitDelay === undefined) {
+            const delay = getRangeValue(this.options.rate.delay);
+            this._emitDelay = (1000 * delay) / this.container.retina.reduceFactor;
+        }
+        if (this._lifeCount > 0 || this._immortal) {
+            this.prepareToDie();
+        }
+    }
+    resize() {
+        const initialPosition = this._initialPosition;
+        this.position =
+            initialPosition && isPointInside(initialPosition, this.container.canvas.size, Vector.origin)
+                ? initialPosition
+                : this.calcPosition();
+    }
+    update(delta) {
+        var _a, _b, _c;
+        if (this._paused) {
+            return;
+        }
+        if (this._firstSpawn) {
+            this._firstSpawn = false;
+            this._currentSpawnDelay = (_a = this._spawnDelay) !== null && _a !== void 0 ? _a : 0;
+            this._currentEmitDelay = (_b = this._emitDelay) !== null && _b !== void 0 ? _b : 0;
+        }
+        if (!this._startParticlesAdded) {
+            this._startParticlesAdded = true;
+            this.emitParticles(this.options.startCount);
+        }
+        if (this._duration !== undefined) {
+            this._currentDuration += delta.value;
+            if (this._currentDuration >= this._duration) {
+                this.pause();
+                if (this._spawnDelay !== undefined) {
+                    delete this._spawnDelay;
+                }
+                if (!this._immortal) {
+                    this._lifeCount--;
+                }
+                if (this._lifeCount > 0 || this._immortal) {
+                    this.position = this.calcPosition();
+                    this._spawnDelay = (((_c = this.options.life.delay) !== null && _c !== void 0 ? _c : 0) * 1000) / this.container.retina.reduceFactor;
+                }
+                else {
+                    this.destroy();
+                }
+                this._currentDuration -= this._duration;
+                delete this._duration;
+            }
+        }
+        if (this._spawnDelay !== undefined) {
+            this._currentSpawnDelay += delta.value;
+            if (this._currentSpawnDelay >= this._spawnDelay) {
+                this._engine.dispatchEvent("emitterPlay", {
+                    container: this.container,
+                });
+                this.play();
+                this._currentSpawnDelay -= this._currentSpawnDelay;
+                delete this._spawnDelay;
+            }
+        }
+        if (this._emitDelay !== undefined) {
+            this._currentEmitDelay += delta.value;
+            if (this._currentEmitDelay >= this._emitDelay) {
+                this.emit();
+                this._currentEmitDelay -= this._emitDelay;
+            }
+        }
+    }
+    calcPosition() {
+        return calcPositionOrRandomFromSizeRanged({
+            size: this.container.canvas.size,
+            position: this.options.position,
+        });
+    }
+    destroy() {
+        this.emitters.removeEmitter(this);
+        this._engine.dispatchEvent("emitterDestroyed", {
+            container: this.container,
+            data: {
+                emitter: this,
+            },
+        });
+    }
+    emit() {
+        if (this._paused) {
+            return;
+        }
+        const quantity = getRangeValue(this.options.rate.quantity);
+        this.emitParticles(quantity);
+    }
+    emitParticles(quantity) {
+        var _a, _b, _c;
+        const position = this.getPosition(), size = this.getSize(), singleParticlesOptions = itemFromSingleOrMultiple(this._particlesOptions);
+        for (let i = 0; i < quantity; i++) {
+            const particlesOptions = deepExtend({}, singleParticlesOptions);
+            if (this.spawnColor) {
+                const hslAnimation = (_a = this.options.spawnColor) === null || _a === void 0 ? void 0 : _a.animation;
+                if (hslAnimation) {
+                    this.spawnColor.h = this.setColorAnimation(hslAnimation.h, this.spawnColor.h, 360);
+                    this.spawnColor.s = this.setColorAnimation(hslAnimation.s, this.spawnColor.s, 100);
+                    this.spawnColor.l = this.setColorAnimation(hslAnimation.l, this.spawnColor.l, 100);
+                }
+                if (!particlesOptions.color) {
+                    particlesOptions.color = {
+                        value: this.spawnColor,
+                    };
+                }
+                else {
+                    particlesOptions.color.value = this.spawnColor;
+                }
+            }
+            if (!position) {
+                return;
+            }
+            const pPosition = (_c = (_b = this._shape) === null || _b === void 0 ? void 0 : _b.randomPosition(position, size, this.fill)) !== null && _c !== void 0 ? _c : position;
+            this.container.particles.addParticle(pPosition, particlesOptions);
+        }
+    }
+    prepareToDie() {
+        var _a;
+        if (this._paused) {
+            return;
+        }
+        const duration = (_a = this.options.life) === null || _a === void 0 ? void 0 : _a.duration;
+        if (this.container.retina.reduceFactor &&
+            (this._lifeCount > 0 || this._immortal) &&
+            duration !== undefined &&
+            duration > 0) {
+            this._duration = duration * 1000;
+        }
+    }
+    setColorAnimation(animation, initValue, maxValue) {
+        var _a;
+        const container = this.container;
+        if (!animation.enable) {
+            return initValue;
+        }
+        const colorOffset = randomInRange(animation.offset), delay = getRangeValue(this.options.rate.delay), emitFactor = (1000 * delay) / container.retina.reduceFactor, colorSpeed = getRangeValue((_a = animation.speed) !== null && _a !== void 0 ? _a : 0);
+        return (initValue + (colorSpeed * container.fpsLimit) / emitFactor + colorOffset * 3.6) % maxValue;
+    }
+}

package/esm/Emitters.js

@@ -0,0 +1,119 @@
+import { arrayRandomIndex, executeOnSingleOrMultiple, itemFromArray } from "@tsparticles/engine";
+import { Emitter } from "./Options/Classes/Emitter";
+import { EmitterInstance } from "./EmitterInstance";
+export class Emitters {
+    constructor(engine, container) {
+        this.container = container;
+        this._engine = engine;
+        this.array = [];
+        this.emitters = [];
+        this.interactivityEmitters = {
+            random: {
+                count: 1,
+                enable: false,
+            },
+            value: [],
+        };
+        container.getEmitter = (idxOrName) => idxOrName === undefined || typeof idxOrName === "number"
+            ? this.array[idxOrName || 0]
+            : this.array.find((t) => t.name === idxOrName);
+        container.addEmitter = (options, position) => this.addEmitter(options, position);
+        container.removeEmitter = (idxOrName) => {
+            const emitter = container.getEmitter(idxOrName);
+            if (emitter) {
+                this.removeEmitter(emitter);
+            }
+        };
+        container.playEmitter = (idxOrName) => {
+            const emitter = container.getEmitter(idxOrName);
+            if (emitter) {
+                emitter.externalPlay();
+            }
+        };
+        container.pauseEmitter = (idxOrName) => {
+            const emitter = container.getEmitter(idxOrName);
+            if (emitter) {
+                emitter.externalPause();
+            }
+        };
+    }
+    addEmitter(options, position) {
+        const emitterOptions = new Emitter();
+        emitterOptions.load(options);
+        const emitter = new EmitterInstance(this._engine, this, this.container, emitterOptions, position);
+        this.array.push(emitter);
+        return emitter;
+    }
+    handleClickMode(mode) {
+        const emitterOptions = this.emitters, modeEmitters = this.interactivityEmitters;
+        if (mode === "emitter") {
+            let emittersModeOptions;
+            if (modeEmitters && modeEmitters.value instanceof Array) {
+                if (modeEmitters.value.length > 0 && modeEmitters.random.enable) {
+                    emittersModeOptions = [];
+                    const usedIndexes = [];
+                    for (let i = 0; i < modeEmitters.random.count; i++) {
+                        const idx = arrayRandomIndex(modeEmitters.value);
+                        if (usedIndexes.includes(idx) && usedIndexes.length < modeEmitters.value.length) {
+                            i--;
+                            continue;
+                        }
+                        usedIndexes.push(idx);
+                        emittersModeOptions.push(itemFromArray(modeEmitters.value, idx));
+                    }
+                }
+                else {
+                    emittersModeOptions = modeEmitters.value;
+                }
+            }
+            else {
+                emittersModeOptions = modeEmitters === null || modeEmitters === void 0 ? void 0 : modeEmitters.value;
+            }
+            const emittersOptions = emittersModeOptions !== null && emittersModeOptions !== void 0 ? emittersModeOptions : emitterOptions, ePosition = this.container.interactivity.mouse.clickPosition;
+            executeOnSingleOrMultiple(emittersOptions, (emitter) => {
+                this.addEmitter(emitter, ePosition);
+            });
+        }
+    }
+    async init() {
+        this.emitters = this.container.actualOptions.emitters;
+        this.interactivityEmitters = this.container.actualOptions.interactivity.modes.emitters;
+        if (this.emitters instanceof Array) {
+            for (const emitterOptions of this.emitters) {
+                this.addEmitter(emitterOptions);
+            }
+        }
+        else {
+            this.addEmitter(this.emitters);
+        }
+    }
+    pause() {
+        for (const emitter of this.array) {
+            emitter.pause();
+        }
+    }
+    play() {
+        for (const emitter of this.array) {
+            emitter.play();
+        }
+    }
+    removeEmitter(emitter) {
+        const index = this.array.indexOf(emitter);
+        if (index >= 0) {
+            this.array.splice(index, 1);
+        }
+    }
+    resize() {
+        for (const emitter of this.array) {
+            emitter.resize();
+        }
+    }
+    stop() {
+        this.array = [];
+    }
+    update(delta) {
+        for (const emitter of this.array) {
+            emitter.update(delta);
+        }
+    }
+}

package/esm/EmittersEngine.js

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

package/esm/Enums/EmitterClickMode.js

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

package/esm/Enums/EmitterShapeType.js

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

package/esm/IEmitterShape.js

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