tsparticles 1.42.2 → 1.43.0

package/browser/Utils/NumberUtils.js

@@ -1,4 +1,4 @@
-import { Vector } from "../Core";
+import { Vector } from "../Core/Utils/Vector";
 /**
  * Clamps a number between a minimum and maximum value
  * @param num the source number
@@ -48,8 +48,12 @@ export function setRangeValue(source, value) {
         : setRangeValue(min, max);
 }
 export function getValue(options) {
-    const random = options.random;
-    const { enable, minimumValue } = typeof random === "boolean" ? { enable: random, minimumValue: 0 } : random;
+    const random = options.random, { enable, minimumValue } = typeof random === "boolean"
+        ? {
+            enable: random,
+            minimumValue: 0,
+        }
+        : random;
     return enable ? getRangeValue(setRangeValue(options.value, minimumValue)) : getRangeValue(options.value);
 }
 /**
@@ -58,8 +62,7 @@ export function getValue(options) {
  * @param pointB the second coordinate
  */
 export function getDistances(pointA, pointB) {
-    const dx = pointA.x - pointB.x;
-    const dy = pointA.y - pointB.y;
+    const dx = pointA.x - pointB.x, dy = pointA.y - pointB.y;
     return { dx: dx, dy: dy, distance: Math.sqrt(dx * dx + dy * dy) };
 }
 /**
@@ -126,8 +129,7 @@ export function calcEasing(value, type) {
         case "ease-out-sine" /* easeOutSine */:
             return Math.sin((value * Math.PI) / 2);
         case "ease-out-back" /* easeOutBack */: {
-            const c1 = 1.70158;
-            const c3 = c1 + 1;
+            const c1 = 1.70158, c3 = c1 + 1;
             return 1 + c3 * Math.pow(value - 1, 3) + c1 * Math.pow(value - 1, 2);
         }
         case "ease-out-circ" /* easeOutCirc */:
@@ -136,3 +138,67 @@ export function calcEasing(value, type) {
             return value;
     }
 }
