tsparticles 1.40.2 → 1.41.3

package/umd/Utils/Utils.js

@@ -0,0 +1,279 @@
+(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", "./NumberUtils", "../Core"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.rectBounce = exports.circleBounce = exports.circleBounceDataFromParticle = exports.divMode = exports.singleDivModeExecute = exports.divModeExecute = exports.isDivModeEnabled = exports.deepExtend = exports.calculateBounds = exports.areBoundsInside = exports.isPointInside = exports.itemFromArray = exports.arrayRandomIndex = exports.loadFont = exports.isInArray = exports.cancelAnimation = exports.animate = exports.isSsr = void 0;
+    const NumberUtils_1 = require("./NumberUtils");
+    const Core_1 = require("../Core");
+    function rectSideBounce(pSide, pOtherSide, rectSide, rectOtherSide, velocity, factor) {
+        const res = { bounced: false };
+        if (pOtherSide.min >= rectOtherSide.min &&
+            pOtherSide.min <= rectOtherSide.max &&
+            pOtherSide.max >= rectOtherSide.min &&
+            pOtherSide.max <= rectOtherSide.max) {
+            if ((pSide.max >= rectSide.min && pSide.max <= (rectSide.max + rectSide.min) / 2 && velocity > 0) ||
+                (pSide.min <= rectSide.max && pSide.min > (rectSide.max + rectSide.min) / 2 && velocity < 0)) {
+                res.velocity = velocity * -factor;
+                res.bounced = true;
+            }
+        }
+        return res;
+    }
+    function checkSelector(element, selectors) {
+        if (selectors instanceof Array) {
+            for (const selector of selectors) {
+                if (element.matches(selector)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else {
+            return element.matches(selectors);
+        }
+    }
+    function isSsr() {
+        return typeof window === "undefined" || !window || typeof window.document === "undefined" || !window.document;
+    }
+    exports.isSsr = isSsr;
+    function animate() {
+        return isSsr()
+            ? (callback) => setTimeout(callback)
+            : (callback) => (window.requestAnimationFrame ||
+                window.webkitRequestAnimationFrame ||
+                window.mozRequestAnimationFrame ||
+                window.oRequestAnimationFrame ||
+                window.msRequestAnimationFrame ||
+                window.setTimeout)(callback);
+    }
+    exports.animate = animate;
+    function cancelAnimation() {
+        return isSsr()
+            ? (handle) => clearTimeout(handle)
+            : (handle) => (window.cancelAnimationFrame ||
+                window.webkitCancelRequestAnimationFrame ||
+                window.mozCancelRequestAnimationFrame ||
+                window.oCancelRequestAnimationFrame ||
+                window.msCancelRequestAnimationFrame ||
+                window.clearTimeout)(handle);
+    }
+    exports.cancelAnimation = cancelAnimation;
+    function isInArray(value, array) {
+        return value === array || (array instanceof Array && array.indexOf(value) > -1);
+    }
+    exports.isInArray = isInArray;
+    async function loadFont(character) {
+        var _a, _b;
+        try {
+            await document.fonts.load(`${(_a = character.weight) !== null && _a !== void 0 ? _a : "400"} 36px '${(_b = character.font) !== null && _b !== void 0 ? _b : "Verdana"}'`);
+        }
+        catch (_c) {
+        }
+    }
+    exports.loadFont = loadFont;
+    function arrayRandomIndex(array) {
+        return Math.floor(Math.random() * array.length);
+    }
+    exports.arrayRandomIndex = arrayRandomIndex;
+    function itemFromArray(array, index, useIndex = true) {
+        const fixedIndex = index !== undefined && useIndex ? index % array.length : arrayRandomIndex(array);
+        return array[fixedIndex];
+    }
+    exports.itemFromArray = itemFromArray;
+    function isPointInside(point, size, radius, direction) {
+        return areBoundsInside(calculateBounds(point, radius !== null && radius !== void 0 ? radius : 0), size, direction);
+    }
+    exports.isPointInside = isPointInside;
+    function areBoundsInside(bounds, size, direction) {
+        let inside = true;
+        if (!direction || direction === "bottom") {
+            inside = bounds.top < size.height;
+        }
+        if (inside && (!direction || direction === "left")) {
+            inside = bounds.right > 0;
+        }
+        if (inside && (!direction || direction === "right")) {
+            inside = bounds.left < size.width;
+        }
+        if (inside && (!direction || direction === "top")) {
+            inside = bounds.bottom > 0;
+        }
+        return inside;
+    }
+    exports.areBoundsInside = areBoundsInside;
+    function calculateBounds(point, radius) {
+        return {
+            bottom: point.y + radius,
+            left: point.x - radius,
+            right: point.x + radius,
+            top: point.y - radius,
+        };
+    }
+    exports.calculateBounds = calculateBounds;
+    function deepExtend(destination, ...sources) {
+        for (const source of sources) {
+            if (source === undefined || source === null) {
+                continue;
+            }
+            if (typeof source !== "object") {
+                destination = source;
+                continue;
+            }
+            const sourceIsArray = Array.isArray(source);
+            if (sourceIsArray && (typeof destination !== "object" || !destination || !Array.isArray(destination))) {
+                destination = [];
+            }
+            else if (!sourceIsArray && (typeof destination !== "object" || !destination || Array.isArray(destination))) {
+                destination = {};
+            }
+            for (const key in source) {
+                if (key === "__proto__") {
+                    continue;
+                }
+                const sourceDict = source;
+                const value = sourceDict[key];
+                const isObject = typeof value === "object";
+                const destDict = destination;
+                destDict[key] =
+                    isObject && Array.isArray(value)
+                        ? value.map((v) => deepExtend(destDict[key], v))
+                        : deepExtend(destDict[key], value);
+            }
+        }
+        return destination;
+    }
+    exports.deepExtend = deepExtend;
+    function isDivModeEnabled(mode, divs) {
+        return divs instanceof Array ? !!divs.find((t) => t.enable && isInArray(mode, t.mode)) : isInArray(mode, divs.mode);
+    }
+    exports.isDivModeEnabled = isDivModeEnabled;
+    function divModeExecute(mode, divs, callback) {
+        if (divs instanceof Array) {
+            for (const div of divs) {
+                const divMode = div.mode;
+                const divEnabled = div.enable;
+                if (divEnabled && isInArray(mode, divMode)) {
+                    singleDivModeExecute(div, callback);
+                }
+            }
+        }
+        else {
+            const divMode = divs.mode;
+            const divEnabled = divs.enable;
+            if (divEnabled && isInArray(mode, divMode)) {
+                singleDivModeExecute(divs, callback);
+            }
+        }
+    }
+    exports.divModeExecute = divModeExecute;
+    function singleDivModeExecute(div, callback) {
+        const selectors = div.selectors;
+        if (selectors instanceof Array) {
+            for (const selector of selectors) {
+                callback(selector, div);
+            }
+        }
+        else {
+            callback(selectors, div);
+        }
+    }
+    exports.singleDivModeExecute = singleDivModeExecute;
+    function divMode(divs, element) {
+        if (!element || !divs) {
+            return;
+        }
+        if (divs instanceof Array) {
+            return divs.find((d) => checkSelector(element, d.selectors));
+        }
+        else if (checkSelector(element, divs.selectors)) {
+            return divs;
+        }
+    }
+    exports.divMode = divMode;
+    function circleBounceDataFromParticle(p) {
+        return {
+            position: p.getPosition(),
+            radius: p.getRadius(),
+            mass: p.getMass(),
+            velocity: p.velocity,
+            factor: Core_1.Vector.create((0, NumberUtils_1.getValue)(p.options.bounce.horizontal), (0, NumberUtils_1.getValue)(p.options.bounce.vertical)),
+        };
+    }
+    exports.circleBounceDataFromParticle = circleBounceDataFromParticle;
+    function circleBounce(p1, p2) {
+        const { x: xVelocityDiff, y: yVelocityDiff } = p1.velocity.sub(p2.velocity);
+        const [pos1, pos2] = [p1.position, p2.position];
+        const { dx: xDist, dy: yDist } = (0, NumberUtils_1.getDistances)(pos2, pos1);
+        if (xVelocityDiff * xDist + yVelocityDiff * yDist >= 0) {
+            const angle = -Math.atan2(yDist, xDist);
+            const m1 = p1.mass;
+            const m2 = p2.mass;
+            const u1 = p1.velocity.rotate(angle);
+            const u2 = p2.velocity.rotate(angle);
+            const v1 = (0, NumberUtils_1.collisionVelocity)(u1, u2, m1, m2);
+            const v2 = (0, NumberUtils_1.collisionVelocity)(u2, u1, m1, m2);
+            const vFinal1 = v1.rotate(-angle);
+            const vFinal2 = v2.rotate(-angle);
+            p1.velocity.x = vFinal1.x * p1.factor.x;
+            p1.velocity.y = vFinal1.y * p1.factor.y;
+            p2.velocity.x = vFinal2.x * p2.factor.x;
+            p2.velocity.y = vFinal2.y * p2.factor.y;
+        }
+    }
+    exports.circleBounce = circleBounce;
+    function rectBounce(particle, divBounds) {
+        const pPos = particle.getPosition();
+        const size = particle.getRadius();
+        const bounds = calculateBounds(pPos, size);
+        const resH = rectSideBounce({
+            min: bounds.left,
+            max: bounds.right,
+        }, {
+            min: bounds.top,
+            max: bounds.bottom,
+        }, {
+            min: divBounds.left,
+            max: divBounds.right,
+        }, {
+            min: divBounds.top,
+            max: divBounds.bottom,
+        }, particle.velocity.x, (0, NumberUtils_1.getValue)(particle.options.bounce.horizontal));
+        if (resH.bounced) {
+            if (resH.velocity !== undefined) {
+                particle.velocity.x = resH.velocity;
+            }
+            if (resH.position !== undefined) {
+                particle.position.x = resH.position;
+            }
+        }
+        const resV = rectSideBounce({
+            min: bounds.top,
+            max: bounds.bottom,
+        }, {
+            min: bounds.left,
+            max: bounds.right,
+        }, {
+            min: divBounds.top,
+            max: divBounds.bottom,
+        }, {
+            min: divBounds.left,
+            max: divBounds.right,
+        }, particle.velocity.y, (0, NumberUtils_1.getValue)(particle.options.bounce.vertical));
+        if (resV.bounced) {
+            if (resV.velocity !== undefined) {
+                particle.velocity.y = resV.velocity;
+            }
+            if (resV.position !== undefined) {
+                particle.position.y = resV.position;
+            }
+        }
+    }
+    exports.rectBounce = rectBounce;
+});

package/umd/Utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./CanvasUtils";
+export * from "./ColorUtils";
+export * from "./NumberUtils";
+export * from "./Utils";

package/umd/Utils/index.js

@@ -0,0 +1,26 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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);
+};
+(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", "./CanvasUtils", "./ColorUtils", "./NumberUtils", "./Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./CanvasUtils"), exports);
+    __exportStar(require("./ColorUtils"), exports);
+    __exportStar(require("./NumberUtils"), exports);
+    __exportStar(require("./Utils"), exports);
+});

