tsparticles 1.39.1 → 1.40.1

package/esm/Core/Loader.js

@@ -1,24 +1,39 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Loader_engine;
 import { Constants } from "./Utils";
 import { Container } from "./Container";
 import { itemFromArray } from "../Utils";
-const tsParticlesDom = [];
 function fetchError(statusCode) {
     console.error(`Error tsParticles - fetch status: ${statusCode}`);
     console.error("Error tsParticles - File config not found");
 }
 export class Loader {
-    static dom() {
-        return tsParticlesDom;
+    constructor(engine) {
+        _Loader_engine.set(this, void 0);
+        __classPrivateFieldSet(this, _Loader_engine, engine, "f");
     }
-    static domItem(index) {
-        const dom = Loader.dom();
+    dom() {
+        return __classPrivateFieldGet(this, _Loader_engine, "f").domArray;
+    }
+    domItem(index) {
+        const dom = this.dom();
         const item = dom[index];
         if (item && !item.destroyed) {
             return item;
         }
         dom.splice(index, 1);
     }
-    static async loadOptions(params) {
+    async loadOptions(params) {
         var _a, _b, _c;
         const tagId = (_a = params.tagId) !== null && _a !== void 0 ? _a : `tsparticles${Math.floor(Math.random() * 10000)}`;
         const { options, index } = params;
@@ -29,10 +44,10 @@ export class Loader {
             (_c = document.querySelector("body")) === null || _c === void 0 ? void 0 : _c.append(domContainer);
         }
         const currentOptions = options instanceof Array ? itemFromArray(options, index) : options;
-        const dom = Loader.dom();
+        const dom = this.dom();
         const oldIndex = dom.findIndex((v) => v.id === tagId);
         if (oldIndex >= 0) {
-            const old = Loader.domItem(oldIndex);
+            const old = this.domItem(oldIndex);
             if (old && !old.destroyed) {
                 old.destroy();
                 dom.splice(oldIndex, 1);
@@ -57,7 +72,7 @@ export class Loader {
                 domContainer.appendChild(canvasEl);
             }
         }
-        const newItem = new Container(tagId, currentOptions);
+        const newItem = new Container(__classPrivateFieldGet(this, _Loader_engine, "f"), tagId, currentOptions);
         if (oldIndex >= 0) {
             dom.splice(oldIndex, 0, newItem);
         }
@@ -68,7 +83,7 @@ export class Loader {
         await newItem.start();
         return newItem;
     }
-    static async loadRemoteOptions(params) {
+    async loadRemoteOptions(params) {
         const { url: jsonUrl, index } = params;
         const url = jsonUrl instanceof Array ? itemFromArray(jsonUrl, index) : jsonUrl;
         if (!url) {
@@ -80,14 +95,14 @@ export class Loader {
             return;
         }
         const data = await response.json();
-        return await Loader.loadOptions({
+        return this.loadOptions({
             tagId: params.tagId,
             element: params.element,
             index,
             options: data,
         });
     }
-    static load(tagId, options, index) {
+    load(tagId, options, index) {
         const params = { index };
         if (typeof tagId === "string") {
             params.tagId = tagId;
@@ -103,7 +118,7 @@ export class Loader {
         }
         return this.loadOptions(params);
     }
-    static async set(id, domContainer, options, index) {
+    async set(id, domContainer, options, index) {
         const params = { index };
         if (typeof id === "string") {
             params.tagId = id;
@@ -125,7 +140,7 @@ export class Loader {
         }
         return this.loadOptions(params);
     }
-    static async loadJSON(tagId, jsonUrl, index) {
+    async loadJSON(tagId, jsonUrl, index) {
         let url, id;
         if (typeof jsonUrl === "number" || jsonUrl === undefined) {
             url = tagId;
@@ -134,9 +149,9 @@ export class Loader {
             id = tagId;
             url = jsonUrl;
         }
-        return await Loader.loadRemoteOptions({ tagId: id, url, index });
+        return this.loadRemoteOptions({ tagId: id, url, index });
     }
-    static async setJSON(id, domContainer, jsonUrl, index) {
+    async setJSON(id, domContainer, jsonUrl, index) {
         let url, newId, newIndex, element;
         if (id instanceof HTMLElement) {
             element = id;
@@ -149,10 +164,10 @@ export class Loader {
             url = jsonUrl;
             newIndex = index;
         }
-        return await Loader.loadRemoteOptions({ tagId: newId, url, index: newIndex, element });
+        return this.loadRemoteOptions({ tagId: newId, url, index: newIndex, element });
     }
-    static setOnClickHandler(callback) {
-        const dom = Loader.dom();
+    setOnClickHandler(callback) {
+        const dom = this.dom();
         if (dom.length === 0) {
             throw new Error("Can only set click handlers after calling tsParticles.load() or tsParticles.loadJSON()");
         }
@@ -161,3 +176,4 @@ export class Loader {
         }
     }
 }
+_Loader_engine = new WeakMap();

package/esm/Core/Particle.d.ts

@@ -2,11 +2,13 @@ import { ShapeType } from "../Enums";
 import type { IBubbleParticleData, ICoordinates, ICoordinates3d, IDelta, IHsl, IParticle, IParticleGradientAnimation, IParticleHslAnimation, IParticleLife, IParticleNumericValueAnimation, IParticleRetinaProps, IParticleRoll, IParticleSpin, IParticleTiltValueAnimation, IParticleValueAnimation, IParticleWobble, IRgb, IShapeValues } from "./Interfaces";
 import { Vector, Vector3d } from "./Utils";
 import type { Container } from "./Container";
+import type { Engine } from "../engine";
 import type { IParticles } from "../Options/Interfaces/Particles/IParticles";
 import { ParticlesOptions } from "../Options/Classes/Particles/ParticlesOptions";
 import type { RecursivePartial } from "../Types";
 import type { Stroke } from "../Options/Classes/Particles/Stroke";
 export declare class Particle implements IParticle {
+    #private;
     readonly id: number;
     readonly container: Container;
     readonly group?: string | undefined;
@@ -49,7 +51,7 @@ export declare class Particle implements IParticle {
     readonly bubble: IBubbleParticleData;
     readonly zIndexFactor: number;
     readonly retina: IParticleRetinaProps;
-    constructor(id: number, container: Container, position?: ICoordinates, overrideOptions?: RecursivePartial<IParticles>, group?: string | undefined);
+    constructor(engine: Engine, id: number, container: Container, position?: ICoordinates, overrideOptions?: RecursivePartial<IParticles>, group?: string | undefined);
     isVisible(): boolean;
     isInsideCanvas(): boolean;
     draw(delta: IDelta): void;

package/esm/Core/Particle.js

@@ -1,4 +1,16 @@
-import { Plugins, Vector, Vector3d } from "./Utils";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Particle_engine;
+import { Vector, Vector3d } from "./Utils";
 import { alterHsl, clamp, colorToRgb, deepExtend, getDistance, getHslFromAnimation, getParticleBaseVelocity, getParticleDirectionAngle, getRangeMax, getRangeMin, getRangeValue, getValue, isInArray, itemFromArray, randomInRange, setRangeValue, } from "../Utils";
 import { ParticlesOptions } from "../Options/Classes/Particles/ParticlesOptions";
 import { Shape } from "../Options/Classes/Particles/Shape/Shape";
@@ -13,11 +25,13 @@ const fixOutMode = (data) => {
     }
 };
 export class Particle {
-    constructor(id, container, position, overrideOptions, group) {
+    constructor(engine, id, container, position, overrideOptions, group) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         this.id = id;
         this.container = container;
         this.group = group;
+        _Particle_engine.set(this, void 0);
+        __classPrivateFieldSet(this, _Particle_engine, engine, "f");
         this.fill = true;
         this.close = true;
         this.lastPathTime = 0;
@@ -115,7 +129,7 @@ export class Particle {
         this.sides = 24;
         let drawer = container.drawers.get(this.shape);
         if (!drawer) {
-            drawer = Plugins.getShapeDrawer(this.shape);
+            drawer = __classPrivateFieldGet(this, _Particle_engine, "f").plugins.getShapeDrawer(this.shape);
             if (drawer) {
                 container.drawers.set(this.shape, drawer);
             }
@@ -363,3 +377,4 @@ export class Particle {
         return life;
     }
 }
+_Particle_engine = new WeakMap();

package/esm/Core/Particles.d.ts

@@ -1,10 +1,12 @@
 import type { ICoordinates, IDelta, IMouseData, IParticle, IRgb } from "./Interfaces";
 import { QuadTree } from "./Utils";
 import type { Container } from "./Container";
+import type { Engine } from "../engine";
 import type { IParticles } from "../Options/Interfaces/Particles/IParticles";
 import { Particle } from "./Particle";
 import type { RecursivePartial } from "../Types";
 export declare class Particles {
+    #private;
     private readonly container;
     get count(): number;
     quadTree: QuadTree;
@@ -22,7 +24,7 @@ export declare class Particles {
     private nextId;
     private readonly freqs;
     private readonly mover;
-    constructor(container: Container);
+    constructor(engine: Engine, container: Container);
     init(): void;
     redraw(): void;
     removeAt(index: number, quantity?: number, group?: string, override?: boolean): void;

package/esm/Core/Particles.js

@@ -1,10 +1,24 @@
-import { InteractionManager, ParticlesMover, Plugins, Point, QuadTree, Rectangle } from "./Utils";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Particles_engine;
+import { InteractionManager, ParticlesMover, Point, QuadTree, Rectangle } from "./Utils";
 import { getRangeMax, getRangeMin, getRangeValue, randomInRange, setRangeValue } from "../Utils";
 import { Particle } from "./Particle";
 import { ParticlesOptions } from "../Options/Classes/Particles/ParticlesOptions";
 export class Particles {
-    constructor(container) {
+    constructor(engine, container) {
         this.container = container;
+        _Particles_engine.set(this, void 0);
+        __classPrivateFieldSet(this, _Particles_engine, engine, "f");
         this.nextId = 0;
         this.array = [];
         this.zArray = [];
@@ -16,11 +30,11 @@ export class Particles {
             links: new Map(),
             triangles: new Map(),
         };
-        this.interactionManager = new InteractionManager(container);
+        this.interactionManager = new InteractionManager(__classPrivateFieldGet(this, _Particles_engine, "f"), container);
         const canvasSize = this.container.canvas.size;
         this.linksColors = new Map();
         this.quadTree = new QuadTree(new Rectangle(-canvasSize.width / 4, -canvasSize.height / 4, (canvasSize.width * 3) / 2, (canvasSize.height * 3) / 2), 4);
-        this.updaters = Plugins.getUpdaters(container, true);
+        this.updaters = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getUpdaters(container, true);
     }
     get count() {
         return this.array.length;
@@ -34,7 +48,7 @@ export class Particles {
         this.freqs.links = new Map();
         this.freqs.triangles = new Map();
         let handled = false;
-        this.updaters = Plugins.getUpdaters(container, true);
+        this.updaters = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getUpdaters(container, true);
         this.interactionManager.init();
         for (const [, plugin] of container.plugins) {
             if (plugin.particlesInitialization !== undefined) {
@@ -281,7 +295,7 @@ export class Particles {
     }
     pushParticle(position, overrideOptions, group, initializer) {
         try {
-            const particle = new Particle(this.nextId, this.container, position, overrideOptions, group);
+            const particle = new Particle(__classPrivateFieldGet(this, _Particles_engine, "f"), this.nextId, this.container, position, overrideOptions, group);
             let canAdd = true;
             if (initializer) {
                 canAdd = initializer(particle);
@@ -300,3 +314,4 @@ export class Particles {
         }
     }
 }
+_Particles_engine = new WeakMap();

package/esm/Core/Utils/InteractionManager.d.ts

@@ -1,11 +1,13 @@
 import type { IDelta } from "../Interfaces";
 import type { Container } from "../Container";
+import type { Engine } from "../../engine";
 import type { Particle } from "../Particle";
 export declare class InteractionManager {
+    #private;
     private readonly container;
-    private readonly externalInteractors;
-    private readonly particleInteractors;
-    constructor(container: Container);
+    private externalInteractors;
+    private particleInteractors;
+    constructor(engine: Engine, container: Container);
     init(): void;
     externalInteract(delta: IDelta): void;
     particlesInteract(particle: Particle, delta: IDelta): void;

package/esm/Core/Utils/InteractionManager.js

@@ -1,13 +1,28 @@
-import { Plugins } from "../Utils";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _InteractionManager_engine;
 export class InteractionManager {
-    constructor(container) {
+    constructor(engine, container) {
         this.container = container;
+        _InteractionManager_engine.set(this, void 0);
+        __classPrivateFieldSet(this, _InteractionManager_engine, engine, "f");
         this.externalInteractors = [];
         this.particleInteractors = [];
         this.init();
     }
     init() {
-        const interactors = Plugins.getInteractors(this.container, true);
+        const interactors = __classPrivateFieldGet(this, _InteractionManager_engine, "f").plugins.getInteractors(this.container, true);
+        this.externalInteractors = [];
+        this.particleInteractors = [];
         for (const interactor of interactors) {
             switch (interactor.type) {
                 case 0:
@@ -37,3 +52,4 @@ export class InteractionManager {
         }
     }
 }
+_InteractionManager_engine = new WeakMap();

package/esm/Core/Utils/Plugins.d.ts

@@ -1,22 +1,36 @@
 import type { IContainerPlugin, IInteractor, IMovePathGenerator, IParticleUpdater, IPlugin, IShapeDrawer } from "../Interfaces";
 import type { Container } from "../Container";
+import type { Engine } from "../../engine";
 import type { IOptions } from "../../Options/Interfaces/IOptions";
 import type { Options } from "../../Options/Classes/Options";
 import type { RecursivePartial } from "../../Types";
+declare type InteractorInitializer = (container: Container) => IInteractor;
+declare type UpdaterInitializer = (container: Container) => IParticleUpdater;
 export declare class Plugins {
-    static getPlugin(plugin: string): IPlugin | undefined;
-    static addPlugin(plugin: IPlugin): void;
-    static getAvailablePlugins(container: Container): Map<string, IContainerPlugin>;
-    static loadOptions(options: Options, sourceOptions: RecursivePartial<IOptions>): void;
-    static getPreset(preset: string): RecursivePartial<IOptions> | undefined;
-    static addPreset(presetKey: string, options: RecursivePartial<IOptions>, override?: boolean): void;
-    static addShapeDrawer(type: string, drawer: IShapeDrawer): void;
-    static getShapeDrawer(type: string): IShapeDrawer | undefined;
-    static getSupportedShapes(): IterableIterator<string>;
-    static getPathGenerator(type: string): IMovePathGenerator | undefined;
-    static addPathGenerator(type: string, pathGenerator: IMovePathGenerator): void;
-    static getInteractors(container: Container, force?: boolean): IInteractor[];
-    static addInteractor(name: string, initInteractor: (container: Container) => IInteractor): void;
-    static getUpdaters(container: Container, force?: boolean): IParticleUpdater[];
-    static addParticleUpdater(name: string, initUpdater: (container: Container) => IParticleUpdater): void;
+    #private;
+    readonly plugins: IPlugin[];
+    readonly interactorsInitializers: Map<string, InteractorInitializer>;
+    readonly updatersInitializers: Map<string, UpdaterInitializer>;
+    readonly interactors: Map<Container, IInteractor[]>;
+    readonly updaters: Map<Container, IParticleUpdater[]>;
+    readonly presets: Map<string, RecursivePartial<IOptions>>;
+    readonly drawers: Map<string, IShapeDrawer>;
+    readonly pathGenerators: Map<string, IMovePathGenerator>;
+    constructor(engine: Engine);
+    getPlugin(plugin: string): IPlugin | undefined;
+    addPlugin(plugin: IPlugin): void;
+    getAvailablePlugins(container: Container): Map<string, IContainerPlugin>;
+    loadOptions(options: Options, sourceOptions: RecursivePartial<IOptions>): void;
+    getPreset(preset: string): RecursivePartial<IOptions> | undefined;
+    addPreset(presetKey: string, options: RecursivePartial<IOptions>, override?: boolean): void;
+    addShapeDrawer(type: string, drawer: IShapeDrawer): void;
+    getShapeDrawer(type: string): IShapeDrawer | undefined;
+    getSupportedShapes(): IterableIterator<string>;
+    getPathGenerator(type: string): IMovePathGenerator | undefined;
+    addPathGenerator(type: string, pathGenerator: IMovePathGenerator): void;
+    getInteractors(container: Container, force?: boolean): IInteractor[];
+    addInteractor(name: string, initInteractor: (container: Container) => IInteractor): void;
+    getUpdaters(container: Container, force?: boolean): IParticleUpdater[];
+    addParticleUpdater(name: string, initUpdater: (container: Container) => IParticleUpdater): void;
 }
+export {};

package/esm/Core/Utils/Plugins.js

@@ -1,23 +1,34 @@
-const plugins = [];
-const interactorsInitializers = new Map();
-const updatersInitializers = new Map();
-const interactors = new Map();
-const updaters = new Map();
-const presets = new Map();
-const drawers = new Map();
-const pathGenerators = new Map();
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Plugins_engine;
 export class Plugins {
-    static getPlugin(plugin) {
-        return plugins.find((t) => t.id === plugin);
+    constructor(engine) {
+        _Plugins_engine.set(this, void 0);
+        __classPrivateFieldSet(this, _Plugins_engine, engine, "f");
+        this.plugins = [];
+        this.interactorsInitializers = new Map();
+        this.updatersInitializers = new Map();
+        this.interactors = new Map();
+        this.updaters = new Map();
+        this.presets = new Map();
+        this.drawers = new Map();
+        this.pathGenerators = new Map();
     }
-    static addPlugin(plugin) {
-        if (!Plugins.getPlugin(plugin.id)) {
-            plugins.push(plugin);
+    getPlugin(plugin) {
+        return this.plugins.find((t) => t.id === plugin);
+    }
+    addPlugin(plugin) {
+        if (!this.getPlugin(plugin.id)) {
+            this.plugins.push(plugin);
         }
     }
-    static getAvailablePlugins(container) {
+    getAvailablePlugins(container) {
         const res = new Map();
-        for (const plugin of plugins) {
+        for (const plugin of this.plugins) {
             if (!plugin.needsPlugin(container.actualOptions)) {
                 continue;
             }
@@ -25,58 +36,59 @@ export class Plugins {
         }
         return res;
     }
-    static loadOptions(options, sourceOptions) {
-        for (const plugin of plugins) {
+    loadOptions(options, sourceOptions) {
+        for (const plugin of this.plugins) {
             plugin.loadOptions(options, sourceOptions);
         }
     }
-    static getPreset(preset) {
-        return presets.get(preset);
+    getPreset(preset) {
+        return this.presets.get(preset);
     }
-    static addPreset(presetKey, options, override = false) {
-        if (override || !Plugins.getPreset(presetKey)) {
-            presets.set(presetKey, options);
+    addPreset(presetKey, options, override = false) {
+        if (override || !this.getPreset(presetKey)) {
+            this.presets.set(presetKey, options);
         }
     }
-    static addShapeDrawer(type, drawer) {
-        if (!Plugins.getShapeDrawer(type)) {
-            drawers.set(type, drawer);
+    addShapeDrawer(type, drawer) {
+        if (!this.getShapeDrawer(type)) {
+            this.drawers.set(type, drawer);
         }
     }
-    static getShapeDrawer(type) {
-        return drawers.get(type);
+    getShapeDrawer(type) {
+        return this.drawers.get(type);
     }
-    static getSupportedShapes() {
-        return drawers.keys();
+    getSupportedShapes() {
+        return this.drawers.keys();
     }
-    static getPathGenerator(type) {
-        return pathGenerators.get(type);
+    getPathGenerator(type) {
+        return this.pathGenerators.get(type);
     }
-    static addPathGenerator(type, pathGenerator) {
-        if (!Plugins.getPathGenerator(type)) {
-            pathGenerators.set(type, pathGenerator);
+    addPathGenerator(type, pathGenerator) {
+        if (!this.getPathGenerator(type)) {
+            this.pathGenerators.set(type, pathGenerator);
         }
     }
-    static getInteractors(container, force = false) {
-        let res = interactors.get(container);
+    getInteractors(container, force = false) {
+        let res = this.interactors.get(container);
         if (!res || force) {
-            res = [...interactorsInitializers.values()].map((t) => t(container));
-            interactors.set(container, res);
+            res = [...this.interactorsInitializers.values()].map((t) => t(container));
+            this.interactors.set(container, res);
         }
         return res;
     }
-    static addInteractor(name, initInteractor) {
-        interactorsInitializers.set(name, initInteractor);
+    addInteractor(name, initInteractor) {
+        this.interactorsInitializers.set(name, initInteractor);
     }
-    static getUpdaters(container, force = false) {
-        let res = updaters.get(container);
+    getUpdaters(container, force = false) {
+        let res = this.updaters.get(container);
         if (!res || force) {
-            res = [...updatersInitializers.values()].map((t) => t(container));
-            updaters.set(container, res);
+            res = [...this.updatersInitializers.values()].map((t) => t(container));
+            this.updaters.set(container, res);
         }
         return res;
     }
-    static addParticleUpdater(name, initUpdater) {
-        updatersInitializers.set(name, initUpdater);
+    addParticleUpdater(name, initUpdater) {
+        this.updatersInitializers.set(name, initUpdater);
     }
 }
+_Plugins_engine = new WeakMap();

package/esm/Options/Classes/Options.d.ts

@@ -1,6 +1,7 @@
 import type { RangeValue, RecursivePartial } from "../../Types";
 import { Background } from "./Background/Background";
 import { BackgroundMask } from "./BackgroundMask/BackgroundMask";
+import type { Engine } from "../../engine";
 import { FullScreen } from "./FullScreen/FullScreen";
 import type { IOptionLoader } from "../Interfaces/IOptionLoader";
 import type { IOptions } from "../Interfaces/IOptions";
@@ -39,7 +40,7 @@ export declare class Options implements IOptions, IOptionLoader<IOptions> {
     defaultDarkTheme?: string;
     defaultLightTheme?: string;
     [name: string]: unknown;
-    constructor();
+    constructor(engine: Engine);
     load(data?: RecursivePartial<IOptions>): void;
     setTheme(name?: string): void;
     setResponsive(width: number, pxRatio: number, defaultOptions: IOptions): number | undefined;

package/esm/Options/Classes/Options.js

@@ -1,9 +1,15 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Options_instances, _Options_findDefaultTheme;
+var _Options_instances, _Options_engine, _Options_findDefaultTheme;
 import { Background } from "./Background/Background";
 import { BackgroundMask } from "./BackgroundMask/BackgroundMask";
 import { FullScreen } from "./FullScreen/FullScreen";
@@ -11,20 +17,21 @@ import { Interactivity } from "./Interactivity/Interactivity";
 import { ManualParticle } from "./ManualParticle";
 import { Motion } from "./Motion/Motion";
 import { ParticlesOptions } from "./Particles/ParticlesOptions";
-import { Plugins } from "../../Core";
 import { Responsive } from "./Responsive";
 import { Theme } from "./Theme/Theme";
 import { deepExtend } from "../../Utils";
 export class Options {
-    constructor() {
+    constructor(engine) {
         _Options_instances.add(this);
+        _Options_engine.set(this, void 0);
+        __classPrivateFieldSet(this, _Options_engine, engine, "f");
         this.autoPlay = true;
         this.background = new Background();
         this.backgroundMask = new BackgroundMask();
         this.fullScreen = new FullScreen();
         this.detectRetina = true;
         this.duration = 0;
-        this.fpsLimit = 60;
+        this.fpsLimit = 120;
         this.interactivity = new Interactivity();
         this.manualParticles = [];
         this.motion = new Motion();
@@ -112,7 +119,7 @@ export class Options {
         this.motion.load(data.motion);
         this.particles.load(data.particles);
         this.style = deepExtend(this.style, data.style);
-        Plugins.loadOptions(this, data);
+        __classPrivateFieldGet(this, _Options_engine, "f").plugins.loadOptions(this, data);
         if (data.responsive !== undefined) {
             for (const responsive of data.responsive) {
                 const optResponsive = new Responsive();
@@ -154,10 +161,10 @@ export class Options {
         return responsiveOptions === null || responsiveOptions === void 0 ? void 0 : responsiveOptions.maxWidth;
     }
     importPreset(preset) {
-        this.load(Plugins.getPreset(preset));
+        this.load(__classPrivateFieldGet(this, _Options_engine, "f").plugins.getPreset(preset));
     }
 }
-_Options_instances = new WeakSet(), _Options_findDefaultTheme = function _Options_findDefaultTheme(mode) {
+_Options_engine = new WeakMap(), _Options_instances = new WeakSet(), _Options_findDefaultTheme = function _Options_findDefaultTheme(mode) {
     var _a;
     return ((_a = this.themes.find((theme) => theme.default.value && theme.default.mode === mode)) !== null && _a !== void 0 ? _a : this.themes.find((theme) => theme.default.value && theme.default.mode === "any"));
 };