@tsparticles/engine 4.0.0-alpha.8 → 4.0.0-beta.1

package/umd/Core/Container.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../Utils/MathUtils.js", "./Utils/Constants.js", "./Canvas.js", "./Utils/EventListeners.js", "../Enums/Types/EventType.js", "../Options/Classes/Options.js", "./Particles.js", "./Retina.js", "../Utils/LogUtils.js", "../Utils/OptionsUtils.js"], factory);
+        define(["require", "exports", "../Utils/MathUtils.js", "./Utils/Constants.js", "./CanvasManager.js", "./Utils/EventListeners.js", "../Enums/Types/EventType.js", "../Options/Classes/Options.js", "./ParticlesManager.js", "./Retina.js", "../Utils/LogUtils.js", "../Utils/OptionsUtils.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -12,11 +12,11 @@
     exports.Container = void 0;
     const MathUtils_js_1 = require("../Utils/MathUtils.js");
     const Constants_js_1 = require("./Utils/Constants.js");
-    const Canvas_js_1 = require("./Canvas.js");
+    const CanvasManager_js_1 = require("./CanvasManager.js");
     const EventListeners_js_1 = require("./Utils/EventListeners.js");
     const EventType_js_1 = require("../Enums/Types/EventType.js");
     const Options_js_1 = require("../Options/Classes/Options.js");
-    const Particles_js_1 = require("./Particles.js");
+    const ParticlesManager_js_1 = require("./ParticlesManager.js");
     const Retina_js_1 = require("./Retina.js");
     const LogUtils_js_1 = require("../Utils/LogUtils.js");
     const OptionsUtils_js_1 = require("../Utils/OptionsUtils.js");
@@ -27,44 +27,52 @@
         delta.value = value;
         delta.factor = smooth ? Constants_js_1.defaultFps / fpsLimit : (Constants_js_1.defaultFps * value) / Constants_js_1.millisecondsToSeconds;
     }
-    function loadContainerOptions(engine, container, ...sourceOptionsArr) {
-        const options = new Options_js_1.Options(engine, container);
+    function loadContainerOptions(pluginManager, container, ...sourceOptionsArr) {
+        const options = new Options_js_1.Options(pluginManager, container);
         (0, OptionsUtils_js_1.loadOptions)(options, ...sourceOptionsArr);
         return options;
     }
     class Container {
-        constructor(engine, id, sourceOptions) {
-            this._delta = { value: 0, factor: 0 };
-            this._nextFrame = (timestamp) => {
-                try {
-                    if (!this._smooth &&
-                        this._lastFrameTime !== undefined &&
-                        timestamp < this._lastFrameTime + Constants_js_1.millisecondsToSeconds / this.fpsLimit) {
-                        this.draw(false);
-                        return;
-                    }
-                    this._lastFrameTime ??= timestamp;
-                    updateDelta(this._delta, timestamp - this._lastFrameTime, this.fpsLimit, this._smooth);
-                    this.addLifeTime(this._delta.value);
-                    this._lastFrameTime = timestamp;
-                    if (this._delta.value > Constants_js_1.millisecondsToSeconds) {
-                        this.draw(false);
-                        return;
-                    }
-                    this.canvas.drawParticles(this._delta);
-                    if (!this.alive()) {
-                        this.destroy();
-                        return;
-                    }
-                    if (this.animationStatus) {
-                        this.draw(false);
-                    }
-                }
-                catch (e) {
-                    (0, LogUtils_js_1.getLogger)().error("error in animation loop", e);
-                }
-            };
-            this._engine = engine;
+        actualOptions;
+        canvas;
+        destroyed;
+        effectDrawers;
+        fpsLimit;
+        hdr;
+        id;
+        pageHidden;
+        particleCreatedPlugins;
+        particleDestroyedPlugins;
+        particlePositionPlugins;
+        particleUpdaters;
+        particles;
+        plugins;
+        retina;
+        shapeDrawers;
+        started;
+        zLayers;
+        _delay;
+        _delayTimeout;
+        _delta = { value: 0, factor: 0 };
+        _dispatchCallback;
+        _drawAnimationFrame;
+        _duration;
+        _eventListeners;
+        _firstStart;
+        _initialSourceOptions;
+        _lastFrameTime;
+        _lifeTime;
+        _onDestroy;
+        _options;
+        _paused;
+        _pluginManager;
+        _smooth;
+        _sourceOptions;
+        constructor(params) {
+            const { dispatchCallback, pluginManager, id, onDestroy, sourceOptions } = params;
+            this._pluginManager = pluginManager;
+            this._dispatchCallback = dispatchCallback;
+            this._onDestroy = onDestroy;
             this.id = Symbol(id);
             this.fpsLimit = 120;
             this.hdr = false;
@@ -81,17 +89,20 @@
             this.pageHidden = false;
             this._sourceOptions = sourceOptions;
             this._initialSourceOptions = sourceOptions;
-            this.retina = new Retina_js_1.Retina(this);
-            this.canvas = new Canvas_js_1.Canvas(this, this._engine);
-            this.particles = new Particles_js_1.Particles(this._engine, this);
-            this.pathGenerators = new Map();
-            this.plugins = [];
             this.effectDrawers = new Map();
             this.shapeDrawers = new Map();
-            this._options = loadContainerOptions(this._engine, this);
-            this.actualOptions = loadContainerOptions(this._engine, this);
+            this.particleUpdaters = [];
+            this.retina = new Retina_js_1.Retina(this);
+            this.canvas = new CanvasManager_js_1.CanvasManager(this._pluginManager, this);
+            this.particles = new ParticlesManager_js_1.ParticlesManager(this._pluginManager, this);
+            this.plugins = [];
+            this.particleDestroyedPlugins = [];
+            this.particleCreatedPlugins = [];
+            this.particlePositionPlugins = [];
+            this._options = loadContainerOptions(this._pluginManager, this);
+            this.actualOptions = loadContainerOptions(this._pluginManager, this);
             this._eventListeners = new EventListeners_js_1.EventListeners(this);
-            this._engine.dispatchEvent(EventType_js_1.EventType.containerBuilt, { container: this });
+            this.dispatchEvent(EventType_js_1.EventType.containerBuilt);
         }
         get animationStatus() {
             return !this._paused && !this.pageHidden && guardCheck(this);
@@ -105,13 +116,6 @@
         addLifeTime(value) {
             this._lifeTime += value;
         }
-        addPath(key, generator, override = false) {
-            if (!guardCheck(this) || (!override && this.pathGenerators.has(key))) {
-                return false;
-            }
-            this.pathGenerators.set(key, generator);
-            return true;
-        }
         alive() {
             return !this._duration || this._lifeTime <= this._duration;
         }
@@ -122,42 +126,41 @@
             this.stop();
             this.particles.destroy();
             this.canvas.destroy();
-            for (const effectDrawer of this.effectDrawers.values()) {
+            for (const [, effectDrawer] of this.effectDrawers) {
                 effectDrawer.destroy?.(this);
             }
-            this.effectDrawers.clear();
-            for (const shapeDrawer of this.shapeDrawers.values()) {
+            for (const [, shapeDrawer] of this.shapeDrawers) {
                 shapeDrawer.destroy?.(this);
             }
-            this.shapeDrawers.clear();
             for (const plugin of this.plugins) {
                 plugin.destroy?.();
             }
+            this.effectDrawers = new Map();
+            this.shapeDrawers = new Map();
+            this.particleUpdaters = [];
             this.plugins.length = 0;
-            this._engine.clearPlugins(this);
+            this._pluginManager.clearPlugins(this);
             this.destroyed = true;
-            if (remove) {
-                const mainArr = this._engine.items, idx = mainArr.indexOf(this);
-                if (idx >= Constants_js_1.removeMinIndex) {
-                    mainArr.splice(idx, Constants_js_1.removeDeleteCount);
-                }
-            }
-            this._engine.dispatchEvent(EventType_js_1.EventType.containerDestroyed, { container: this });
+            this._onDestroy(remove);
+            this.dispatchEvent(EventType_js_1.EventType.containerDestroyed);
+        }
+        dispatchEvent(type, data) {
+            this._dispatchCallback(type, {
+                container: this,
+                data,
+            });
         }
         draw(force) {
             if (!guardCheck(this)) {
                 return;
             }
             let refreshTime = force;
-            const frame = (timestamp) => {
+            this._drawAnimationFrame = (0, MathUtils_js_1.animate)((timestamp) => {
                 if (refreshTime) {
                     this._lastFrameTime = undefined;
                     refreshTime = false;
                 }
                 this._nextFrame(timestamp);
-            };
-            this._drawAnimationFrame = (0, MathUtils_js_1.animate)(timestamp => {
-                frame(timestamp);
             });
         }
         async export(type, options = {}) {
@@ -178,34 +181,33 @@
             if (!guardCheck(this)) {
                 return;
             }
-            const effects = this._engine.getSupportedEffects();
-            for (const type of effects) {
-                const drawer = this._engine.getEffectDrawer(type);
-                if (drawer) {
-                    this.effectDrawers.set(type, drawer);
-                }
-            }
-            const shapes = this._engine.getSupportedShapes();
-            for (const type of shapes) {
-                const drawer = this._engine.getShapeDrawer(type);
-                if (drawer) {
-                    this.shapeDrawers.set(type, drawer);
-                }
-            }
             const allContainerPlugins = new Map();
-            for (const plugin of this._engine.plugins) {
+            for (const plugin of this._pluginManager.plugins) {
                 const containerPlugin = await plugin.getPlugin(this);
                 if (containerPlugin.preInit) {
                     await containerPlugin.preInit();
                 }
                 allContainerPlugins.set(plugin, containerPlugin);
             }
-            await this.particles.initPlugins();
-            this._options = loadContainerOptions(this._engine, this, this._initialSourceOptions, this.sourceOptions);
-            this.actualOptions = loadContainerOptions(this._engine, this, this._options);
+            await this.initDrawersAndUpdaters();
+            this._options = loadContainerOptions(this._pluginManager, this, this._initialSourceOptions, this.sourceOptions);
+            this.actualOptions = loadContainerOptions(this._pluginManager, this, this._options);
+            this.plugins.length = 0;
+            this.particleDestroyedPlugins.length = 0;
+            this.particleCreatedPlugins.length = 0;
+            this.particlePositionPlugins.length = 0;
             for (const [plugin, containerPlugin] of allContainerPlugins) {
                 if (plugin.needsPlugin(this.actualOptions)) {
                     this.plugins.push(containerPlugin);
+                    if (containerPlugin.particleCreated) {
+                        this.particleCreatedPlugins.push(containerPlugin);
+                    }
+                    if (containerPlugin.particleDestroyed) {
+                        this.particleDestroyedPlugins.push(containerPlugin);
+                    }
+                    if (containerPlugin.particlePosition) {
+                        this.particlePositionPlugins.push(containerPlugin);
+                    }
                 }
             }
             this.retina.init();
@@ -224,19 +226,19 @@
             for (const plugin of this.plugins) {
                 await plugin.init?.();
             }
-            for (const drawer of this.effectDrawers.values()) {
-                await drawer.init?.(this);
-            }
-            for (const drawer of this.shapeDrawers.values()) {
-                await drawer.init?.(this);
-            }
-            this._engine.dispatchEvent(EventType_js_1.EventType.containerInit, { container: this });
             await this.particles.init();
+            this.dispatchEvent(EventType_js_1.EventType.containerInit);
             this.particles.setDensity();
             for (const plugin of this.plugins) {
                 plugin.particlesSetup?.();
             }
-            this._engine.dispatchEvent(EventType_js_1.EventType.particlesSetup, { container: this });
+            this.dispatchEvent(EventType_js_1.EventType.particlesSetup);
+        }
+        async initDrawersAndUpdaters() {
+            const pluginManager = this._pluginManager;
+            this.effectDrawers = await pluginManager.getEffectDrawers(this, true);
+            this.shapeDrawers = await pluginManager.getShapeDrawers(this, true);
+            this.particleUpdaters = await pluginManager.getUpdaters(this, true);
         }
         pause() {
             if (!guardCheck(this)) {
@@ -255,7 +257,7 @@
             if (!this.pageHidden) {
                 this._paused = true;
             }
-            this._engine.dispatchEvent(EventType_js_1.EventType.containerPaused, { container: this });
+            this.dispatchEvent(EventType_js_1.EventType.containerPaused);
         }
         play(force) {
             if (!guardCheck(this)) {
@@ -276,7 +278,7 @@
                     }
                 }
             }
-            this._engine.dispatchEvent(EventType_js_1.EventType.containerPlay, { container: this });
+            this.dispatchEvent(EventType_js_1.EventType.containerPlay);
             this.draw(needsUpdate ?? false);
         }
         async refresh() {
@@ -292,8 +294,8 @@
             }
             this._initialSourceOptions = sourceOptions;
             this._sourceOptions = sourceOptions;
-            this._options = loadContainerOptions(this._engine, this, this._initialSourceOptions, this.sourceOptions);
-            this.actualOptions = loadContainerOptions(this._engine, this, this._options);
+            this._options = loadContainerOptions(this._pluginManager, this, this._initialSourceOptions, this.sourceOptions);
+            this.actualOptions = loadContainerOptions(this._pluginManager, this, this._options);
             return this.refresh();
         }
         async start() {
@@ -308,7 +310,7 @@
                     for (const plugin of this.plugins) {
                         await plugin.start?.();
                     }
-                    this._engine.dispatchEvent(EventType_js_1.EventType.containerStarted, { container: this });
+                    this.dispatchEvent(EventType_js_1.EventType.containerStarted);
                     this.play();
                     resolve();
                 };
@@ -332,9 +334,11 @@
             for (const plugin of this.plugins) {
                 plugin.stop?.();
             }
-            this.plugins.length = 0;
+            this.particleCreatedPlugins.length = 0;
+            this.particleDestroyedPlugins.length = 0;
+            this.particlePositionPlugins.length = 0;
             this._sourceOptions = this._options;
-            this._engine.dispatchEvent(EventType_js_1.EventType.containerStopped, { container: this });
+            this.dispatchEvent(EventType_js_1.EventType.containerStopped);
         }
         updateActualOptions() {
             let refresh = false;
@@ -345,6 +349,35 @@
             }
             return refresh;
         }
+        _nextFrame = (timestamp) => {
+            try {
+                if (!this._smooth &&
+                    this._lastFrameTime !== undefined &&
+                    timestamp < this._lastFrameTime + Constants_js_1.millisecondsToSeconds / this.fpsLimit) {
+                    this.draw(false);
+                    return;
+                }
+                this._lastFrameTime ??= timestamp;
+                updateDelta(this._delta, timestamp - this._lastFrameTime, this.fpsLimit, this._smooth);
+                this.addLifeTime(this._delta.value);
+                this._lastFrameTime = timestamp;
+                if (this._delta.value > Constants_js_1.millisecondsToSeconds) {
+                    this.draw(false);
+                    return;
+                }
+                this.canvas.render.drawParticles(this._delta);
+                if (!this.alive()) {
+                    this.destroy();
+                    return;
+                }
+                if (this.animationStatus) {
+                    this.draw(false);
+                }
+            }
+            catch (e) {
+                (0, LogUtils_js_1.getLogger)().error("error in animation loop", e);
+            }
+        };
     }
     exports.Container = Container;
 });

package/umd/Core/Engine.js

@@ -37,7 +37,7 @@ var __importStar = (this && this.__importStar) || (function () {
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./Utils/Constants.js", "../Utils/Utils.js", "../Utils/EventDispatcher.js", "../Enums/Types/EventType.js", "../Utils/LogUtils.js", "../Utils/MathUtils.js"], factory);
+        define(["require", "exports", "./Utils/Constants.js", "../Utils/Utils.js", "../Utils/EventDispatcher.js", "./Utils/PluginManager.js", "../Utils/LogUtils.js", "../Utils/MathUtils.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -47,7 +47,7 @@ var __importStar = (this && this.__importStar) || (function () {
     const Constants_js_1 = require("./Utils/Constants.js");
     const Utils_js_1 = require("../Utils/Utils.js");
     const EventDispatcher_js_1 = require("../Utils/EventDispatcher.js");
-    const EventType_js_1 = require("../Enums/Types/EventType.js");
+    const PluginManager_js_1 = require("./Utils/PluginManager.js");
     const LogUtils_js_1 = require("../Utils/LogUtils.js");
     const MathUtils_js_1 = require("../Utils/MathUtils.js");
     const fullPercent = "100%";
@@ -91,163 +91,41 @@ var __importStar = (this && this.__importStar) || (function () {
         if (domContainer) {
             return domContainer;
         }
-        domContainer = documentSafe.createElement("div");
+        domContainer = documentSafe.createElement("canvas");
         domContainer.id = id;
         domContainer.dataset[Constants_js_1.generatedAttribute] = Constants_js_1.generatedTrue;
         documentSafe.body.append(domContainer);
         return domContainer;
     };
     class Engine {
-        constructor() {
-            this._configs = new Map();
-            this._domArray = [];
-            this._eventDispatcher = new EventDispatcher_js_1.EventDispatcher();
-            this._initialized = false;
-            this._isRunningLoaders = false;
-            this._loadPromises = new Set();
-            this._allLoadersSet = new Set();
-            this._executedSet = new Set();
-            this.plugins = [];
-            this.colorManagers = new Map();
-            this.easingFunctions = new Map();
-            this._initializers = {
-                movers: new Map(),
-                updaters: new Map(),
-            };
-            this.movers = new Map();
-            this.updaters = new Map();
-            this.presets = new Map();
-            this.effectDrawers = new Map();
-            this.shapeDrawers = new Map();
-            this.pathGenerators = new Map();
-        }
-        get configs() {
-            const res = {};
-            for (const [name, config] of this._configs) {
-                res[name] = config;
-            }
-            return res;
-        }
+        pluginManager = new PluginManager_js_1.PluginManager(this);
+        _domArray = [];
+        _eventDispatcher = new EventDispatcher_js_1.EventDispatcher();
+        _initialized = false;
         get items() {
             return this._domArray;
         }
         get version() {
-            return "4.0.0-alpha.8";
-        }
-        addColorManager(manager) {
-            this.colorManagers.set(manager.key, manager);
-        }
-        addConfig(config) {
-            const key = config.key ?? config.name ?? "default";
-            this._configs.set(key, config);
-            this._eventDispatcher.dispatchEvent(EventType_js_1.EventType.configAdded, { data: { name: key, config } });
-        }
-        addEasing(name, easing) {
-            if (this.easingFunctions.get(name)) {
-                return;
-            }
-            this.easingFunctions.set(name, easing);
-        }
-        addEffect(effect, drawer) {
-            if (this.getEffectDrawer(effect)) {
-                return;
-            }
-            this.effectDrawers.set(effect, drawer);
+            return "4.0.0-beta.1";
         }
         addEventListener(type, listener) {
             this._eventDispatcher.addEventListener(type, listener);
         }
-        addMover(name, moverInitializer) {
-            this._initializers.movers.set(name, moverInitializer);
-        }
-        addParticleUpdater(name, updaterInitializer) {
-            this._initializers.updaters.set(name, updaterInitializer);
-        }
-        addPathGenerator(name, generator) {
-            if (this.getPathGenerator(name)) {
-                return;
-            }
-            this.pathGenerators.set(name, generator);
-        }
-        addPlugin(plugin) {
-            if (this.getPlugin(plugin.id)) {
-                return;
-            }
-            this.plugins.push(plugin);
-        }
-        addPreset(preset, options, override = false) {
-            if (!(override || !this.getPreset(preset))) {
-                return;
-            }
-            this.presets.set(preset, options);
-        }
-        addShape(drawer) {
-            for (const validType of drawer.validTypes) {
-                if (this.getShapeDrawer(validType)) {
-                    continue;
-                }
-                this.shapeDrawers.set(validType, drawer);
-            }
-        }
         checkVersion(pluginVersion) {
             if (this.version === pluginVersion) {
                 return;
             }
             throw new Error(`The tsParticles version is different from the loaded plugins version. Engine version: ${this.version}. Plugin version: ${pluginVersion}`);
         }
-        clearPlugins(container) {
-            this.updaters.delete(container);
-            this.movers.delete(container);
-        }
         dispatchEvent(type, args) {
             this._eventDispatcher.dispatchEvent(type, args);
         }
-        getEasing(name) {
-            return this.easingFunctions.get(name) ?? ((value) => value);
-        }
-        getEffectDrawer(type) {
-            return this.effectDrawers.get(type);
-        }
-        async getMovers(container, force = false) {
-            return (0, Utils_js_1.getItemsFromInitializer)(container, this.movers, this._initializers.movers, force);
-        }
-        getPathGenerator(type) {
-            return this.pathGenerators.get(type);
-        }
-        getPlugin(plugin) {
-            return this.plugins.find(t => t.id === plugin);
-        }
-        getPreset(preset) {
-            return this.presets.get(preset);
-        }
-        getShapeDrawer(type) {
-            return this.shapeDrawers.get(type);
-        }
-        getSupportedEffects() {
-            return this.effectDrawers.keys();
-        }
-        getSupportedShapes() {
-            return this.shapeDrawers.keys();
-        }
-        async getUpdaters(container, force = false) {
-            return (0, Utils_js_1.getItemsFromInitializer)(container, this.updaters, this._initializers.updaters, force);
-        }
         async init() {
-            if (this._initialized || this._isRunningLoaders)
+            if (this._initialized) {
                 return;
-            this._isRunningLoaders = true;
-            this._executedSet = new Set();
-            this._allLoadersSet = new Set(this._loadPromises);
-            try {
-                for (const loader of this._allLoadersSet) {
-                    await this._runLoader(loader, this._executedSet, this._allLoadersSet);
-                }
-            }
-            finally {
-                this._loadPromises.clear();
-                this._isRunningLoaders = false;
-                this._initialized = true;
             }
+            await this.pluginManager.init();
+            this._initialized = true;
         }
         item(index) {
             const { items } = this, item = items[index];
@@ -259,7 +137,23 @@ var __importStar = (this && this.__importStar) || (function () {
         }
         async load(params) {
             await this.init();
-            const { Container } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./Container.js"))) : new Promise((resolve_1, reject_1) => { require(["./Container.js"], resolve_1, reject_1); }).then(__importStar)), id = params.id ?? params.element?.id ?? `tsparticles${Math.floor((0, MathUtils_js_1.getRandom)() * Constants_js_1.loadRandomFactor).toString()}`, { index, url } = params, options = url ? await getDataFromUrl({ fallback: params.options, url, index }) : params.options, currentOptions = (0, Utils_js_1.itemFromSingleOrMultiple)(options, index), { items } = this, oldIndex = items.findIndex(v => v.id.description === id), newItem = new Container(this, id, currentOptions);
+            const { Container } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./Container.js"))) : new Promise((resolve_1, reject_1) => { require(["./Container.js"], resolve_1, reject_1); }).then(__importStar)), id = params.id ?? params.element?.id ?? `tsparticles${Math.floor((0, MathUtils_js_1.getRandom)() * Constants_js_1.loadRandomFactor).toString()}`, { index, url } = params, options = url ? await getDataFromUrl({ fallback: params.options, url, index }) : params.options, currentOptions = (0, Utils_js_1.itemFromSingleOrMultiple)(options, index), { items } = this, oldIndex = items.findIndex(v => v.id.description === id), newItem = new Container({
+                dispatchCallback: (eventType, args) => {
+                    this.dispatchEvent(eventType, args);
+                },
+                id,
+                onDestroy: (remove) => {
+                    if (!remove) {
+                        return;
+                    }
+                    const mainArr = this.items, idx = mainArr.indexOf(newItem);
+                    if (idx >= Constants_js_1.removeMinIndex) {
+                        mainArr.splice(idx, Constants_js_1.removeDeleteCount);
+                    }
+                },
+                pluginManager: this.pluginManager,
+                sourceOptions: currentOptions,
+            });
             if (oldIndex >= Constants_js_1.loadMinIndex) {
                 const old = this.item(oldIndex), deleteCount = old ? Constants_js_1.one : Constants_js_1.none;
                 if (old && !old.destroyed) {
@@ -275,42 +169,15 @@ var __importStar = (this && this.__importStar) || (function () {
             await newItem.start();
             return newItem;
         }
-        loadParticlesOptions(container, options, ...sourceOptions) {
-            const updaters = this.updaters.get(container);
-            if (!updaters) {
-                return;
-            }
-            updaters.forEach(updater => updater.loadOptions?.(options, ...sourceOptions));
-        }
         async refresh(refresh = true) {
             if (!refresh) {
                 return;
             }
             await Promise.all(this.items.map(t => t.refresh()));
         }
-        async register(...loaders) {
-            if (this._initialized) {
-                throw new Error("Register plugins can only be done before calling tsParticles.load()");
-            }
-            for (const loader of loaders) {
-                if (this._isRunningLoaders) {
-                    await this._runLoader(loader, this._executedSet, this._allLoadersSet);
-                }
-                else {
-                    this._loadPromises.add(loader);
-                }
-            }
-        }
         removeEventListener(type, listener) {
             this._eventDispatcher.removeEventListener(type, listener);
         }
-        async _runLoader(loader, executed, allLoaders) {
-            if (executed.has(loader))
-                return;
-            executed.add(loader);
-            allLoaders.add(loader);
-            await loader(this);
-        }
     }
     exports.Engine = Engine;
 });