package/umd/engine.d.ts

@@ -0,0 +1,26 @@
+import type { Container, IInteractor, IMovePathGenerator, IParticleUpdater, IPlugin, IShapeDrawer, Particle } from "./Core";
+import { Plugins } from "./Core";
+import type { RecursivePartial, ShapeDrawerAfterEffectFunction, ShapeDrawerDestroyFunction, ShapeDrawerDrawFunction, ShapeDrawerInitFunction, SingleOrMultiple } from "./Types";
+import type { IOptions } from "./Options/Interfaces/IOptions";
+export declare class Engine {
+    #private;
+    readonly domArray: Container[];
+    readonly plugins: Plugins;
+    constructor();
+    init(): void;
+    loadFromArray(tagId: string, options: RecursivePartial<IOptions>[], index?: number): Promise<Container | undefined>;
+    load(tagId: string | SingleOrMultiple<RecursivePartial<IOptions>>, options?: SingleOrMultiple<RecursivePartial<IOptions>>): Promise<Container | undefined>;
+    set(id: string | HTMLElement, element: HTMLElement | RecursivePartial<IOptions>, options?: RecursivePartial<IOptions>): Promise<Container | undefined>;
+    loadJSON(tagId: string | SingleOrMultiple<string>, pathConfigJson?: SingleOrMultiple<string> | number, index?: number): Promise<Container | undefined>;
+    setJSON(id: string | HTMLElement, element: HTMLElement | SingleOrMultiple<string>, pathConfigJson?: SingleOrMultiple<string> | number, index?: number): Promise<Container | undefined>;
+    setOnClickHandler(callback: (e: Event, particles?: Particle[]) => void): void;
+    dom(): Container[];
+    domItem(index: number): Container | undefined;
+    refresh(): Promise<void>;
+    addShape(shape: string, drawer: IShapeDrawer | ShapeDrawerDrawFunction, init?: ShapeDrawerInitFunction, afterEffect?: ShapeDrawerAfterEffectFunction, destroy?: ShapeDrawerDestroyFunction): Promise<void>;
+    addPreset(preset: string, options: RecursivePartial<IOptions>, override?: boolean): Promise<void>;
+    addPlugin(plugin: IPlugin): Promise<void>;
+    addPathGenerator(name: string, generator: IMovePathGenerator): Promise<void>;
+    addInteractor(name: string, interactorInitializer: (container: Container) => IInteractor): Promise<void>;
+    addParticleUpdater(name: string, updaterInitializer: (container: Container) => IParticleUpdater): Promise<void>;
+}

