tsparticles 1.36.0 → 1.37.3

package/tsparticles.js

@@ -3,8 +3,8 @@
     var a = factory();
     for (var i in a) (typeof exports === "object" ? exports : root)[i] = a[i];
   }
-})(this, (function() {
-  return (() => {
+})(window, (function() {
+  return function() {
     "use strict";
     var __webpack_modules__ = {};
     var __webpack_module_cache__ = {};
@@ -20,8 +20,54 @@
       return module.exports;
     }
     __webpack_require__.m = __webpack_modules__;
-    (() => {
-      var getProto = Object.getPrototypeOf ? obj => Object.getPrototypeOf(obj) : obj => obj.__proto__;
+    !function() {
+      var deferred = [];
+      __webpack_require__.O = function(result, chunkIds, fn, priority) {
+        if (chunkIds) {
+          priority = priority || 0;
+          for (var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
+          deferred[i] = [ chunkIds, fn, priority ];
+          return;
+        }
+        var notFulfilled = Infinity;
+        for (var i = 0; i < deferred.length; i++) {
+          var chunkIds = deferred[i][0];
+          var fn = deferred[i][1];
+          var priority = deferred[i][2];
+          var fulfilled = true;
+          for (var j = 0; j < chunkIds.length; j++) {
+            if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((function(key) {
+              return __webpack_require__.O[key](chunkIds[j]);
+            }))) {
+              chunkIds.splice(j--, 1);
+            } else {
+              fulfilled = false;
+              if (priority < notFulfilled) notFulfilled = priority;
+            }
+          }
+          if (fulfilled) {
+            deferred.splice(i--, 1);
+            var r = fn();
+            if (r !== undefined) result = r;
+          }
+        }
+        return result;
+      };
+    }();
+    !function() {
+      __webpack_require__.F = {};
+      __webpack_require__.E = function(chunkId) {
+        Object.keys(__webpack_require__.F).map((function(key) {
+          __webpack_require__.F[key](chunkId);
+        }));
+      };
+    }();
+    !function() {
+      var getProto = Object.getPrototypeOf ? function(obj) {
+        return Object.getPrototypeOf(obj);
+      } : function(obj) {
+        return obj.__proto__;
+      };
       var leafPrototypes;
       __webpack_require__.t = function(value, mode) {
         if (mode & 1) value = this(value);
@@ -35,15 +81,21 @@
         var def = {};
         leafPrototypes = leafPrototypes || [ null, getProto({}), getProto([]), getProto(getProto) ];
         for (var current = mode & 2 && value; typeof current == "object" && !~leafPrototypes.indexOf(current); current = getProto(current)) {
-          Object.getOwnPropertyNames(current).forEach((key => def[key] = () => value[key]));
+          Object.getOwnPropertyNames(current).forEach((function(key) {
+            def[key] = function() {
+              return value[key];
+            };
+          }));
         }
-        def["default"] = () => value;
+        def["default"] = function() {
+          return value;
+        };
         __webpack_require__.d(ns, def);
         return ns;
       };
-    })();
-    (() => {
-      __webpack_require__.d = (exports, definition) => {
+    }();
+    !function() {
+      __webpack_require__.d = function(exports, definition) {
         for (var key in definition) {
           if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
             Object.defineProperty(exports, key, {
@@ -53,18 +105,22 @@
           }
         }
       };
-    })();
-    (() => {
+    }();
+    !function() {
       __webpack_require__.f = {};
-      __webpack_require__.e = chunkId => Promise.all(Object.keys(__webpack_require__.f).reduce(((promises, key) => {
-        __webpack_require__.f[key](chunkId, promises);
-        return promises;
-      }), []));
-    })();
-    (() => {
-      __webpack_require__.u = chunkId => "" + "tsparticles.pathseg" + ".js";
-    })();
-    (() => {
+      __webpack_require__.e = function(chunkId) {
+        return Promise.all(Object.keys(__webpack_require__.f).reduce((function(promises, key) {
+          __webpack_require__.f[key](chunkId, promises);
+          return promises;
+        }), []));
+      };
+    }();
+    !function() {
+      __webpack_require__.u = function(chunkId) {
+        return "" + "tsparticles.pathseg" + ".js";
+      };
+    }();
+    !function() {
       __webpack_require__.g = function() {
         if (typeof globalThis === "object") return globalThis;
         try {
@@ -73,14 +129,16 @@
           if (typeof window === "object") return window;
         }
       }();
-    })();
-    (() => {
-      __webpack_require__.o = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
-    })();
-    (() => {
+    }();
+    !function() {
+      __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+      };
+    }();
+    !function() {
       var inProgress = {};
       var dataWebpackPrefix = "tsparticles:";
-      __webpack_require__.l = (url, done, key, chunkId) => {
+      __webpack_require__.l = function(url, done, key, chunkId) {
         if (inProgress[url]) {
           inProgress[url].push(done);
           return;
@@ -108,13 +166,15 @@
           script.src = url;
         }
         inProgress[url] = [ done ];
-        var onScriptComplete = (prev, event) => {
+        var onScriptComplete = function(prev, event) {
           script.onerror = script.onload = null;
           clearTimeout(timeout);
           var doneFns = inProgress[url];
           delete inProgress[url];
           script.parentNode && script.parentNode.removeChild(script);
-          doneFns && doneFns.forEach((fn => fn(event)));
+          doneFns && doneFns.forEach((function(fn) {
+            return fn(event);
+          }));
           if (prev) return prev(event);
         };
         var timeout = setTimeout(onScriptComplete.bind(null, undefined, {
@@ -125,9 +185,9 @@
         script.onload = onScriptComplete.bind(null, script.onload);
         needAttach && document.head.appendChild(script);
       };
-    })();
-    (() => {
-      __webpack_require__.r = exports => {
+    }();
+    !function() {
+      __webpack_require__.r = function(exports) {
         if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
           Object.defineProperty(exports, Symbol.toStringTag, {
             value: "Module"
@@ -137,8 +197,8 @@
           value: true
         });
       };
-    })();
-    (() => {
+    }();
+    !function() {
       var scriptUrl;
       if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
       var document = __webpack_require__.g.document;
@@ -152,24 +212,26 @@
       if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
       scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
       __webpack_require__.p = scriptUrl;
-    })();
-    (() => {
+    }();
+    !function() {
       var installedChunks = {
         649: 0,
         155: 0
       };
-      __webpack_require__.f.j = (chunkId, promises) => {
+      __webpack_require__.f.j = function(chunkId, promises) {
         var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
         if (installedChunkData !== 0) {
           if (installedChunkData) {
             promises.push(installedChunkData[2]);
           } else {
             if (true) {
-              var promise = new Promise(((resolve, reject) => installedChunkData = installedChunks[chunkId] = [ resolve, reject ]));
+              var promise = new Promise((function(resolve, reject) {
+                installedChunkData = installedChunks[chunkId] = [ resolve, reject ];
+              }));
               promises.push(installedChunkData[2] = promise);
               var url = __webpack_require__.p + __webpack_require__.u(chunkId);
               var error = new Error;
-              var loadingEnded = event => {
+              var loadingEnded = function(event) {
                 if (__webpack_require__.o(installedChunks, chunkId)) {
                   installedChunkData = installedChunks[chunkId];
                   if (installedChunkData !== 0) installedChunks[chunkId] = undefined;
@@ -189,10 +251,30 @@
           }
         }
       };
-      var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
-        var [chunkIds, moreModules, runtime] = data;
+      __webpack_require__.F.j = function(chunkId) {
+        if ((!__webpack_require__.o(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && true) {
+          installedChunks[chunkId] = null;
+          var link = document.createElement("link");
+          if (__webpack_require__.nc) {
+            link.setAttribute("nonce", __webpack_require__.nc);
+          }
+          link.rel = "prefetch";
+          link.as = "script";
+          link.href = __webpack_require__.p + __webpack_require__.u(chunkId);
+          document.head.appendChild(link);
+        }
+      };
+      __webpack_require__.O.j = function(chunkId) {
+        return installedChunks[chunkId] === 0;
+      };
+      var webpackJsonpCallback = function(parentChunkLoadingFunction, data) {
+        var chunkIds = data[0];
+        var moreModules = data[1];
+        var runtime = data[2];
         var moduleId, chunkId, i = 0;
-        if (chunkIds.some((id => installedChunks[id] !== 0))) {
+        if (chunkIds.some((function(id) {
+          return installedChunks[id] !== 0;
+        }))) {
           for (moduleId in moreModules) {
             if (__webpack_require__.o(moreModules, moduleId)) {
               __webpack_require__.m[moduleId] = moreModules[moduleId];
@@ -208,128 +290,365 @@
           }
           installedChunks[chunkIds[i]] = 0;
         }
+        return __webpack_require__.O(result);
       };
-      var chunkLoadingGlobal = this["webpackChunktsparticles"] = this["webpackChunktsparticles"] || [];
+      var chunkLoadingGlobal = window["webpackChunktsparticles"] = window["webpackChunktsparticles"] || [];
       chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
       chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
-    })();
+    }();
+    !function() {
+      __webpack_require__.O(0, [ 649 ], (function() {
+        __webpack_require__.E(917);
+      }), 5);
+    }();
     var __webpack_exports__ = {};
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
-      AbsorberClickMode: () => AbsorberClickMode,
-      AlterType: () => AlterType,
-      AnimationStatus: () => AnimationStatus,
-      Circle: () => Circle,
-      CircleWarp: () => CircleWarp,
-      ClickMode: () => ClickMode,
-      CollisionMode: () => CollisionMode,
-      Constants: () => Constants,
-      Container: () => Container,
-      DestroyMode: () => DestroyMode,
-      DestroyType: () => DestroyType,
-      DivMode: () => DivMode,
-      DivType: () => DivType,
-      EasingType: () => EasingType,
-      EmitterClickMode: () => EmitterClickMode,
-      EmitterShapeType: () => EmitterShapeType,
-      ExternalInteractorBase: () => ExternalInteractorBase,
-      GradientType: () => GradientType,
-      HoverMode: () => HoverMode,
-      InlineArrangement: () => InlineArrangement,
-      InteractivityDetect: () => InteractivityDetect,
-      InteractorType: () => InteractorType,
-      Main: () => Main,
-      MoveDirection: () => MoveDirection,
-      MoveType: () => MoveType,
-      OrbitType: () => OrbitType,
-      OutMode: () => OutMode,
-      OutModeDirection: () => OutModeDirection,
-      Particle: () => Particle,
-      ParticlesInteractorBase: () => ParticlesInteractorBase,
-      Point: () => Point,
-      Rectangle: () => Rectangle,
-      RollMode: () => RollMode,
-      RotateDirection: () => RotateDirection,
-      ShapeType: () => ShapeType,
-      SizeMode: () => SizeMode,
-      StartValueType: () => StartValueType,
-      ThemeMode: () => ThemeMode,
-      TiltDirection: () => TiltDirection,
-      Type: () => Type,
-      Vector: () => Vector,
-      alterHsl: () => alterHsl,
-      animate: () => animate,
-      areBoundsInside: () => areBoundsInside,
-      arrayRandomIndex: () => arrayRandomIndex,
-      calcEasing: () => calcEasing,
-      calculateBounds: () => calculateBounds,
-      cancelAnimation: () => cancelAnimation,
-      circleBounce: () => circleBounce,
-      circleBounceDataFromParticle: () => circleBounceDataFromParticle,
-      clamp: () => clamp,
-      clear: () => clear,
-      collisionVelocity: () => collisionVelocity,
-      colorMix: () => colorMix,
-      colorToHsl: () => colorToHsl,
-      colorToRgb: () => colorToRgb,
-      deepExtend: () => deepExtend,
-      divMode: () => divMode,
-      divModeExecute: () => divModeExecute,
-      drawConnectLine: () => drawConnectLine,
-      drawEllipse: () => drawEllipse,
-      drawGrabLine: () => drawGrabLine,
-      drawLinkLine: () => drawLinkLine,
-      drawLinkTriangle: () => drawLinkTriangle,
-      drawParticle: () => drawParticle,
-      drawParticlePlugin: () => drawParticlePlugin,
-      drawPlugin: () => drawPlugin,
-      drawShape: () => drawShape,
-      drawShapeAfterEffect: () => drawShapeAfterEffect,
-      getDistance: () => getDistance,
-      getDistances: () => getDistances,
-      getHslAnimationFromHsl: () => getHslAnimationFromHsl,
-      getHslFromAnimation: () => getHslFromAnimation,
-      getLinkColor: () => getLinkColor,
-      getLinkRandomColor: () => getLinkRandomColor,
-      getParticleBaseVelocity: () => getParticleBaseVelocity,
-      getParticleDirectionAngle: () => getParticleDirectionAngle,
-      getRandomRgbColor: () => getRandomRgbColor,
-      getRangeMax: () => getRangeMax,
-      getRangeMin: () => getRangeMin,
-      getRangeValue: () => getRangeValue,
-      getStyleFromHsl: () => getStyleFromHsl,
-      getStyleFromHsv: () => getStyleFromHsv,
-      getStyleFromRgb: () => getStyleFromRgb,
-      getValue: () => getValue,
-      gradient: () => gradient,
-      hslToHsv: () => hslToHsv,
-      hslToRgb: () => hslToRgb,
-      hslaToHsva: () => hslaToHsva,
-      hslaToRgba: () => hslaToRgba,
-      hsvToHsl: () => hsvToHsl,
-      hsvToRgb: () => hsvToRgb,
-      hsvaToHsla: () => hsvaToHsla,
-      hsvaToRgba: () => hsvaToRgba,
-      isDivModeEnabled: () => isDivModeEnabled,
-      isInArray: () => isInArray,
-      isPointInside: () => isPointInside,
-      isSsr: () => isSsr,
-      itemFromArray: () => itemFromArray,
-      loadFont: () => loadFont,
-      mix: () => mix,
-      pJSDom: () => pJSDom,
-      paintBase: () => paintBase,
-      particlesJS: () => particlesJS,
-      randomInRange: () => randomInRange,
-      rectBounce: () => rectBounce,
-      rgbToHsl: () => rgbToHsl,
-      rgbToHsv: () => rgbToHsv,
-      rgbaToHsva: () => rgbaToHsva,
-      setRangeValue: () => setRangeValue,
-      singleDivModeExecute: () => singleDivModeExecute,
-      stringToAlpha: () => stringToAlpha,
-      stringToRgb: () => stringToRgb,
-      tsParticles: () => tsParticles
+      AbsorberClickMode: function() {
+        return AbsorberClickMode;
+      },
+      AlterType: function() {
+        return AlterType;
+      },
+      AnimationStatus: function() {
+        return AnimationStatus;
+      },
+      Circle: function() {
+        return Circle;
+      },
+      CircleWarp: function() {
+        return CircleWarp;
+      },
+      ClickMode: function() {
+        return ClickMode;
+      },
+      CollisionMode: function() {
+        return CollisionMode;
+      },
+      Constants: function() {
+        return Constants;
+      },
+      Container: function() {
+        return Container;
+      },
+      DestroyMode: function() {
+        return DestroyMode;
+      },
+      DestroyType: function() {
+        return DestroyType;
+      },
+      DivMode: function() {
+        return DivMode;
+      },
+      DivType: function() {
+        return DivType;
+      },
+      EasingType: function() {
+        return EasingType;
+      },
+      EmitterClickMode: function() {
+        return EmitterClickMode;
+      },
+      EmitterShapeType: function() {
+        return EmitterShapeType;
+      },
+      ExternalInteractorBase: function() {
+        return ExternalInteractorBase;
+      },
+      GradientType: function() {
+        return GradientType;
+      },
+      HoverMode: function() {
+        return HoverMode;
+      },
+      InlineArrangement: function() {
+        return InlineArrangement;
+      },
+      InteractivityDetect: function() {
+        return InteractivityDetect;
+      },
+      InteractorType: function() {
+        return InteractorType;
+      },
+      Main: function() {
+        return Main;
+      },
+      MoveDirection: function() {
+        return MoveDirection;
+      },
+      MoveType: function() {
+        return MoveType;
+      },
+      OrbitType: function() {
+        return OrbitType;
+      },
+      OutMode: function() {
+        return OutMode;
+      },
+      OutModeDirection: function() {
+        return OutModeDirection;
+      },
+      Particle: function() {
+        return Particle;
+      },
+      ParticlesInteractorBase: function() {
+        return ParticlesInteractorBase;
+      },
+      Point: function() {
+        return Point;
+      },
+      Rectangle: function() {
+        return Rectangle;
+      },
+      ResponsiveMode: function() {
+        return ResponsiveMode;
+      },
+      RollMode: function() {
+        return RollMode;
+      },
+      RotateDirection: function() {
+        return RotateDirection;
+      },
+      ShapeType: function() {
+        return ShapeType;
+      },
+      SizeMode: function() {
+        return SizeMode;
+      },
+      StartValueType: function() {
+        return StartValueType;
+      },
+      ThemeMode: function() {
+        return ThemeMode;
+      },
+      TiltDirection: function() {
+        return TiltDirection;
+      },
+      Type: function() {
+        return Type;
+      },
+      Vector: function() {
+        return Vector;
+      },
+      alterHsl: function() {
+        return alterHsl;
+      },
+      animate: function() {
+        return animate;
+      },
+      areBoundsInside: function() {
+        return areBoundsInside;
+      },
+      arrayRandomIndex: function() {
+        return arrayRandomIndex;
+      },
+      calcEasing: function() {
+        return calcEasing;
+      },
+      calculateBounds: function() {
+        return calculateBounds;
+      },
+      cancelAnimation: function() {
+        return cancelAnimation;
+      },
+      circleBounce: function() {
+        return circleBounce;
+      },
+      circleBounceDataFromParticle: function() {
+        return circleBounceDataFromParticle;
+      },
+      clamp: function() {
+        return clamp;
+      },
+      clear: function() {
+        return clear;
+      },
+      collisionVelocity: function() {
+        return collisionVelocity;
+      },
+      colorMix: function() {
+        return colorMix;
+      },
+      colorToHsl: function() {
+        return colorToHsl;
+      },
+      colorToRgb: function() {
+        return colorToRgb;
+      },
+      deepExtend: function() {
+        return deepExtend;
+      },
+      divMode: function() {
+        return divMode;
+      },
+      divModeExecute: function() {
+        return divModeExecute;
+      },
+      drawConnectLine: function() {
+        return drawConnectLine;
+      },
+      drawEllipse: function() {
+        return drawEllipse;
+      },
+      drawGrabLine: function() {
+        return drawGrabLine;
+      },
+      drawLinkLine: function() {
+        return drawLinkLine;
+      },
+      drawLinkTriangle: function() {
+        return drawLinkTriangle;
+      },
+      drawParticle: function() {
+        return drawParticle;
+      },
+      drawParticlePlugin: function() {
+        return drawParticlePlugin;
+      },
+      drawPlugin: function() {
+        return drawPlugin;
+      },
+      drawShape: function() {
+        return drawShape;
+      },
+      drawShapeAfterEffect: function() {
+        return drawShapeAfterEffect;
+      },
+      getDistance: function() {
+        return getDistance;
+      },
+      getDistances: function() {
+        return getDistances;
+      },
+      getHslAnimationFromHsl: function() {
+        return getHslAnimationFromHsl;
+      },
+      getHslFromAnimation: function() {
+        return getHslFromAnimation;
+      },
+      getLinkColor: function() {
+        return getLinkColor;
+      },
+      getLinkRandomColor: function() {
+        return getLinkRandomColor;
+      },
+      getParticleBaseVelocity: function() {
+        return getParticleBaseVelocity;
+      },
+      getParticleDirectionAngle: function() {
+        return getParticleDirectionAngle;
+      },
+      getRandomRgbColor: function() {
+        return getRandomRgbColor;
+      },
+      getRangeMax: function() {
+        return getRangeMax;
+      },
+      getRangeMin: function() {
+        return getRangeMin;
+      },
+      getRangeValue: function() {
+        return getRangeValue;
+      },
+      getStyleFromHsl: function() {
+        return getStyleFromHsl;
+      },
+      getStyleFromHsv: function() {
+        return getStyleFromHsv;
+      },
+      getStyleFromRgb: function() {
+        return getStyleFromRgb;
+      },
+      getValue: function() {
+        return getValue;
+      },
+      gradient: function() {
+        return gradient;
+      },
+      hslToHsv: function() {
+        return hslToHsv;
+      },
+      hslToRgb: function() {
+        return hslToRgb;
+      },
+      hslaToHsva: function() {
+        return hslaToHsva;
+      },
+      hslaToRgba: function() {
+        return hslaToRgba;
+      },
+      hsvToHsl: function() {
+        return hsvToHsl;
+      },
+      hsvToRgb: function() {
+        return hsvToRgb;
+      },
+      hsvaToHsla: function() {
+        return hsvaToHsla;
+      },
+      hsvaToRgba: function() {
+        return hsvaToRgba;
+      },
+      isDivModeEnabled: function() {
+        return isDivModeEnabled;
+      },
+      isInArray: function() {
+        return isInArray;
+      },
+      isPointInside: function() {
+        return isPointInside;
+      },
+      isSsr: function() {
+        return isSsr;
+      },
+      itemFromArray: function() {
+        return itemFromArray;
+      },
+      loadFont: function() {
+        return loadFont;
+      },
+      mix: function() {
+        return mix;
+      },
+      pJSDom: function() {
+        return pJSDom;
+      },
+      paintBase: function() {
+        return paintBase;
+      },
+      particlesJS: function() {
+        return particlesJS;
+      },
+      randomInRange: function() {
+        return randomInRange;
+      },
+      rectBounce: function() {
+        return rectBounce;
+      },
+      rgbToHsl: function() {
+        return rgbToHsl;
+      },
+      rgbToHsv: function() {
+        return rgbToHsv;
+      },
+      rgbaToHsva: function() {
+        return rgbaToHsva;
+      },
+      setRangeValue: function() {
+        return setRangeValue;
+      },
+      singleDivModeExecute: function() {
+        return singleDivModeExecute;
+      },
+      stringToAlpha: function() {
+        return stringToAlpha;
+      },
+      stringToRgb: function() {
+        return stringToRgb;
+      },
+      tsParticles: function() {
+        return tsParticles;
+      }
     });
     const initPjs = main => {
       const particlesJS = (tagId, options) => main.load(tagId, options);
@@ -347,8 +666,8 @@
       };
       const pJSDom = main.dom();
       return {
-        particlesJS,
-        pJSDom
+        particlesJS: particlesJS,
+        pJSDom: pJSDom
       };
     };
     var MoveDirection;
@@ -448,6 +767,11 @@
       ThemeMode["dark"] = "dark";
       ThemeMode["light"] = "light";
     })(ThemeMode || (ThemeMode = {}));
+    var ResponsiveMode;
+    (function(ResponsiveMode) {
+      ResponsiveMode["screen"] = "screen";
+      ResponsiveMode["canvas"] = "canvas";
+    })(ResponsiveMode || (ResponsiveMode = {}));
     var AnimationStatus;
     (function(AnimationStatus) {
       AnimationStatus[AnimationStatus["increasing"] = 0] = "increasing";
@@ -648,7 +972,7 @@
     }
     function getValue(options) {
       const random = options.random;
-      const {enable, minimumValue} = typeof random === "boolean" ? {
+      const {enable: enable, minimumValue: minimumValue} = typeof random === "boolean" ? {
         enable: random,
         minimumValue: 0
       } : random;
@@ -658,8 +982,8 @@
       const dx = pointA.x - pointB.x;
       const dy = pointA.y - pointB.y;
       return {
-        dx,
-        dy,
+        dx: dx,
+        dy: dy,
         distance: Math.sqrt(dx * dx + dy * dy)
       };
     }
@@ -1274,7 +1598,7 @@
       }
       const s = !v ? 0 : c / v;
       return {
-        h,
+        h: h,
         s: s * 100,
         v: v * 100
       };
@@ -1683,8 +2007,8 @@
     class Range {
       constructor(x, y) {
         this.position = {
-          x,
-          y
+          x: x,
+          y: y
         };
       }
     }
@@ -1727,8 +2051,8 @@
       constructor(x, y, width, height) {
         super(x, y);
         this.size = {
-          height,
-          width
+          height: height,
+          width: width
         };
       }
       contains(point) {
@@ -2216,9 +2540,9 @@
           pathGenerators.set(type, pathGenerator);
         }
       }
-      static getInteractors(container) {
+      static getInteractors(container, force = false) {
         let res = interactors.get(container);
-        if (!res) {
+        if (!res || force) {
           res = [ ...interactorsInitializers.values() ].map((t => t(container)));
           interactors.set(container, res);
         }
@@ -2227,9 +2551,9 @@
       static addInteractor(name, initInteractor) {
         interactorsInitializers.set(name, initInteractor);
       }
-      static getUpdaters(container) {
+      static getUpdaters(container, force = false) {
         let res = updaters.get(container);
-        if (!res) {
+        if (!res || force) {
           res = [ ...updatersInitializers.values() ].map((t => t(container)));
           updaters.set(container, res);
         }
@@ -4486,21 +4810,21 @@
         const radius = this.getRadius();
         const outModes = this.options.move.outModes, fixHorizontal = outMode => {
           fixOutMode({
-            outMode,
+            outMode: outMode,
             checkModes: [ OutMode.bounce, OutMode.bounceHorizontal ],
             coord: pos.x,
             maxCoord: container.canvas.size.width,
             setCb: value => pos.x += value,
-            radius
+            radius: radius
           });
         }, fixVertical = outMode => {
           fixOutMode({
-            outMode,
+            outMode: outMode,
             checkModes: [ OutMode.bounce, OutMode.bounceVertical ],
             coord: pos.y,
             maxCoord: container.canvas.size.height,
             setCb: value => pos.y += value,
-            radius
+            radius: radius
           });
         };
         fixHorizontal((_c = outModes.left) !== null && _c !== void 0 ? _c : outModes.default);
@@ -4582,9 +4906,12 @@
     class InteractionManager {
       constructor(container) {
         this.container = container;
-        const interactors = Plugins.getInteractors(container);
         this.externalInteractors = [];
         this.particleInteractors = [];
+        this.init();
+      }
+      init() {
+        const interactors = Plugins.getInteractors(this.container, true);
         for (const interactor of interactors) {
           switch (interactor.type) {
            case InteractorType.External:
@@ -4617,7 +4944,7 @@
     }
     function applyDistance(particle) {
       const initialPosition = particle.initialPosition;
-      const {dx, dy} = getDistances(initialPosition, particle.position);
+      const {dx: dx, dy: dy} = getDistances(initialPosition, particle.position);
       const dxFixed = Math.abs(dx), dyFixed = Math.abs(dy);
       const hDistance = particle.retina.maxDistance.horizontal;
       const vDistance = particle.retina.maxDistance.vertical;
@@ -4806,7 +5133,7 @@
         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);
+        this.updaters = Plugins.getUpdaters(container, true);
       }
       get count() {
         return this.array.length;
@@ -4820,6 +5147,8 @@
         this.freqs.links = new Map;
         this.freqs.triangles = new Map;
         let handled = false;
+        this.updaters = Plugins.getUpdaters(container, true);
+        this.interactionManager.init();
         for (const [, plugin] of container.plugins) {
           if (plugin.particlesInitialization !== undefined) {
             handled = plugin.particlesInitialization();
@@ -5863,7 +6192,7 @@
     }
     class Interactivity {
       constructor() {
-        this.detectsOn = InteractivityDetect.canvas;
+        this.detectsOn = InteractivityDetect.window;
         this.events = new Events;
         this.modes = new Modes;
       }
@@ -5931,7 +6260,7 @@
             color: data.cover
           } : data.cover;
           this.cover.load(cover.color !== undefined ? cover : {
-            color
+            color: color
           });
         }
         if (data.enable !== undefined) {
@@ -6014,8 +6343,8 @@
     }
     class FullScreen {
       constructor() {
-        this.enable = false;
-        this.zIndex = -1;
+        this.enable = true;
+        this.zIndex = 0;
       }
       load(data) {
         if (!data) {
@@ -6082,6 +6411,7 @@
       constructor() {
         this.maxWidth = Infinity;
         this.options = {};
+        this.mode = ResponsiveMode.canvas;
       }
       load(data) {
         if (!data) {
@@ -6090,6 +6420,13 @@
         if (data.maxWidth !== undefined) {
           this.maxWidth = data.maxWidth;
         }
+        if (data.mode !== undefined) {
+          if (data.mode === ResponsiveMode.screen) {
+            this.mode = ResponsiveMode.screen;
+          } else {
+            this.mode = ResponsiveMode.canvas;
+          }
+        }
         if (data.options !== undefined) {
           this.options = deepExtend({}, data.options);
         }
@@ -6228,7 +6565,7 @@
       }
       setResponsive(width, pxRatio, defaultOptions) {
         this.load(defaultOptions);
-        const responsiveOptions = this.responsive.find((t => t.maxWidth * pxRatio > width));
+        const responsiveOptions = this.responsive.find((t => t.mode === ResponsiveMode.screen && screen ? t.maxWidth * pxRatio > screen.availWidth : t.maxWidth * pxRatio > width));
         this.load(responsiveOptions === null || responsiveOptions === void 0 ? void 0 : responsiveOptions.options);
         return responsiveOptions === null || responsiveOptions === void 0 ? void 0 : responsiveOptions.maxWidth;
       }
@@ -6254,10 +6591,12 @@
         this.zLayers = 100;
         this.pageHidden = false;
         this._sourceOptions = sourceOptions;
+        this._initialSourceOptions = sourceOptions;
         this.retina = new Retina(this);
         this.canvas = new Canvas(this);
         this.particles = new Particles(this);
         this.drawer = new FrameManager(this);
+        this.presets = presets;
         this.pathGenerator = {
           generate: () => {
             const v = Vector.create(0, 0);
@@ -6286,17 +6625,6 @@
         this.density = 1;
         this._options = new Options;
         this.actualOptions = new Options;
-        for (const preset of presets) {
-          this._options.load(Plugins.getPreset(preset));
-        }
-        const shapes = Plugins.getSupportedShapes();
-        for (const type of shapes) {
-          const drawer = Plugins.getShapeDrawer(type);
-          if (drawer) {
-            this.drawers.set(type, drawer);
-          }
-        }
-        this._options.load(this._sourceOptions);
         this.eventListeners = new EventListeners(this);
         if (typeof IntersectionObserver !== "undefined" && IntersectionObserver) {
           this.intersectionObserver = new IntersectionObserver((entries => this.intersectionManager(entries)));
@@ -6438,6 +6766,7 @@
         this.particles.linksColors = new Map;
         delete this.particles.grabLineColor;
         delete this.particles.linksColor;
+        this._sourceOptions = this._options;
       }
       async loadTheme(name) {
         this.currentTheme = name;
@@ -6551,6 +6880,19 @@
         return false;
       }
       async init() {
+        this._options = new Options;
+        for (const preset of this.presets) {
+          this._options.load(Plugins.getPreset(preset));
+        }
+        const shapes = Plugins.getSupportedShapes();
+        for (const type of shapes) {
+          const drawer = Plugins.getShapeDrawer(type);
+          if (drawer) {
+            this.drawers.set(type, drawer);
+          }
+        }
+        this._options.load(this._initialSourceOptions);
+        this._options.load(this._sourceOptions);
         this.actualOptions = new Options;
         this.actualOptions.load(this._options);
         this.retina.init();
@@ -6637,7 +6979,7 @@
       static async loadOptions(params) {
         var _a, _b, _c;
         const tagId = (_a = params.tagId) !== null && _a !== void 0 ? _a : `tsparticles${Math.floor(Math.random() * 1e4)}`;
-        const {options, index} = params;
+        const {options: options, index: index} = params;
         let domContainer = (_b = params.element) !== null && _b !== void 0 ? _b : document.getElementById(tagId);
         if (!domContainer) {
           domContainer = document.createElement("div");
@@ -6687,7 +7029,7 @@
         return newItem;
       }
       static async loadRemoteOptions(params) {
-        const {url: jsonUrl, index} = params;
+        const {url: jsonUrl, index: index} = params;
         const url = jsonUrl instanceof Array ? itemFromArray(jsonUrl, index) : jsonUrl;
         if (!url) {
           return;
@@ -6701,13 +7043,13 @@
         return await Loader.loadOptions({
           tagId: params.tagId,
           element: params.element,
-          index,
+          index: index,
           options: data
         });
       }
       static load(tagId, options, index) {
         const params = {
-          index
+          index: index
         };
         if (typeof tagId === "string") {
           params.tagId = tagId;
@@ -6723,7 +7065,7 @@
       }
       static async set(id, domContainer, options, index) {
         const params = {
-          index
+          index: index
         };
         if (typeof id === "string") {
           params.tagId = id;
@@ -6752,8 +7094,8 @@
         }
         return await Loader.loadRemoteOptions({
           tagId: id,
-          url,
-          index
+          url: url,
+          index: index
         });
       }
       static async setJSON(id, domContainer, jsonUrl, index) {
@@ -6770,9 +7112,9 @@
         }
         return await Loader.loadRemoteOptions({
           tagId: newId,
-          url,
+          url: url,
           index: newIndex,
-          element
+          element: element
         });
       }
       static setOnClickHandler(callback) {
@@ -6832,34 +7174,45 @@
       domItem(index) {
         return Loader.domItem(index);
       }
-      addShape(shape, drawer, init, afterEffect, destroy) {
+      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,
-            destroy,
+            afterEffect: afterEffect,
+            destroy: destroy,
             draw: drawer,
-            init
+            init: init
           };
         } else {
           customDrawer = drawer;
         }
         Plugins.addShapeDrawer(shape, customDrawer);
+        await this.refresh();
       }
-      addPreset(preset, options, override = false) {
+      async addPreset(preset, options, override = false) {
         Plugins.addPreset(preset, options, override);
+        await this.refresh();
       }
-      addPlugin(plugin) {
+      async addPlugin(plugin) {
         Plugins.addPlugin(plugin);
+        await this.refresh();
       }
-      addPathGenerator(name, generator) {
+      async addPathGenerator(name, generator) {
         Plugins.addPathGenerator(name, generator);
+        await this.refresh();
       }
-      addInteractor(name, interactorInitializer) {
+      async addInteractor(name, interactorInitializer) {
         Plugins.addInteractor(name, interactorInitializer);
+        await this.refresh();
       }
-      addParticleUpdater(name, updaterInitializer) {
+      async addParticleUpdater(name, updaterInitializer) {
         Plugins.addParticleUpdater(name, updaterInitializer);
+        await this.refresh();
       }
     }
     _Main_initialized = new WeakMap;
@@ -6871,8 +7224,8 @@
         context.arc(0, 0, radius, 0, Math.PI * 2, false);
       }
     }
-    function loadCircleShape(tsParticles) {
-      tsParticles.addShape("circle", new CircleDrawer);
+    async function loadCircleShape(tsParticles) {
+      await tsParticles.addShape("circle", new CircleDrawer);
     }
     class LifeUpdater {
       constructor(container) {
@@ -6933,8 +7286,8 @@
         life.duration = getRangeValue(lifeOptions.duration.value) * 1e3;
       }
     }
-    function loadLifeUpdater(tsParticles) {
-      tsParticles.addParticleUpdater("life", (container => new LifeUpdater(container)));
+    async function loadLifeUpdater(tsParticles) {
+      await tsParticles.addParticleUpdater("life", (container => new LifeUpdater(container)));
     }
     class ExternalInteractorBase {
       constructor(container) {
@@ -6976,8 +7329,8 @@
         }
       }
     }
-    function loadExternalConnectInteraction(tsParticles) {
-      tsParticles.addInteractor("externalConnect", (container => new Connector(container)));
+    async function loadExternalConnectInteraction(tsParticles) {
+      await tsParticles.addInteractor("externalConnect", (container => new Connector(container)));
     }
     function checkDestroy(particle, value, minValue, maxValue) {
       switch (particle.options.opacity.animation.destroy) {
@@ -7088,8 +7441,8 @@
         updateOpacity(particle, delta);
       }
     }
-    function loadOpacityUpdater(tsParticles) {
-      tsParticles.addParticleUpdater("opacity", (container => new OpacityUpdater(container)));
+    async function loadOpacityUpdater(tsParticles) {
+      await tsParticles.addParticleUpdater("opacity", (container => new OpacityUpdater(container)));
     }
     function loadImage(source) {
       return new Promise(((resolve, reject) => {
@@ -7098,7 +7451,7 @@
           return;
         }
         const image = {
-          source,
+          source: source,
           type: source.substr(source.length - 3)
         };
         const img = new Image;
@@ -7117,7 +7470,7 @@
         throw new Error("Error tsParticles - No image.src");
       }
       const image = {
-        source,
+        source: source,
         type: source.substr(source.length - 3)
       };
       if (image.type !== "svg") {
@@ -7131,7 +7484,7 @@
       return image;
     }
     function replaceColorSvg(imageShape, color, opacity) {
-      const {svgData} = imageShape;
+      const {svgData: svgData} = imageShape;
       if (!svgData) {
         return "";
       }
@@ -7335,8 +7688,8 @@
         const close = (_g = imageData.close) !== null && _g !== void 0 ? _g : particle.close;
         const imageShape = {
           image: imageRes,
-          fill,
-          close
+          fill: fill,
+          close: close
         };
         particle.image = imageShape.image;
         particle.fill = imageShape.fill;
@@ -7344,10 +7697,10 @@
       }
     }
     _ImageDrawer_images = new WeakMap;
-    function loadImageShape(tsParticles) {
+    async function loadImageShape(tsParticles) {
       const imageDrawer = new ImageDrawer;
-      tsParticles.addShape("image", imageDrawer);
-      tsParticles.addShape("images", imageDrawer);
+      await tsParticles.addShape("image", imageDrawer);
+      await tsParticles.addShape("images", imageDrawer);
     }
     class PolygonDrawerBase {
       getSidesCount(particle) {
@@ -7416,15 +7769,15 @@
         };
       }
     }
-    function loadGenericPolygonShape(tsParticles) {
-      tsParticles.addShape("polygon", new PolygonDrawer);
+    async function loadGenericPolygonShape(tsParticles) {
+      await tsParticles.addShape("polygon", new PolygonDrawer);
     }
-    function loadTriangleShape(tsParticles) {
-      tsParticles.addShape("triangle", new TriangleDrawer);
+    async function loadTriangleShape(tsParticles) {
+      await tsParticles.addShape("triangle", new TriangleDrawer);
     }
-    function loadPolygonShape(tsParticles) {
-      loadGenericPolygonShape(tsParticles);
-      loadTriangleShape(tsParticles);
+    async function loadPolygonShape(tsParticles) {
+      await loadGenericPolygonShape(tsParticles);
+      await loadTriangleShape(tsParticles);
     }
     var ProcessBubbleType;
     (function(ProcessBubbleType) {
@@ -7664,8 +8017,8 @@
         }
       }
     }
-    function loadExternalBubbleInteraction(tsParticles) {
-      tsParticles.addInteractor("externalBubble", (container => new Bubbler(container)));
+    async function loadExternalBubbleInteraction(tsParticles) {
+      await tsParticles.addInteractor("externalBubble", (container => new Bubbler(container)));
     }
     class Attractor extends ExternalInteractorBase {
       constructor(container) {
@@ -7702,7 +8055,7 @@
         const attractOptions = container.actualOptions.interactivity.modes.attract;
         const query = container.particles.quadTree.query(area);
         for (const particle of query) {
-          const {dx, dy, distance} = getDistances(particle.position, position);
+          const {dx: dx, dy: dy, distance: distance} = getDistances(particle.position, position);
           const velocity = attractOptions.speed * attractOptions.factor;
           const attractFactor = clamp(calcEasing(1 - distance / attractRadius, attractOptions.easing) * velocity, 0, attractOptions.maxSpeed);
           const normVec = Vector.create(distance === 0 ? velocity : dx / distance * attractFactor, distance === 0 ? velocity : dy / distance * attractFactor);
@@ -7733,8 +8086,8 @@
         return;
       }
     }
-    function loadExternalAttractInteraction(tsParticles) {
-      tsParticles.addInteractor("externalAttract", (container => new Attractor(container)));
+    async function loadExternalAttractInteraction(tsParticles) {
+      await tsParticles.addInteractor("externalAttract", (container => new Attractor(container)));
     }
     class Grabber extends ExternalInteractorBase {
       constructor(container) {
@@ -7776,8 +8129,8 @@
         }
       }
     }
-    function loadExternalGrabInteraction(tsParticles) {
-      tsParticles.addInteractor("externalGrab", (container => new Grabber(container)));
+    async function loadExternalGrabInteraction(tsParticles) {
+      await tsParticles.addInteractor("externalGrab", (container => new Grabber(container)));
     }
     class StarDrawer {
       getSidesCount(particle) {
@@ -7799,8 +8152,8 @@
         }
       }
     }
-    function loadStarShape(tsParticles) {
-      tsParticles.addShape("star", new StarDrawer);
+    async function loadStarShape(tsParticles) {
+      await tsParticles.addShape("star", new StarDrawer);
     }
     class ParticlesInteractorBase {
       constructor(container) {
@@ -7819,7 +8172,7 @@
           if (p1 === p2 || !p2.options.move.attract.enable || p2.destroyed || p2.spawning) {
             continue;
           }
-          const pos2 = p2.getPosition(), {dx, dy} = getDistances(pos1, pos2), rotate = p1.options.move.attract.rotate, ax = dx / (rotate.x * 1e3), ay = dy / (rotate.y * 1e3), p1Factor = p2.size.value / p1.size.value, p2Factor = 1 / p1Factor;
+          const pos2 = p2.getPosition(), {dx: dx, dy: dy} = getDistances(pos1, pos2), rotate = p1.options.move.attract.rotate, ax = dx / (rotate.x * 1e3), ay = dy / (rotate.y * 1e3), p1Factor = p2.size.value / p1.size.value, p2Factor = 1 / p1Factor;
           p1.velocity.x -= ax * p1Factor;
           p1.velocity.y -= ay * p1Factor;
           p2.velocity.x += ax * p2Factor;
@@ -7831,8 +8184,8 @@
       }
       reset() {}
     }
-    function loadParticlesAttractInteraction(tsParticles) {
-      tsParticles.addInteractor("particlesAttract", (container => new Attractor_Attractor(container)));
+    async function loadParticlesAttractInteraction(tsParticles) {
+      await tsParticles.addInteractor("particlesAttract", (container => new Attractor_Attractor(container)));
     }
     const fixFactor = Math.sqrt(2);
     class SquareDrawer {
@@ -7843,10 +8196,10 @@
         context.rect(-radius / fixFactor, -radius / fixFactor, radius * 2 / fixFactor, radius * 2 / fixFactor);
       }
     }
-    function loadSquareShape(tsParticles) {
+    async function loadSquareShape(tsParticles) {
       const drawer = new SquareDrawer;
-      tsParticles.addShape("edge", drawer);
-      tsParticles.addShape("square", drawer);
+      await tsParticles.addShape("edge", drawer);
+      await tsParticles.addShape("square", drawer);
     }
     function updateColorValue(delta, value, valueAnimation, max, decrease) {
       var _a;
@@ -7918,8 +8271,8 @@
         updateStrokeColor(particle, delta);
       }
     }
-    function loadStrokeColorUpdater(tsParticles) {
-      tsParticles.addParticleUpdater("strokeColor", (container => new StrokeColorUpdater(container)));
+    async function loadStrokeColorUpdater(tsParticles) {
+      await tsParticles.addParticleUpdater("strokeColor", (container => new StrokeColorUpdater(container)));
     }
     function ColorUpdater_updateColorValue(delta, value, valueAnimation, max, decrease) {
       var _a;
@@ -7978,8 +8331,8 @@
         updateColor(particle, delta);
       }
     }
-    function loadColorUpdater(tsParticles) {
-      tsParticles.addParticleUpdater("color", (container => new ColorUpdater(container)));
+    async function loadColorUpdater(tsParticles) {
+      await tsParticles.addParticleUpdater("color", (container => new ColorUpdater(container)));
     }
     function bounce(p1, p2) {
       circleBounce(circleBounceDataFromParticle(p1), circleBounceDataFromParticle(p2));
@@ -8078,8 +8431,8 @@
         }
       }
     }
-    function loadParticlesCollisionsInteraction(tsParticles) {
-      tsParticles.addInteractor("particlesCollisions", (container => new Collider(container)));
+    async function loadParticlesCollisionsInteraction(tsParticles) {
+      await tsParticles.addInteractor("particlesCollisions", (container => new Collider(container)));
     }
     function updateAngle(particle, delta) {
       var _a;
@@ -8156,8 +8509,8 @@
         updateAngle(particle, delta);
       }
     }
-    function loadAngleUpdater(tsParticles) {
-      tsParticles.addParticleUpdater("angle", (container => new AngleUpdater(container)));
+    async function loadAngleUpdater(tsParticles) {
+      await tsParticles.addParticleUpdater("angle", (container => new AngleUpdater(container)));
     }
     function bounceHorizontal(data) {
       if (!(data.outMode === OutMode.bounce || data.outMode === OutMode.bounceHorizontal || data.outMode === "bounceHorizontal" || data.outMode === OutMode.split)) {
@@ -8312,22 +8665,22 @@
         }
         const pos = particle.getPosition(), offset = particle.offset, size = particle.getRadius(), bounds = calculateBounds(pos, size), canvasSize = container.canvas.size;
         bounceHorizontal({
-          particle,
-          outMode,
-          direction,
-          bounds,
-          canvasSize,
-          offset,
-          size
+          particle: particle,
+          outMode: outMode,
+          direction: direction,
+          bounds: bounds,
+          canvasSize: canvasSize,
+          offset: offset,
+          size: size
         });
         bounceVertical({
-          particle,
-          outMode,
-          direction,
-          bounds,
-          canvasSize,
-          offset,
-          size
+          particle: particle,
+          outMode: outMode,
+          direction: direction,
+          bounds: bounds,
+          canvasSize: canvasSize,
+          offset: offset,
+          size: size
         });
       }
       none(particle, direction) {
@@ -8352,8 +8705,8 @@
         }
       }
     }
-    function loadOutModesUpdater(tsParticles) {
-      tsParticles.addParticleUpdater("outModes", (container => new OutOfCanvasUpdater(container)));
+    async function loadOutModesUpdater(tsParticles) {
+      await tsParticles.addParticleUpdater("outModes", (container => new OutOfCanvasUpdater(container)));
     }
     class Repulser extends ExternalInteractorBase {
       constructor(container) {
@@ -8403,7 +8756,7 @@
         var _a;
         const container = this.container, query = container.particles.quadTree.query(area), repulseOptions = container.actualOptions.interactivity.modes.repulse;
         for (const particle of query) {
-          const {dx, dy, distance} = getDistances(particle.position, position), velocity = ((_a = divRepulse === null || divRepulse === void 0 ? void 0 : divRepulse.speed) !== null && _a !== void 0 ? _a : repulseOptions.speed) * repulseOptions.factor, repulseFactor = clamp(calcEasing(1 - distance / repulseRadius, repulseOptions.easing) * velocity, 0, repulseOptions.maxSpeed), normVec = Vector.create(distance === 0 ? velocity : dx / distance * repulseFactor, distance === 0 ? velocity : dy / distance * repulseFactor);
+          const {dx: dx, dy: dy, distance: distance} = getDistances(particle.position, position), velocity = ((_a = divRepulse === null || divRepulse === void 0 ? void 0 : divRepulse.speed) !== null && _a !== void 0 ? _a : repulseOptions.speed) * repulseOptions.factor, repulseFactor = clamp(calcEasing(1 - distance / repulseRadius, repulseOptions.easing) * velocity, 0, repulseOptions.maxSpeed), normVec = Vector.create(distance === 0 ? velocity : dx / distance * repulseFactor, distance === 0 ? velocity : dy / distance * repulseFactor);
           particle.position.addTo(normVec);
         }
       }
@@ -8425,7 +8778,7 @@
           }
           const range = new Circle(mouseClickPos.x, mouseClickPos.y, repulseRadius), query = container.particles.quadTree.query(range);
           for (const particle of query) {
-            const {dx, dy, distance} = getDistances(mouseClickPos, particle.position), d = distance ** 2, velocity = container.actualOptions.interactivity.modes.repulse.speed, force = -repulseRadius * velocity / d;
+            const {dx: dx, dy: dy, distance: distance} = getDistances(mouseClickPos, particle.position), d = distance ** 2, velocity = container.actualOptions.interactivity.modes.repulse.speed, force = -repulseRadius * velocity / d;
             if (d <= repulseRadius) {
               container.repulse.particles.push(particle);
               const vect = Vector.create(dx, dy);
@@ -8441,8 +8794,8 @@
         }
       }
     }
-    function loadExternalRepulseInteraction(tsParticles) {
-      tsParticles.addInteractor("externalRepulse", (container => new Repulser(container)));
+    async function loadExternalRepulseInteraction(tsParticles) {
+      await tsParticles.addInteractor("externalRepulse", (container => new Repulser(container)));
     }
     class LineDrawer {
       getSidesCount() {
@@ -8453,8 +8806,8 @@
         context.lineTo(radius / 2, 0);
       }
     }
-    function loadLineShape(tsParticles) {
-      tsParticles.addShape("line", new LineDrawer);
+    async function loadLineShape(tsParticles) {
+      await tsParticles.addShape("line", new LineDrawer);
     }
     class Bouncer extends ExternalInteractorBase {
       constructor(container) {
@@ -8499,8 +8852,8 @@
         for (const particle of query) {
           if (area instanceof Circle) {
             circleBounce(circleBounceDataFromParticle(particle), {
-              position,
-              radius,
+              position: position,
+              radius: radius,
               mass: radius ** 2 * Math.PI / 2,
               velocity: Vector.origin,
               factor: Vector.origin
@@ -8511,8 +8864,8 @@
         }
       }
     }
-    function loadExternalBounceInteraction(tsParticles) {
-      tsParticles.addInteractor("externalBounce", (container => new Bouncer(container)));
+    async function loadExternalBounceInteraction(tsParticles) {
+      await tsParticles.addInteractor("externalBounce", (container => new Bouncer(container)));
     }
     const validTypes = [ "text", "character", "char" ];
     class TextDrawer {
@@ -8571,10 +8924,10 @@
         context.globalAlpha = 1;
       }
     }
-    function loadTextShape(tsParticles) {
+    async function loadTextShape(tsParticles) {
       const drawer = new TextDrawer;
       for (const type of validTypes) {
-        tsParticles.addShape(type, drawer);
+        await tsParticles.addShape(type, drawer);
       }
     }
     function getLinkDistance(pos1, pos2, optDistance, canvasSize, warp) {
@@ -8789,16 +9142,16 @@
       }
       loadOptions() {}
     }
-    function loadPlugin(tsParticles) {
+    async function loadPlugin(tsParticles) {
       const plugin = new Plugin;
-      tsParticles.addPlugin(plugin);
+      await tsParticles.addPlugin(plugin);
     }
-    function loadInteraction(tsParticles) {
-      tsParticles.addInteractor("particlesLinks", (container => new Linker(container)));
+    async function loadInteraction(tsParticles) {
+      await tsParticles.addInteractor("particlesLinks", (container => new Linker(container)));
     }
-    function loadParticlesLinksInteraction(tsParticles) {
-      loadInteraction(tsParticles);
-      loadPlugin(tsParticles);
+    async function loadParticlesLinksInteraction(tsParticles) {
+      await loadInteraction(tsParticles);
+      await loadPlugin(tsParticles);
     }
     function SizeUpdater_checkDestroy(particle, value, minValue, maxValue) {
       switch (particle.options.size.animation.destroy) {
@@ -8865,33 +9218,33 @@
         updateSize(particle, delta);
       }
     }
-    function loadSizeUpdater(tsParticles) {
-      tsParticles.addParticleUpdater("size", (() => new SizeUpdater));
-    }
-    function loadSlim(tsParticles) {
-      loadExternalAttractInteraction(tsParticles);
-      loadExternalBounceInteraction(tsParticles);
-      loadExternalBubbleInteraction(tsParticles);
-      loadExternalConnectInteraction(tsParticles);
-      loadExternalGrabInteraction(tsParticles);
-      loadExternalRepulseInteraction(tsParticles);
-      loadParticlesAttractInteraction(tsParticles);
-      loadParticlesCollisionsInteraction(tsParticles);
-      loadParticlesLinksInteraction(tsParticles);
-      loadCircleShape(tsParticles);
-      loadImageShape(tsParticles);
-      loadLineShape(tsParticles);
-      loadPolygonShape(tsParticles);
-      loadSquareShape(tsParticles);
-      loadStarShape(tsParticles);
-      loadTextShape(tsParticles);
-      loadLifeUpdater(tsParticles);
-      loadOpacityUpdater(tsParticles);
-      loadSizeUpdater(tsParticles);
-      loadAngleUpdater(tsParticles);
-      loadColorUpdater(tsParticles);
-      loadStrokeColorUpdater(tsParticles);
-      loadOutModesUpdater(tsParticles);
+    async function loadSizeUpdater(tsParticles) {
+      await tsParticles.addParticleUpdater("size", (() => new SizeUpdater));
+    }
+    async function loadSlim(tsParticles) {
+      await loadExternalAttractInteraction(tsParticles);
+      await loadExternalBounceInteraction(tsParticles);
+      await loadExternalBubbleInteraction(tsParticles);
+      await loadExternalConnectInteraction(tsParticles);
+      await loadExternalGrabInteraction(tsParticles);
+      await loadExternalRepulseInteraction(tsParticles);
+      await loadParticlesAttractInteraction(tsParticles);
+      await loadParticlesCollisionsInteraction(tsParticles);
+      await loadParticlesLinksInteraction(tsParticles);
+      await loadCircleShape(tsParticles);
+      await loadImageShape(tsParticles);
+      await loadLineShape(tsParticles);
+      await loadPolygonShape(tsParticles);
+      await loadSquareShape(tsParticles);
+      await loadStarShape(tsParticles);
+      await loadTextShape(tsParticles);
+      await loadLifeUpdater(tsParticles);
+      await loadOpacityUpdater(tsParticles);
+      await loadSizeUpdater(tsParticles);
+      await loadAngleUpdater(tsParticles);
+      await loadColorUpdater(tsParticles);
+      await loadStrokeColorUpdater(tsParticles);
+      await loadOutModesUpdater(tsParticles);
     }
     class TrailMaker extends ExternalInteractorBase {
       constructor(container) {
@@ -8935,8 +9288,8 @@
       }
       reset() {}
     }
-    function loadExternalTrailInteraction(tsParticles) {
-      tsParticles.addInteractor("externalTrail", (container => new TrailMaker(container)));
+    async function loadExternalTrailInteraction(tsParticles) {
+      await tsParticles.addInteractor("externalTrail", (container => new TrailMaker(container)));
     }
     function updateTilt(particle, delta) {
       var _a;
@@ -9014,8 +9367,8 @@
         updateTilt(particle, delta);
       }
     }
-    function loadTiltUpdater(tsParticles) {
-      tsParticles.addParticleUpdater("tilt", (container => new TiltUpdater(container)));
+    async function loadTiltUpdater(tsParticles) {
+      await tsParticles.addParticleUpdater("tilt", (container => new TiltUpdater(container)));
     }
     function updateWobble(particle, delta) {
       var _a;
@@ -9062,12 +9415,12 @@
         updateWobble(particle, delta);
       }
     }
-    function loadWobbleUpdater(tsParticles) {
-      tsParticles.addParticleUpdater("wobble", (container => new WobbleUpdater(container)));
+    async function loadWobbleUpdater(tsParticles) {
+      await tsParticles.addParticleUpdater("wobble", (container => new WobbleUpdater(container)));
     }
     class AbsorberInstance {
       constructor(absorbers, container, options, position) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         this.absorbers = absorbers;
         this.container = container;
         this.initialPosition = position ? Vector.create(position.x, position.y) : undefined;
@@ -9078,16 +9431,22 @@
         this.size = getRangeValue(options.size.value) * container.retina.pixelRatio;
         this.mass = this.size * options.size.density * container.retina.reduceFactor;
         const limit = options.size.limit;
-        this.limit = limit !== undefined ? limit * container.retina.pixelRatio * container.retina.reduceFactor : limit;
+        this.limit = typeof limit === "number" ? {
+          radius: limit * container.retina.pixelRatio * container.retina.reduceFactor,
+          mass: 0
+        } : {
+          radius: ((_a = limit === null || limit === void 0 ? void 0 : limit.radius) !== null && _a !== void 0 ? _a : 0) * container.retina.pixelRatio * container.retina.reduceFactor,
+          mass: (_b = limit === null || limit === void 0 ? void 0 : limit.mass) !== null && _b !== void 0 ? _b : 0
+        };
         const color = typeof options.color === "string" ? {
           value: options.color
         } : options.color;
-        this.color = (_a = colorToRgb(color)) !== null && _a !== void 0 ? _a : {
+        this.color = (_c = colorToRgb(color)) !== null && _c !== void 0 ? _c : {
           b: 0,
           g: 0,
           r: 0
         };
-        this.position = (_c = (_b = this.initialPosition) === null || _b === void 0 ? void 0 : _b.copy()) !== null && _c !== void 0 ? _c : this.calcPosition();
+        this.position = (_e = (_d = this.initialPosition) === null || _d === void 0 ? void 0 : _d.copy()) !== null && _e !== void 0 ? _e : this.calcPosition();
       }
       attract(particle) {
         const container = this.container;
@@ -9108,7 +9467,7 @@
           }
         }
         const pos = particle.getPosition();
-        const {dx, dy, distance} = getDistances(this.position, pos);
+        const {dx: dx, dy: dy, distance: distance} = getDistances(this.position, pos);
         const v = Vector.create(dx, dy);
         v.length = this.mass / Math.pow(distance, 2) * container.retina.reduceFactor;
         if (distance < this.size + particle.getRadius()) {
@@ -9126,10 +9485,12 @@
             }
             this.updateParticlePosition(particle, v);
           }
-          if (this.limit === undefined || this.size < this.limit) {
+          if (this.limit.radius <= 0 || this.size < this.limit.radius) {
             this.size += sizeFactor;
           }
-          this.mass += sizeFactor * this.options.size.density * container.retina.reduceFactor;
+          if (this.limit.mass <= 0 || this.mass < this.limit.mass) {
+            this.mass += sizeFactor * this.options.size.density * container.retina.reduceFactor;
+          }
         } else {
           this.updateParticlePosition(particle, v);
         }
@@ -9160,9 +9521,10 @@
         const container = this.container;
         const canvasSize = container.canvas.size;
         if (particle.needsNewPosition) {
-          const pSize = particle.getRadius();
-          particle.position.x = (canvasSize.width - pSize * 2) * (1 + (Math.random() * .2 - .1)) + pSize;
-          particle.position.y = (canvasSize.height - pSize * 2) * (1 + (Math.random() * .2 - .1)) + pSize;
+          particle.position.x = Math.floor(Math.random() * canvasSize.width);
+          particle.position.y = Math.floor(Math.random() * canvasSize.height);
+          particle.velocity.setTo(particle.initialVelocity);
+          particle.absorberOrbit = undefined;
           particle.needsNewPosition = false;
         }
         if (this.options.orbits) {
@@ -9199,12 +9561,30 @@
         }
       }
     }
+    class AbsorberSizeLimit {
+      constructor() {
+        this.radius = 0;
+        this.mass = 0;
+      }
+      load(data) {
+        if (!data) {
+          return;
+        }
+        if (data.mass !== undefined) {
+          this.mass = data.mass;
+        }
+        if (data.radius !== undefined) {
+          this.radius = data.radius;
+        }
+      }
+    }
     class AbsorberSize extends ValueWithRandom {
       constructor() {
         super();
         this.density = 5;
         this.random.minimumValue = 1;
         this.value = 50;
+        this.limit = new AbsorberSizeLimit;
       }
       load(data) {
         if (!data) {
@@ -9214,11 +9594,10 @@
         if (data.density !== undefined) {
           this.density = data.density;
         }
-        if (data.limit !== undefined) {
-          this.limit = data.limit;
-        }
-        if (data.limit !== undefined) {
-          this.limit = data.limit;
+        if (typeof data.limit === "number") {
+          this.limit.radius = data.limit;
+        } else {
+          this.limit.load(data.limit);
         }
       }
     }
@@ -9436,9 +9815,9 @@
         }
       }
     }
-    function loadAbsorbersPlugin(tsParticles) {
+    async function loadAbsorbersPlugin(tsParticles) {
       const plugin = new plugin_Plugin;
-      tsParticles.addPlugin(plugin);
+      await tsParticles.addPlugin(plugin);
     }
     class EmitterSize {
       constructor() {
@@ -10030,9 +10409,9 @@
         }
       }
     }
-    function loadEmittersPlugin(tsParticles) {
+    async function loadEmittersPlugin(tsParticles) {
       const plugin = new EmittersPlugin;
-      tsParticles.addPlugin(plugin);
+      await tsParticles.addPlugin(plugin);
       if (!tsParticles.addEmitterShape) {
         tsParticles.addEmitterShape = (name, shape) => {
           ShapeManager.addShape(name, shape);
@@ -10316,7 +10695,7 @@
       return res;
     }
     function calcClosestPtOnSegment(s1, s2, pos) {
-      const {dx, dy} = getDistances(pos, s1);
+      const {dx: dx, dy: dy} = getDistances(pos, s1);
       const {dx: dxx, dy: dyy} = getDistances(s2, s1);
       const t = (dx * dxx + dy * dyy) / (dxx ** 2 + dyy ** 2);
       let x = s1.x + dxx * t;
@@ -10329,13 +10708,13 @@
         y = s2.y;
       }
       return {
-        x,
-        y,
+        x: x,
+        y: y,
         isOnSegment: t >= 0 && t <= 1
       };
     }
     function segmentBounce(start, stop, velocity) {
-      const {dx, dy} = getDistances(start, stop);
+      const {dx: dx, dy: dy} = getDistances(start, stop);
       const wallAngle = Math.atan2(dy, dx);
       const wallNormalX = Math.sin(wallAngle);
       const wallNormalY = -Math.cos(wallAngle);
@@ -10733,7 +11112,7 @@
         await __webpack_require__.e(917).then(__webpack_require__.t.bind(__webpack_require__, 167, 23));
       }
       const plugin = new PolygonMask_plugin_Plugin;
-      tsParticles.addPlugin(plugin);
+      await tsParticles.addPlugin(plugin);
     }
     function updateRoll(particle, delta) {
       const roll = particle.options.roll;
@@ -10792,23 +11171,24 @@
         updateRoll(particle, delta);
       }
     }
-    function loadRollUpdater(tsParticles) {
-      tsParticles.addParticleUpdater("roll", (() => new RollUpdater));
+    async function loadRollUpdater(tsParticles) {
+      await tsParticles.addParticleUpdater("roll", (() => new RollUpdater));
     }
-    function loadFull(tsParticles) {
-      loadSlim(tsParticles);
-      loadExternalTrailInteraction(tsParticles);
-      loadRollUpdater(tsParticles);
-      loadTiltUpdater(tsParticles);
-      loadWobbleUpdater(tsParticles);
-      loadAbsorbersPlugin(tsParticles);
-      loadEmittersPlugin(tsParticles);
-      loadPolygonMaskPlugin(tsParticles);
+    async function loadFull(tsParticles) {
+      await loadSlim(tsParticles);
+      await loadExternalTrailInteraction(tsParticles);
+      await loadRollUpdater(tsParticles);
+      await loadTiltUpdater(tsParticles);
+      await loadWobbleUpdater(tsParticles);
+      await loadAbsorbersPlugin(tsParticles);
+      await loadEmittersPlugin(tsParticles);
+      await loadPolygonMaskPlugin(tsParticles);
     }
     const tsParticles = new Main;
     tsParticles.init();
+    const {particlesJS: particlesJS, pJSDom: pJSDom} = initPjs(tsParticles);
     loadFull(tsParticles);
-    const {particlesJS, pJSDom} = initPjs(tsParticles);
+    __webpack_exports__ = __webpack_require__.O(__webpack_exports__);
     return __webpack_exports__;
-  })();
+  }();
 }));