+/**
+ * Gets exact position from percent position based on the given size
+ * @param data the data to use for calculating the position
+ * @returns the exact position
+ */
+export function calcPositionFromSize(data) {
+    var _a, _b;
+    return ((_a = data.position) === null || _a === void 0 ? void 0 : _a.x) !== undefined && ((_b = data.position) === null || _b === void 0 ? void 0 : _b.y) !== undefined
+        ? {
+            x: (data.position.x * data.size.width) / 100,
+            y: (data.position.y * data.size.height) / 100,
+        }
+        : undefined;
+}
+/**
+ * Gets exact position from percent position, or a random one if not specified, based on the given size
+ * @param data the data to use for calculating the position
+ * @returns the exact position
+ */
+export function calcPositionOrRandomFromSize(data) {
+    var _a, _b, _c, _d;
+    return {
+        x: (((_b = (_a = data.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : Math.random() * 100) * data.size.width) / 100,
+        y: (((_d = (_c = data.position) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : Math.random() * 100) * data.size.height) / 100,
+    };
+}
+/**
+ * Gets exact position from percent position, or a random one if not specified, based on the given size
+ * @param data the data to use for calculating the position
+ * @returns the exact position
+ */
+export function calcPositionOrRandomFromSizeRanged(data) {
+    var _a, _b;
+    const position = {
+        x: ((_a = data.position) === null || _a === void 0 ? void 0 : _a.x) !== undefined ? getRangeValue(data.position.x) : undefined,
+        y: ((_b = data.position) === null || _b === void 0 ? void 0 : _b.y) !== undefined ? getRangeValue(data.position.y) : undefined,
+    };
+    return calcPositionOrRandomFromSize({ size: data.size, position });
+}
+/**
+ * Gets exact position from exact position, or a random one if not specified, based on the given size
+ * @param data the data to use for calculating the position
+ * @returns the exact position
+ */
+export function calcExactPositionOrRandomFromSize(data) {
+    var _a, _b, _c, _d;
+    return {
+        x: (_b = (_a = data.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : Math.random() * data.size.width,
+        y: (_d = (_c = data.position) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : Math.random() * data.size.height,
+    };
+}
+/**
+ * Gets exact position from exact position, or a random one if not specified, based on the given size
+ * @param data the data to use for calculating the position
+ * @returns the exact position
+ */
+export function calcExactPositionOrRandomFromSizeRanged(data) {
+    var _a, _b;
+    const position = {
+        x: ((_a = data.position) === null || _a === void 0 ? void 0 : _a.x) !== undefined ? getRangeValue(data.position.x) : undefined,
+        y: ((_b = data.position) === null || _b === void 0 ? void 0 : _b.y) !== undefined ? getRangeValue(data.position.y) : undefined,
+    };
+    return calcExactPositionOrRandomFromSize({ size: data.size, position });
+}

package/browser/Utils/Utils.js

@@ -1,36 +1,56 @@
 import { collisionVelocity, getDistances, getValue } from "./NumberUtils";
-import { Vector } from "../Core";
+import { Vector } from "../Core/Utils/Vector";
+/**
+ * Calculates the bounce on a rectangle side
+ * @hidden
+ * @param pSide particle bounce side
+ * @param pOtherSide particle bounce other side
+ * @param rectSide rectangle bounce side
+ * @param rectOtherSide rectangle bounce other side
+ * @param velocity particle velocity
+ * @param factor bounce factor
+ */
 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;
-        }
+    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;
 }
+/**
+ * Checks if the given selectors matches the element
+ * @hidden
+ * @param element element to check
+ * @param selectors selectors to check
+ */
 function checkSelector(element, selectors) {
-    if (selectors instanceof Array) {
-        for (const selector of selectors) {
-            if (element.matches(selector)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    else {
+    if (!(selectors instanceof Array)) {
         return element.matches(selectors);
     }
+    for (const selector of selectors) {
+        if (element.matches(selector)) {
+            return true;
+        }
+    }
+    return false;
 }
-/* ---------- global functions - vendors ------------ */
+/**
+ * Checks if the script is executed server side
+ */
 export function isSsr() {
     return typeof window === "undefined" || !window || typeof window.document === "undefined" || !window.document;
 }
+/**
+ * Calls the requestAnimationFrame function or a polyfill
+ */
 export function animate() {
     return isSsr()
         ? (callback) => setTimeout(callback)
@@ -41,6 +61,9 @@ export function animate() {
             window.msRequestAnimationFrame ||
             window.setTimeout)(callback);
 }
+/**
+ * Cancels the requestAnimationFrame function or a polyfill
+ */
 export function cancelAnimation() {
     return isSsr()
         ? (handle) => clearTimeout(handle)
@@ -52,13 +75,18 @@ export function cancelAnimation() {
             window.clearTimeout)(handle);
 }
 /**
- * Check if a value is equal to the destination, if same type, or is in the provided array
+ * Checks if a value is equal to the destination, if same type, or is in the provided array
  * @param value the value to check
  * @param array the data array or single value
+ * @returns true if the value is equal to the destination, if same type, or is in the provided array
  */
 export function isInArray(value, array) {
     return value === array || (array instanceof Array && array.indexOf(value) > -1);
 }
+/**
+ * Loads a font for the canvas
+ * @param character character shape options
+ */
 export async function loadFont(character) {
     var _a, _b;
     try {
@@ -68,16 +96,41 @@ export async function loadFont(character) {
         // ignores any error
     }
 }
+/**
+ * Returns a random array index
+ * @param array the array to get the index from
+ * @returns a random array index
+ */
 export function arrayRandomIndex(array) {
     return Math.floor(Math.random() * array.length);
 }
+/**
+ * Returns a random object from the given array
+ * @param array the array to get the object from
+ * @param index the index to get the object from
+ * @param useIndex if true, the index will be used instead of a random index
+ */
 export function itemFromArray(array, index, useIndex = true) {
     const fixedIndex = index !== undefined && useIndex ? index % array.length : arrayRandomIndex(array);
     return array[fixedIndex];
 }
+/**
+ * Checks if the given point is inside the given rectangle
+ * @param point the point to check
+ * @param size the rectangle size
+ * @param radius the point radius
+ * @param direction the point direction
+ * @returns true if the point is inside the rectangle
+ */
 export function isPointInside(point, size, radius, direction) {
     return areBoundsInside(calculateBounds(point, radius !== null && radius !== void 0 ? radius : 0), size, direction);
 }
+/**
+ * Checks if the given shape bounds are inside the given rectangle
+ * @param bounds the shape bounds to check
+ * @param size the rectangle size
+ * @param direction the shape direction
+ */
 export function areBoundsInside(bounds, size, direction) {
     let inside = true;
     if (!direction || direction === "bottom" /* bottom */) {
@@ -94,6 +147,12 @@ export function areBoundsInside(bounds, size, direction) {
     }
     return inside;
 }
+/**
+ * Calculates the bounds of the given point
+ * @param point the point to calculate the bounds from
+ * @param radius the point radius
+ * @returns the bounds of the given point
+ */
 export function calculateBounds(point, radius) {
     return {
         bottom: point.y + radius,
@@ -102,6 +161,12 @@ export function calculateBounds(point, radius) {
         top: point.y - radius,
     };
 }
+/**
+ * Merges the whole source objects into the destination object
+ * @param destination the destination object
+ * @param sources the source objects
+ * @returns the merged destination object
+ */
 export function deepExtend(destination, ...sources) {
     for (const source of sources) {
         if (source === undefined || source === null) {
@@ -122,10 +187,7 @@ export function deepExtend(destination, ...sources) {
             if (key === "__proto__") {
                 continue;
             }
-            const sourceDict = source;
-            const value = sourceDict[key];
-            const isObject = typeof value === "object";
-            const destDict = destination;
+            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))
@@ -134,27 +196,42 @@ export function deepExtend(destination, ...sources) {
     }
     return destination;
 }
+/**
+ * Checks if the given div mode is enabled in the given div elements
+ * @param mode the div mode to check
+ * @param divs the div elements to check
+ * @returns true if the div mode is enabled
+ */
 export function isDivModeEnabled(mode, divs) {
     return divs instanceof Array ? !!divs.find((t) => t.enable && isInArray(mode, t.mode)) : isInArray(mode, divs.mode);
 }
+/**
+ * Execute the given callback if div mode in the given div elements is enabled
+ * @param mode the div mode to check
+ * @param divs the div elements to check
+ * @param callback the callback to execute
+ */
 export function divModeExecute(mode, divs, callback) {
     if (divs instanceof Array) {
         for (const div of divs) {
-            const divMode = div.mode;
-            const divEnabled = div.enable;
+            const divMode = div.mode, divEnabled = div.enable;
             if (divEnabled && isInArray(mode, divMode)) {
                 singleDivModeExecute(div, callback);
             }
         }
     }
     else {
-        const divMode = divs.mode;
-        const divEnabled = divs.enable;
+        const divMode = divs.mode, divEnabled = divs.enable;
         if (divEnabled && isInArray(mode, divMode)) {
             singleDivModeExecute(divs, callback);
         }
     }
 }
+/**
+ * Execute the given callback for the given div event
+ * @param div the div event to execute the callback for
+ * @param callback the callback to execute
+ */
 export function singleDivModeExecute(div, callback) {
     const selectors = div.selectors;
     if (selectors instanceof Array) {
@@ -166,6 +243,12 @@ export function singleDivModeExecute(div, callback) {
         callback(selectors, div);
     }
 }
+/**
+ * Checks if the given element targets any of the div modes
+ * @param divs the div elements to check
+ * @param element the element to check
+ * @returns true if the element targets any of the div modes
+ */
 export function divMode(divs, element) {
     if (!element || !divs) {
         return;
@@ -177,6 +260,11 @@ export function divMode(divs, element) {
         return divs;
     }
 }
+/**
+ * Returns circle bounce data for the given particle
+ * @param p the particle to get the circle bounds data for
+ * @returns the circle bounce data for the given particle
+ */
 export function circleBounceDataFromParticle(p) {
     return {
         position: p.getPosition(),
@@ -186,37 +274,30 @@ export function circleBounceDataFromParticle(p) {
         factor: Vector.create(getValue(p.options.bounce.horizontal), getValue(p.options.bounce.vertical)),
     };
 }
+/**
+ * Executes the circle bounce between two particles
+ * @param p1 the first particle
+ * @param p2 the second particle
+ */
 export 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 } = getDistances(pos2, pos1);
+    const { x: xVelocityDiff, y: yVelocityDiff } = p1.velocity.sub(p2.velocity), [pos1, pos2] = [p1.position, p2.position], { dx: xDist, dy: yDist } = getDistances(pos2, pos1);
     // Prevent accidental overlap of particles
-    if (xVelocityDiff * xDist + yVelocityDiff * yDist >= 0) {
-        // Grab angle between the two colliding particles
-        const angle = -Math.atan2(yDist, xDist);
-        // Store mass in var for better readability in collision equation
-        const m1 = p1.mass;
-        const m2 = p2.mass;
-        // Velocity before equation
-        const u1 = p1.velocity.rotate(angle);
-        const u2 = p2.velocity.rotate(angle);
-        // Velocity after 1d collision equation
-        const v1 = collisionVelocity(u1, u2, m1, m2);
-        const v2 = collisionVelocity(u2, u1, m1, m2);
-        // Final velocity after rotating axis back to original location
-        const vFinal1 = v1.rotate(-angle);
-        const vFinal2 = v2.rotate(-angle);
-        // Swap particle velocities for realistic bounce effect
-        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;
+    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 = collisionVelocity(u1, u2, m1, m2), v2 = 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;
 }
+/**
+ * Executes the bounce between a particle and div bounds
+ * @param particle the particle to bounce
+ * @param divBounds the div bounds to bounce
+ */
 export function rectBounce(particle, divBounds) {
-    const pPos = particle.getPosition();
-    const size = particle.getRadius();
-    const bounds = calculateBounds(pPos, size);
+    const pPos = particle.getPosition(), size = particle.getRadius(), bounds = calculateBounds(pPos, size);
     const resH = rectSideBounce({
         min: bounds.left,
         max: bounds.right,

package/browser/engine.js

@@ -10,7 +10,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _Engine_initialized, _Engine_loader;
-import { Loader, Plugins } from "./Core";
+import { Loader } from "./Core/Loader";
+import { Plugins } from "./Core/Utils/Plugins";
 /**
  * Engine class for creating the singleton on window.
  * It's a singleton proxy to the Loader class for initializing [[Container]] instances,
@@ -18,8 +19,18 @@ import { Loader, Plugins } from "./Core";
  * @category Engine
  */
 export class Engine {
+    /**
+     * Engine constructor, initializes plugins, loader and the containers array
+     */
     constructor() {
+        /**
+         * Checks if the engine instance is initialized
+         */
         _Engine_initialized.set(this, void 0);
+        /**
+         * Contains the [[Loader]] engine instance
+         * @private
+         */
         _Engine_loader.set(this, void 0);
         __classPrivateFieldSet(this, _Engine_initialized, false, "f");
         this.domArray = [];
@@ -174,6 +185,10 @@ export class Engine {
         this.plugins.addInteractor(name, interactorInitializer);
         await this.refresh();
     }
+    async addMover(name, moverInitializer) {
+        this.plugins.addParticleMover(name, moverInitializer);
+        await this.refresh();
+    }
     /**
      *
      * @param name

package/browser/full.js

@@ -5,13 +5,19 @@ import { loadPolygonMaskPlugin } from "./Plugins/PolygonMask";
 import { loadRollUpdater } from "./Updaters/Roll";
 import { loadSlim } from "./slim";
 import { loadTiltUpdater } from "./Updaters/Tilt";
+import { loadTwinkleUpdater } from "./Updaters/Twinkle";
 import { loadWobbleUpdater } from "./Updaters/Wobble";
+/**
+ * Loads the full tsParticles instance, containing all default tsParticles plugins
+ * @param engine the engine used to load all plugins
+ */
 export async function loadFull(engine) {
     await loadSlim(engine);
-    await loadExternalTrailInteraction(engine);
     await loadRollUpdater(engine);
     await loadTiltUpdater(engine);
+    await loadTwinkleUpdater(engine);
     await loadWobbleUpdater(engine);
+    await loadExternalTrailInteraction(engine);
     await loadAbsorbersPlugin(engine);
     await loadEmittersPlugin(engine);
     await loadPolygonMaskPlugin(engine);

package/browser/index.engine.js

@@ -1,12 +1,110 @@
 import { Engine } from "./engine";
 import { initPjs } from "./pjs";
-/* ---------- tsParticles functions - start ------------ */
+/**
+ * The exposed tsParticles instance
+ */
 const tsParticles = new Engine();
 tsParticles.init();
-const { particlesJS, pJSDom } = initPjs(tsParticles);
-export * from "./Core";
-export * from "./Enums";
+const { 
+/**
+ * The particles.js compatibility instance
+ */
+particlesJS, 
+/**
+ * The particles.js compatibility dom array
+ */
+pJSDom, } = initPjs(tsParticles);
+export * from "./Core/Interfaces/Colors";
+export * from "./Core/Interfaces/Gradients";
+export * from "./Core/Interfaces/IBounds";
+export * from "./Core/Interfaces/IBubbleParticleData";
+export * from "./Core/Interfaces/ICircleBouncer";
+export * from "./Core/Interfaces/IContainerInteractivity";
+export * from "./Core/Interfaces/IContainerPlugin";
+export * from "./Core/Interfaces/ICoordinates";
+export * from "./Core/Interfaces/IDelta";
+export * from "./Core/Interfaces/IDimension";
+export * from "./Core/Interfaces/IDistance";
+export * from "./Core/Interfaces/IExternalInteractor";
+export * from "./Core/Interfaces/IInteractor";
+export * from "./Core/Interfaces/IMouseData";
+export * from "./Core/Interfaces/IMovePathGenerator";
+export * from "./Core/Interfaces/IParticle";
+export * from "./Core/Interfaces/IParticleColorStyle";
+export * from "./Core/Interfaces/IParticleGravity";
+export * from "./Core/Interfaces/IParticleHslAnimation";
+export * from "./Core/Interfaces/IParticlesInteractor";
+export * from "./Core/Interfaces/IParticleLife";
+export * from "./Core/Interfaces/IParticleLoops";
+export * from "./Core/Interfaces/IParticleRetinaProps";
+export * from "./Core/Interfaces/IParticleRoll";
+export * from "./Core/Interfaces/IParticleSpin";
+export * from "./Core/Interfaces/IParticleUpdater";
+export * from "./Core/Interfaces/IParticleValueAnimation";
+export * from "./Core/Interfaces/IParticleWobble";
+export * from "./Core/Interfaces/IParticlesMover";
+export * from "./Core/Interfaces/IPlugin";
+export * from "./Core/Interfaces/IRangeValue";
+export * from "./Core/Interfaces/IRectSideResult";
+export * from "./Core/Interfaces/IShapeDrawer";
+export * from "./Core/Interfaces/IShapeValues";
+export * from "./Core/Utils/Circle";
+export * from "./Core/Utils/CircleWarp";
+export * from "./Core/Utils/Constants";
+export * from "./Core/Utils/EventListeners";
+export * from "./Core/Utils/ExternalInteractorBase";
+export * from "./Core/Utils/FrameManager";
+export * from "./Core/Utils/InteractionManager";
+export * from "./Core/Utils/ParticlesInteractorBase";
+export * from "./Core/Utils/Plugins";
+export * from "./Core/Utils/Point";
+export * from "./Core/Utils/QuadTree";
+export * from "./Core/Utils/Range";
+export * from "./Core/Utils/Rectangle";
+export * from "./Core/Utils/Vector";
+export * from "./Core/Utils/Vector3d";
+export * from "./Core/Canvas";
+export * from "./Core/Container";
+export * from "./Core/Loader";
+export * from "./Core/Particle";
+export * from "./Core/Particles";
+export * from "./Core/Retina";
+export * from "./Enums/Directions/MoveDirection";
+export * from "./Enums/Directions/RotateDirection";
+export * from "./Enums/Directions/OutModeDirection";
+export * from "./Enums/Directions/TiltDirection";
+export * from "./Enums/Modes/ClickMode";
+export * from "./Enums/Modes/DestroyMode";
+export * from "./Enums/Modes/DivMode";
+export * from "./Enums/Modes/HoverMode";
+export * from "./Enums/Modes/CollisionMode";
+export * from "./Enums/Modes/OutMode";
+export * from "./Enums/Modes/RollMode";
+export * from "./Enums/Modes/SizeMode";
+export * from "./Enums/Modes/ThemeMode";
+export * from "./Enums/Modes/ResponsiveMode";
+export * from "./Enums/Types/AlterType";
+export * from "./Enums/Types/DestroyType";
+export * from "./Enums/Types/GradientType";
+export * from "./Enums/Types/InteractorType";
+export * from "./Enums/Types/ShapeType";
+export * from "./Enums/Types/StartValueType";
+export * from "./Enums/Types/DivType";
+export * from "./Enums/Types/EasingType";
+export * from "./Enums/AnimationStatus";
+export * from "./Enums/InteractivityDetect";
 export { Engine, Engine as Main };
-export * from "./Utils";
-export * from "./Types";
+export * from "./Options/Classes/Options";
+export * from "./Options/Classes/OptionsColor";
+export * from "./Options/Interfaces/IOptionLoader";
+export * from "./Types/RangeValue";
+export * from "./Types/RecursivePartial";
+export * from "./Types/ShapeData";
+export * from "./Types/ShapeDrawerFunctions";
+export * from "./Types/SingleOrMultiple";
+export * from "./Types/PathOptions";
+export * from "./Utils/CanvasUtils";
+export * from "./Utils/ColorUtils";
+export * from "./Utils/NumberUtils";
+export * from "./Utils/Utils";
 export { tsParticles, particlesJS, pJSDom };