package/umd/engine.js

@@ -0,0 +1,108 @@
+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);
+};
+(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", "./Core"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var _Engine_initialized, _Engine_loader;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Engine = void 0;
+    const Core_1 = require("./Core");
+    class Engine {
+        constructor() {
+            _Engine_initialized.set(this, void 0);
+            _Engine_loader.set(this, void 0);
+            __classPrivateFieldSet(this, _Engine_initialized, false, "f");
+            this.domArray = [];
+            __classPrivateFieldSet(this, _Engine_loader, new Core_1.Loader(this), "f");
+            this.plugins = new Core_1.Plugins(this);
+        }
+        init() {
+            if (!__classPrivateFieldGet(this, _Engine_initialized, "f")) {
+                __classPrivateFieldSet(this, _Engine_initialized, true, "f");
+            }
+        }
+        async loadFromArray(tagId, options, index) {
+            return __classPrivateFieldGet(this, _Engine_loader, "f").load(tagId, options, index);
+        }
+        async load(tagId, options) {
+            return __classPrivateFieldGet(this, _Engine_loader, "f").load(tagId, options);
+        }
+        async set(id, element, options) {
+            return __classPrivateFieldGet(this, _Engine_loader, "f").set(id, element, options);
+        }
+        async loadJSON(tagId, pathConfigJson, index) {
+            return __classPrivateFieldGet(this, _Engine_loader, "f").loadJSON(tagId, pathConfigJson, index);
+        }
+        async setJSON(id, element, pathConfigJson, index) {
+            return __classPrivateFieldGet(this, _Engine_loader, "f").setJSON(id, element, pathConfigJson, index);
+        }
+        setOnClickHandler(callback) {
+            __classPrivateFieldGet(this, _Engine_loader, "f").setOnClickHandler(callback);
+        }
+        dom() {
+            return __classPrivateFieldGet(this, _Engine_loader, "f").dom();
+        }
+        domItem(index) {
+            return __classPrivateFieldGet(this, _Engine_loader, "f").domItem(index);
+        }
+        async refresh() {
+            for (const instance of this.dom()) {
+                await instance.refresh();
+            }
+        }
+        async addShape(shape, drawer, init, afterEffect, destroy) {
+            let customDrawer;
+            if (typeof drawer === "function") {
+                customDrawer = {
+                    afterEffect: afterEffect,
+                    destroy: destroy,
+                    draw: drawer,
+                    init: init,
+                };
+            }
+            else {
+                customDrawer = drawer;
+            }
+            this.plugins.addShapeDrawer(shape, customDrawer);
+            await this.refresh();
+        }
+        async addPreset(preset, options, override = false) {
+            this.plugins.addPreset(preset, options, override);
+            await this.refresh();
+        }
+        async addPlugin(plugin) {
+            this.plugins.addPlugin(plugin);
+            await this.refresh();
+        }
+        async addPathGenerator(name, generator) {
+            this.plugins.addPathGenerator(name, generator);
+            await this.refresh();
+        }
+        async addInteractor(name, interactorInitializer) {
+            this.plugins.addInteractor(name, interactorInitializer);
+            await this.refresh();
+        }
+        async addParticleUpdater(name, updaterInitializer) {
+            this.plugins.addParticleUpdater(name, updaterInitializer);
+            await this.refresh();
+        }
+    }
+    exports.Engine = Engine;
+    _Engine_initialized = new WeakMap(), _Engine_loader = new WeakMap();
+});

