@tsparticles/engine 3.0.0-alpha.0

package/umd/Utils/Utils.js

@@ -0,0 +1,284 @@
+(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/Utils/Vector"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.initParticleNumericAnimationValue = exports.findItemFromSingleOrMultiple = exports.itemFromSingleOrMultiple = exports.executeOnSingleOrMultiple = 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.safeMatchMedia = exports.hasMatchMedia = exports.isSsr = void 0;
+    const NumberUtils_1 = require("./NumberUtils");
+    const Vector_1 = require("../Core/Utils/Vector");
+    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) {
+            return res;
+        }
+        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) {
+        const res = executeOnSingleOrMultiple(selectors, (selector) => {
+            return element.matches(selector);
+        });
+        return res instanceof Array ? res.some((t) => t) : res;
+    }
+    function isSsr() {
+        return typeof window === "undefined" || !window || typeof window.document === "undefined" || !window.document;
+    }
+    exports.isSsr = isSsr;
+    function hasMatchMedia() {
+        return !isSsr() && typeof matchMedia !== "undefined";
+    }
+    exports.hasMatchMedia = hasMatchMedia;
+    function safeMatchMedia(query) {
+        if (!hasMatchMedia()) {
+            return;
+        }
+        return matchMedia(query);
+    }
+    exports.safeMatchMedia = safeMatchMedia;
+    function animate() {
+        return isSsr()
+            ? (callback) => setTimeout(callback)
+            : (callback) => (requestAnimationFrame || setTimeout)(callback);
+    }
+    exports.animate = animate;
+    function cancelAnimation() {
+        return isSsr()
+            ? (handle) => clearTimeout(handle)
+            : (handle) => (cancelAnimationFrame || 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(font, weight) {
+        try {
+            await document.fonts.load(`${weight !== null && weight !== void 0 ? weight : "400"} 36px '${font !== null && font !== void 0 ? font : "Verdana"}'`);
+        }
+        catch (_a) {
+        }
+    }
+    exports.loadFont = loadFont;
+    function arrayRandomIndex(array) {
+        return Math.floor((0, NumberUtils_1.getRandom)() * array.length);
+    }
+    exports.arrayRandomIndex = arrayRandomIndex;
+    function itemFromArray(array, index, useIndex = true) {
+        return array[index !== undefined && useIndex ? index % array.length : arrayRandomIndex(array)];
+    }
+    exports.itemFromArray = itemFromArray;
+    function isPointInside(point, size, offset, radius, direction) {
+        return areBoundsInside(calculateBounds(point, radius !== null && radius !== void 0 ? radius : 0), size, offset, direction);
+    }
+    exports.isPointInside = isPointInside;
+    function areBoundsInside(bounds, size, offset, direction) {
+        let inside = true;
+        if (!direction || direction === "bottom") {
+            inside = bounds.top < size.height + offset.x;
+        }
+        if (inside && (!direction || direction === "left")) {
+            inside = bounds.right > offset.x;
+        }
+        if (inside && (!direction || direction === "right")) {
+            inside = bounds.left < size.width + offset.y;
+        }
+        if (inside && (!direction || direction === "top")) {
+            inside = bounds.bottom > offset.y;
+        }
+        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, value = sourceDict[key], isObject = typeof value === "object", 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 !!findItemFromSingleOrMultiple(divs, (t) => t.enable && isInArray(mode, t.mode));
+    }
+    exports.isDivModeEnabled = isDivModeEnabled;
+    function divModeExecute(mode, divs, callback) {
+        executeOnSingleOrMultiple(divs, (div) => {
+            const divMode = div.mode, divEnabled = div.enable;
+            if (divEnabled && isInArray(mode, divMode)) {
+                singleDivModeExecute(div, callback);
+            }
+        });
+    }
+    exports.divModeExecute = divModeExecute;
+    function singleDivModeExecute(div, callback) {
+        const selectors = div.selectors;
+        executeOnSingleOrMultiple(selectors, (selector) => {
+            callback(selector, div);
+        });
+    }
+    exports.singleDivModeExecute = singleDivModeExecute;
+    function divMode(divs, element) {
+        if (!element || !divs) {
+            return;
+        }
+        return findItemFromSingleOrMultiple(divs, (div) => {
+            return checkSelector(element, div.selectors);
+        });
+    }
+    exports.divMode = divMode;
+    function circleBounceDataFromParticle(p) {
+        return {
+            position: p.getPosition(),
+            radius: p.getRadius(),
+            mass: p.getMass(),
+            velocity: p.velocity,
+            factor: Vector_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), [pos1, pos2] = [p1.position, p2.position], { dx: xDist, dy: yDist } = (0, NumberUtils_1.getDistances)(pos2, pos1);
+        if (xVelocityDiff * xDist + yVelocityDiff * yDist < 0) {
+            return;
+        }
+        const angle = -Math.atan2(yDist, xDist), m1 = p1.mass, m2 = p2.mass, u1 = p1.velocity.rotate(angle), u2 = p2.velocity.rotate(angle), v1 = (0, NumberUtils_1.collisionVelocity)(u1, u2, m1, m2), v2 = (0, NumberUtils_1.collisionVelocity)(u2, u1, m1, m2), vFinal1 = v1.rotate(-angle), 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(), size = particle.getRadius(), bounds = calculateBounds(pPos, size), 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;
+    function executeOnSingleOrMultiple(obj, callback) {
+        return obj instanceof Array ? obj.map((item, index) => callback(item, index)) : callback(obj, 0);
+    }
+    exports.executeOnSingleOrMultiple = executeOnSingleOrMultiple;
+    function itemFromSingleOrMultiple(obj, index, useIndex) {
+        return obj instanceof Array ? itemFromArray(obj, index, useIndex) : obj;
+    }
+    exports.itemFromSingleOrMultiple = itemFromSingleOrMultiple;
+    function findItemFromSingleOrMultiple(obj, callback) {
+        return obj instanceof Array ? obj.find((t, index) => callback(t, index)) : callback(obj, 0) ? obj : undefined;
+    }
+    exports.findItemFromSingleOrMultiple = findItemFromSingleOrMultiple;
+    function initParticleNumericAnimationValue(options, pxRatio) {
+        const valueRange = options.value, animationOptions = options.animation;
+        const res = {
+            enable: options.animation.enable,
+            value: (0, NumberUtils_1.getRangeValue)(options.value) * pxRatio,
+            max: (0, NumberUtils_1.getRangeMax)(valueRange) * pxRatio,
+            min: (0, NumberUtils_1.getRangeMin)(valueRange) * pxRatio,
+            loops: 0,
+            maxLoops: (0, NumberUtils_1.getRangeValue)(options.animation.count),
+        };
+        if (animationOptions.enable) {
+            res.status = "increasing";
+            res.decay = 1 - (0, NumberUtils_1.getRangeValue)(animationOptions.decay);
+            switch (animationOptions.startValue) {
+                case "min":
+                    res.value = res.min;
+                    res.status = "increasing";
+                    break;
+                case "random":
+                    res.value = (0, NumberUtils_1.randomInRange)(res);
+                    res.status = (0, NumberUtils_1.getRandom)() >= 0.5 ? "increasing" : "decreasing";
+                    break;
+                case "max":
+                default:
+                    res.value = res.max;
+                    res.status = "decreasing";
+                    break;
+            }
+        }
+        res.initialValue = res.value;
+        return res;
+    }
+    exports.initParticleNumericAnimationValue = initParticleNumericAnimationValue;
+});

package/umd/bundle.js

@@ -0,0 +1,124 @@
+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);
+};
+(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", "./Utils/HslColorManager", "./Utils/RgbColorManager", "./Utils/ColorUtils", "./Core/Utils/Circle", "./Core/Utils/Constants", "./Core/Utils/ExternalInteractorBase", "./Core/Utils/ParticlesInteractorBase", "./Core/Utils/Point", "./Core/Utils/Range", "./Core/Utils/Rectangle", "./Core/Utils/Vector", "./Core/Utils/Vector3d", "./Enums/Directions/MoveDirection", "./Enums/Directions/RotateDirection", "./Enums/Directions/OutModeDirection", "./Enums/Modes/ClickMode", "./Enums/Modes/DivMode", "./Enums/Modes/HoverMode", "./Enums/Modes/CollisionMode", "./Enums/Modes/OutMode", "./Enums/Modes/SizeMode", "./Enums/Modes/ThemeMode", "./Enums/Modes/ResponsiveMode", "./Enums/Types/AlterType", "./Enums/Types/DestroyType", "./Enums/Types/GradientType", "./Enums/Types/InteractorType", "./Enums/Types/ParticleOutType", "./Enums/Types/StartValueType", "./Enums/Types/DivType", "./Enums/Types/EasingType", "./Enums/AnimationStatus", "./Enums/InteractivityDetect", "./Options/Classes/AnimatableColor", "./Options/Classes/AnimationOptions", "./Options/Classes/Background/Background", "./Options/Classes/BackgroundMask/BackgroundMask", "./Options/Classes/BackgroundMask/BackgroundMaskCover", "./Options/Classes/ColorAnimation", "./Options/Classes/FullScreen/FullScreen", "./Options/Classes/HslAnimation", "./Options/Classes/Interactivity/Events/ClickEvent", "./Options/Classes/Interactivity/Events/DivEvent", "./Options/Classes/Interactivity/Events/ClickEvent", "./Options/Classes/Interactivity/Events/DivEvent", "./Options/Classes/Interactivity/Events/Events", "./Options/Classes/Interactivity/Events/HoverEvent", "./Options/Classes/Interactivity/Events/Parallax", "./Options/Classes/Interactivity/Events/ResizeEvent", "./Options/Classes/Interactivity/Interactivity", "./Options/Classes/Interactivity/Modes/Modes", "./Options/Classes/ManualParticle", "./Options/Classes/Options", "./Options/Classes/OptionsColor", "./Options/Classes/Particles/Bounce/ParticlesBounce", "./Options/Classes/Particles/Bounce/ParticlesBounceFactor", "./Options/Classes/Particles/Collisions/Collisions", "./Options/Classes/Particles/Collisions/CollisionsAbsorb", "./Options/Classes/Particles/Collisions/CollisionsOverlap", "./Options/Classes/Particles/ParticlesOptions", "./Options/Classes/Particles/Shadow", "./Options/Classes/Particles/Stroke", "./Options/Classes/Particles/Move/MoveAttract", "./Options/Classes/Particles/Move/Move", "./Options/Classes/Particles/Move/MoveAngle", "./Options/Classes/Particles/Move/MoveCenter", "./Options/Classes/Particles/Move/MoveGravity", "./Options/Classes/Particles/Move/MoveTrail", "./Options/Classes/Particles/Move/MoveTrailFill", "./Options/Classes/Particles/Move/OutModes", "./Options/Classes/Particles/Move/Path/MovePath", "./Options/Classes/Particles/Move/Spin", "./Options/Classes/Particles/Number/ParticlesNumber", "./Options/Classes/Particles/Number/ParticlesDensity", "./Options/Classes/Particles/Opacity/Opacity", "./Options/Classes/Particles/Opacity/OpacityAnimation", "./Options/Classes/Particles/Shape/Shape", "./Options/Classes/Particles/Size/Size", "./Options/Classes/Particles/Size/SizeAnimation", "./Options/Classes/Particles/ZIndex/ZIndex", "./Options/Classes/Responsive", "./Options/Classes/Theme/Theme", "./Options/Classes/Theme/ThemeDefault", "./Options/Classes/ValueWithRandom", "./Utils/CanvasUtils", "./Utils/ColorUtils", "./Utils/HslColorManager", "./Utils/NumberUtils", "./Utils/OptionsUtils", "./Utils/RgbColorManager", "./Utils/Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.tsParticles = void 0;
+    const engine_1 = require("./engine");
+    const HslColorManager_1 = require("./Utils/HslColorManager");
+    const RgbColorManager_1 = require("./Utils/RgbColorManager");
+    const ColorUtils_1 = require("./Utils/ColorUtils");
+    const rgbColorManager = new RgbColorManager_1.RgbColorManager(), hslColorManager = new HslColorManager_1.HslColorManager();
+    (0, ColorUtils_1.addColorManager)(rgbColorManager);
+    (0, ColorUtils_1.addColorManager)(hslColorManager);
+    const tsParticles = new engine_1.Engine();
+    exports.tsParticles = tsParticles;
+    __exportStar(require("./Core/Utils/Circle"), exports);
+    __exportStar(require("./Core/Utils/Constants"), exports);
+    __exportStar(require("./Core/Utils/ExternalInteractorBase"), exports);
+    __exportStar(require("./Core/Utils/ParticlesInteractorBase"), exports);
+    __exportStar(require("./Core/Utils/Point"), exports);
+    __exportStar(require("./Core/Utils/Range"), exports);
+    __exportStar(require("./Core/Utils/Rectangle"), exports);
+    __exportStar(require("./Core/Utils/Vector"), exports);
+    __exportStar(require("./Core/Utils/Vector3d"), exports);
+    __exportStar(require("./Enums/Directions/MoveDirection"), exports);
+    __exportStar(require("./Enums/Directions/RotateDirection"), exports);
+    __exportStar(require("./Enums/Directions/OutModeDirection"), exports);
+    __exportStar(require("./Enums/Modes/ClickMode"), exports);
+    __exportStar(require("./Enums/Modes/DivMode"), exports);
+    __exportStar(require("./Enums/Modes/HoverMode"), exports);
+    __exportStar(require("./Enums/Modes/CollisionMode"), exports);
+    __exportStar(require("./Enums/Modes/OutMode"), exports);
+    __exportStar(require("./Enums/Modes/SizeMode"), exports);
+    __exportStar(require("./Enums/Modes/ThemeMode"), exports);
+    __exportStar(require("./Enums/Modes/ResponsiveMode"), exports);
+    __exportStar(require("./Enums/Types/AlterType"), exports);
+    __exportStar(require("./Enums/Types/DestroyType"), exports);
+    __exportStar(require("./Enums/Types/GradientType"), exports);
+    __exportStar(require("./Enums/Types/InteractorType"), exports);
+    __exportStar(require("./Enums/Types/ParticleOutType"), exports);
+    __exportStar(require("./Enums/Types/StartValueType"), exports);
+    __exportStar(require("./Enums/Types/DivType"), exports);
+    __exportStar(require("./Enums/Types/EasingType"), exports);
+    __exportStar(require("./Enums/AnimationStatus"), exports);
+    __exportStar(require("./Enums/InteractivityDetect"), exports);
+    __exportStar(require("./Options/Classes/AnimatableColor"), exports);
+    __exportStar(require("./Options/Classes/AnimationOptions"), exports);
+    __exportStar(require("./Options/Classes/Background/Background"), exports);
+    __exportStar(require("./Options/Classes/BackgroundMask/BackgroundMask"), exports);
+    __exportStar(require("./Options/Classes/BackgroundMask/BackgroundMaskCover"), exports);
+    __exportStar(require("./Options/Classes/ColorAnimation"), exports);
+    __exportStar(require("./Options/Classes/FullScreen/FullScreen"), exports);
+    __exportStar(require("./Options/Classes/HslAnimation"), exports);
+    __exportStar(require("./Options/Classes/Interactivity/Events/ClickEvent"), exports);
+    __exportStar(require("./Options/Classes/Interactivity/Events/DivEvent"), exports);
+    __exportStar(require("./Options/Classes/Interactivity/Events/ClickEvent"), exports);
+    __exportStar(require("./Options/Classes/Interactivity/Events/DivEvent"), exports);
+    __exportStar(require("./Options/Classes/Interactivity/Events/Events"), exports);
+    __exportStar(require("./Options/Classes/Interactivity/Events/HoverEvent"), exports);
+    __exportStar(require("./Options/Classes/Interactivity/Events/Parallax"), exports);
+    __exportStar(require("./Options/Classes/Interactivity/Events/ResizeEvent"), exports);
+    __exportStar(require("./Options/Classes/Interactivity/Interactivity"), exports);
+    __exportStar(require("./Options/Classes/Interactivity/Modes/Modes"), exports);
+    __exportStar(require("./Options/Classes/ManualParticle"), exports);
+    __exportStar(require("./Options/Classes/Options"), exports);
+    __exportStar(require("./Options/Classes/OptionsColor"), exports);
+    __exportStar(require("./Options/Classes/Particles/Bounce/ParticlesBounce"), exports);
+    __exportStar(require("./Options/Classes/Particles/Bounce/ParticlesBounceFactor"), exports);
+    __exportStar(require("./Options/Classes/Particles/Collisions/Collisions"), exports);
+    __exportStar(require("./Options/Classes/Particles/Collisions/CollisionsAbsorb"), exports);
+    __exportStar(require("./Options/Classes/Particles/Collisions/CollisionsOverlap"), exports);
+    __exportStar(require("./Options/Classes/Particles/ParticlesOptions"), exports);
+    __exportStar(require("./Options/Classes/Particles/Shadow"), exports);
+    __exportStar(require("./Options/Classes/Particles/Stroke"), exports);
+    __exportStar(require("./Options/Classes/Particles/Move/MoveAttract"), exports);
+    __exportStar(require("./Options/Classes/Particles/Move/Move"), exports);
+    __exportStar(require("./Options/Classes/Particles/Move/MoveAngle"), exports);
+    __exportStar(require("./Options/Classes/Particles/Move/MoveCenter"), exports);
+    __exportStar(require("./Options/Classes/Particles/Move/MoveGravity"), exports);
+    __exportStar(require("./Options/Classes/Particles/Move/MoveTrail"), exports);
+    __exportStar(require("./Options/Classes/Particles/Move/MoveTrailFill"), exports);
+    __exportStar(require("./Options/Classes/Particles/Move/OutModes"), exports);
+    __exportStar(require("./Options/Classes/Particles/Move/Path/MovePath"), exports);
+    __exportStar(require("./Options/Classes/Particles/Move/Spin"), exports);
+    __exportStar(require("./Options/Classes/Particles/Number/ParticlesNumber"), exports);
+    __exportStar(require("./Options/Classes/Particles/Number/ParticlesDensity"), exports);
+    __exportStar(require("./Options/Classes/Particles/Opacity/Opacity"), exports);
+    __exportStar(require("./Options/Classes/Particles/Opacity/OpacityAnimation"), exports);
+    __exportStar(require("./Options/Classes/Particles/Shape/Shape"), exports);
+    __exportStar(require("./Options/Classes/Particles/Size/Size"), exports);
+    __exportStar(require("./Options/Classes/Particles/Size/SizeAnimation"), exports);
+    __exportStar(require("./Options/Classes/Particles/ZIndex/ZIndex"), exports);
+    __exportStar(require("./Options/Classes/Responsive"), exports);
+    __exportStar(require("./Options/Classes/Theme/Theme"), exports);
+    __exportStar(require("./Options/Classes/Theme/ThemeDefault"), exports);
+    __exportStar(require("./Options/Classes/ValueWithRandom"), exports);
+    __exportStar(require("./Utils/CanvasUtils"), exports);
+    __exportStar(require("./Utils/ColorUtils"), exports);
+    __exportStar(require("./Utils/HslColorManager"), exports);
+    __exportStar(require("./Utils/NumberUtils"), exports);
+    __exportStar(require("./Utils/OptionsUtils"), exports);
+    __exportStar(require("./Utils/RgbColorManager"), exports);
+    __exportStar(require("./Utils/Utils"), exports);
+});