package/umd/full.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "./engine";
+export declare function loadFull(engine: Engine): Promise<void>;

package/umd/full.js

@@ -0,0 +1,32 @@
+(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", "./Plugins/Absorbers", "./Plugins/Emitters", "./Interactions/External/Trail", "./Plugins/PolygonMask", "./Updaters/Roll", "./slim", "./Updaters/Tilt", "./Updaters/Wobble"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadFull = void 0;
+    const Absorbers_1 = require("./Plugins/Absorbers");
+    const Emitters_1 = require("./Plugins/Emitters");
+    const Trail_1 = require("./Interactions/External/Trail");
+    const PolygonMask_1 = require("./Plugins/PolygonMask");
+    const Roll_1 = require("./Updaters/Roll");
+    const slim_1 = require("./slim");
+    const Tilt_1 = require("./Updaters/Tilt");
+    const Wobble_1 = require("./Updaters/Wobble");
+    async function loadFull(engine) {
+        await (0, slim_1.loadSlim)(engine);
+        await (0, Trail_1.loadExternalTrailInteraction)(engine);
+        await (0, Roll_1.loadRollUpdater)(engine);
+        await (0, Tilt_1.loadTiltUpdater)(engine);
+        await (0, Wobble_1.loadWobbleUpdater)(engine);
+        await (0, Absorbers_1.loadAbsorbersPlugin)(engine);
+        await (0, Emitters_1.loadEmittersPlugin)(engine);
+        await (0, PolygonMask_1.loadPolygonMaskPlugin)(engine);
+    }
+    exports.loadFull = loadFull;
+});

package/umd/index.d.ts

@@ -0,0 +1,20 @@
+import { Engine } from "./engine";
+import type { IAbsorberOptions } from "./Plugins/Absorbers/Options/Interfaces/IAbsorberOptions";
+import type { IEmitterOptions } from "./Plugins/Emitters/Options/Interfaces/IEmitterOptions";
+import type { IPolygonMaskOptions } from "./Plugins/PolygonMask/Options/Interfaces/IPolygonMaskOptions";
+import type { IOptions as ISlimOptions } from "./Options/Interfaces/IOptions";
+import type { RecursivePartial } from "./Types";
+declare const tsParticles: Engine;
+declare const particlesJS: import("./pjs").IParticlesJS, pJSDom: import("./Core").Container[];
+export * from "./Core";
+export * from "./Core/Container";
+export * from "./Enums";
+export * from "./Plugins/Absorbers/Enums";
+export * from "./Plugins/Emitters/Enums";
+export * from "./Plugins/PolygonMask/Enums";
+export { Engine, Engine as Main };
+export * from "./Utils";
+export * from "./Types";
+export { particlesJS, pJSDom, tsParticles };
+export declare type IOptions = ISlimOptions & IAbsorberOptions & IEmitterOptions & IPolygonMaskOptions;
+export declare type ISourceOptions = RecursivePartial<IOptions>;

package/umd/index.engine.d.ts

@@ -0,0 +1,13 @@
+import { Engine } from "./engine";
+import type { IOptions } from "./Options/Interfaces/IOptions";
+import type { RecursivePartial } from "./Types";
+declare const tsParticles: Engine;
+declare const particlesJS: import("./pjs").IParticlesJS, pJSDom: import("./Core").Container[];
+export * from "./Core";
+export * from "./Enums";
+export { Engine, Engine as Main };
+export * from "./Utils";
+export * from "./Types";
+export { tsParticles, particlesJS, pJSDom };
+export { IOptions };
+export declare type ISourceOptions = RecursivePartial<IOptions>;

package/umd/index.engine.js