package/umd/engine.js

@@ -0,0 +1,189 @@
+(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/Container", "./Utils/EventDispatcher", "./Core/Utils/Plugins", "./Core/Utils/Constants", "./Utils/NumberUtils", "./Utils/Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Engine = void 0;
+    const Container_1 = require("./Core/Container");
+    const EventDispatcher_1 = require("./Utils/EventDispatcher");
+    const Plugins_1 = require("./Core/Utils/Plugins");
+    const Constants_1 = require("./Core/Utils/Constants");
+    const NumberUtils_1 = require("./Utils/NumberUtils");
+    const Utils_1 = require("./Utils/Utils");
+    async function getDataFromUrl(data) {
+        const url = (0, Utils_1.itemFromSingleOrMultiple)(data.url, data.index);
+        if (!url) {
+            return data.fallback;
+        }
+        const response = await fetch(url);
+        if (response.ok) {
+            return response.json();
+        }
+        console.error(`tsParticles - Error ${response.status} while retrieving config file`);
+        return data.fallback;
+    }
+    class Engine {
+        constructor() {
+            this._configs = new Map();
+            this._domArray = [];
+            this._eventDispatcher = new EventDispatcher_1.EventDispatcher();
+            this.plugins = new Plugins_1.Plugins(this);
+        }
+        get configs() {
+            const res = {};
+            for (const [name, config] of this._configs) {
+                res[name] = config;
+            }
+            return res;
+        }
+        addConfig(nameOrConfig, config) {
+            var _a;
+            if (typeof nameOrConfig === "string") {
+                if (config) {
+                    config.name = nameOrConfig;
+                    this._configs.set(nameOrConfig, config);
+                }
+            }
+            else {
+                this._configs.set((_a = nameOrConfig.name) !== null && _a !== void 0 ? _a : "default", nameOrConfig);
+            }
+        }
+        addEventListener(type, listener) {
+            this._eventDispatcher.addEventListener(type, listener);
+        }
+        async addInteractor(name, interactorInitializer) {
+            this.plugins.addInteractor(name, interactorInitializer);
+            await this.refresh();
+        }
+        async addMover(name, moverInitializer) {
+            this.plugins.addParticleMover(name, moverInitializer);
+            await this.refresh();
+        }
+        async addParticleUpdater(name, updaterInitializer) {
+            this.plugins.addParticleUpdater(name, updaterInitializer);
+            await this.refresh();
+        }
+        async addPathGenerator(name, generator) {
+            this.plugins.addPathGenerator(name, generator);
+            await this.refresh();
+        }
+        async addPlugin(plugin) {
+            this.plugins.addPlugin(plugin);
+            await this.refresh();
+        }
+        async addPreset(preset, options, override = false) {
+            this.plugins.addPreset(preset, options, override);
+            await this.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();
+        }
+        dispatchEvent(type, args) {
+            this._eventDispatcher.dispatchEvent(type, args);
+        }
+        dom() {
+            return this._domArray;
+        }
+        domItem(index) {
+            const dom = this.dom(), item = dom[index];
+            if (item && !item.destroyed) {
+                return item;
+            }
+            dom.splice(index, 1);
+        }
+        async load(params) {
+            var _a, _b, _c;
+            const id = (_a = params.id) !== null && _a !== void 0 ? _a : `tsparticles${Math.floor((0, NumberUtils_1.getRandom)() * 10000)}`, { index, url } = params, options = url
+                ? await getDataFromUrl({
+                    fallback: params.options,
+                    index,
+                    url: url,
+                })
+                : params.options;
+            let domContainer = (_b = params.element) !== null && _b !== void 0 ? _b : document.getElementById(id);
+            if (!domContainer) {
+                domContainer = document.createElement("div");
+                domContainer.id = id;
+                (_c = document.querySelector("body")) === null || _c === void 0 ? void 0 : _c.append(domContainer);
+            }
+            const currentOptions = (0, Utils_1.itemFromSingleOrMultiple)(options, index), dom = this.dom(), oldIndex = dom.findIndex((v) => v.id === id);
+            if (oldIndex >= 0) {
+                const old = this.domItem(oldIndex);
+                if (old && !old.destroyed) {
+                    old.destroy();
+                    dom.splice(oldIndex, 1);
+                }
+            }
+            let canvasEl;
+            if (domContainer.tagName.toLowerCase() === "canvas") {
+                canvasEl = domContainer;
+                canvasEl.dataset[Constants_1.generatedAttribute] = "false";
+            }
+            else {
+                const existingCanvases = domContainer.getElementsByTagName("canvas");
+                if (existingCanvases.length) {
+                    canvasEl = existingCanvases[0];
+                    canvasEl.dataset[Constants_1.generatedAttribute] = "false";
+                }
+                else {
+                    canvasEl = document.createElement("canvas");
+                    canvasEl.dataset[Constants_1.generatedAttribute] = "true";
+                    domContainer.appendChild(canvasEl);
+                }
+            }
+            if (!canvasEl.style.width) {
+                canvasEl.style.width = "100%";
+            }
+            if (!canvasEl.style.height) {
+                canvasEl.style.height = "100%";
+            }
+            const newItem = new Container_1.Container(this, id, currentOptions);
+            if (oldIndex >= 0) {
+                dom.splice(oldIndex, 0, newItem);
+            }
+            else {
+                dom.push(newItem);
+            }
+            newItem.canvas.loadCanvas(canvasEl);
+            await newItem.start();
+            return newItem;
+        }
+        async refresh() {
+            for (const instance of this.dom()) {
+                await instance.refresh();
+            }
+        }
+        removeEventListener(type, listener) {
+            this._eventDispatcher.removeEventListener(type, listener);
+        }
+        setOnClickHandler(callback) {
+            const dom = this.dom();
+            if (!dom.length) {
+                throw new Error("Can only set click handlers after calling tsParticles.load()");
+            }
+            for (const domItem of dom) {
+                domItem.addClickHandler(callback);
+            }
+        }
+    }
+    exports.Engine = Engine;
+});