@@ -0,0 +1,37 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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);
+};
+(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", "./engine", "./pjs", "./Core", "./Enums", "./Utils", "./Types"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.pJSDom = exports.particlesJS = exports.tsParticles = exports.Main = exports.Engine = void 0;
+    const engine_1 = require("./engine");
+    Object.defineProperty(exports, "Engine", { enumerable: true, get: function () { return engine_1.Engine; } });
+    Object.defineProperty(exports, "Main", { enumerable: true, get: function () { return engine_1.Engine; } });
+    const pjs_1 = require("./pjs");
+    const tsParticles = new engine_1.Engine();
+    exports.tsParticles = tsParticles;
+    tsParticles.init();
+    const { particlesJS, pJSDom } = (0, pjs_1.initPjs)(tsParticles);
+    exports.particlesJS = particlesJS;
+    exports.pJSDom = pJSDom;
+    __exportStar(require("./Core"), exports);
+    __exportStar(require("./Enums"), exports);
+    __exportStar(require("./Utils"), exports);
+    __exportStar(require("./Types"), exports);
+});

package/umd/index.js

@@ -0,0 +1,43 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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);
+};
+(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", "./engine", "./pjs", "./full", "./Core", "./Core/Container", "./Enums", "./Plugins/Absorbers/Enums", "./Plugins/Emitters/Enums", "./Plugins/PolygonMask/Enums", "./Utils", "./Types"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.tsParticles = exports.pJSDom = exports.particlesJS = exports.Main = exports.Engine = void 0;
+    const engine_1 = require("./engine");
+    Object.defineProperty(exports, "Engine", { enumerable: true, get: function () { return engine_1.Engine; } });
+    Object.defineProperty(exports, "Main", { enumerable: true, get: function () { return engine_1.Engine; } });
+    const pjs_1 = require("./pjs");
+    const full_1 = require("./full");
+    const tsParticles = new engine_1.Engine();
+    exports.tsParticles = tsParticles;
+    tsParticles.init();
+    const { particlesJS, pJSDom } = (0, pjs_1.initPjs)(tsParticles);
+    exports.particlesJS = particlesJS;
+    exports.pJSDom = pJSDom;
+    (0, full_1.loadFull)(tsParticles);
+    __exportStar(require("./Core"), exports);
+    __exportStar(require("./Core/Container"), exports);
+    __exportStar(require("./Enums"), exports);
+    __exportStar(require("./Plugins/Absorbers/Enums"), exports);
+    __exportStar(require("./Plugins/Emitters/Enums"), exports);
+    __exportStar(require("./Plugins/PolygonMask/Enums"), exports);
+    __exportStar(require("./Utils"), exports);
+    __exportStar(require("./Types"), exports);
+});

package/umd/index.slim.d.ts

@@ -0,0 +1,14 @@
+import { Engine } from "./engine";
+import type { IOptions } from "./Options/Interfaces/IOptions";
+import type { RecursivePartial } from "./Types";
+declare const tsParticles: Engine;
+declare const particlesJS: import("./pjs").IParticlesJS, pJSDom: import("./Core").Container[];
+export * from "./Core";
+export * from "./Core/Container";
+export * from "./Enums";
+export { Engine, Engine as Main };
+export * from "./Utils";
+export * from "./Types";
+export { tsParticles, particlesJS, pJSDom };
+export { IOptions };
+export declare type ISourceOptions = RecursivePartial<IOptions>;

package/umd/index.slim.js

@@ -0,0 +1,40 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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);
+};
+(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", "./engine", "./pjs", "./slim", "./Core", "./Core/Container", "./Enums", "./Utils", "./Types"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.pJSDom = exports.particlesJS = exports.tsParticles = exports.Main = exports.Engine = void 0;
+    const engine_1 = require("./engine");
+    Object.defineProperty(exports, "Engine", { enumerable: true, get: function () { return engine_1.Engine; } });
+    Object.defineProperty(exports, "Main", { enumerable: true, get: function () { return engine_1.Engine; } });
+    const pjs_1 = require("./pjs");
+    const slim_1 = require("./slim");
+    const tsParticles = new engine_1.Engine();
+    exports.tsParticles = tsParticles;
+    tsParticles.init();
+    const { particlesJS, pJSDom } = (0, pjs_1.initPjs)(tsParticles);
+    exports.particlesJS = particlesJS;
+    exports.pJSDom = pJSDom;
+    (0, slim_1.loadSlim)(tsParticles);
+    __exportStar(require("./Core"), exports);
+    __exportStar(require("./Core/Container"), exports);
+    __exportStar(require("./Enums"), exports);
+    __exportStar(require("./Utils"), exports);
+    __exportStar(require("./Types"), exports);
+});