tsparticles 1.37.1 → 1.37.2

package/tsparticles.js

@@ -3,10 +3,97 @@
     var a = factory();
     for (var i in a) (typeof exports === "object" ? exports : root)[i] = a[i];
   }
-})(this, (function() {
+})(window, (function() {
   return function() {
     "use strict";
-    var __webpack_require__ = {};
+    var __webpack_modules__ = {};
+    var __webpack_module_cache__ = {};
+    function __webpack_require__(moduleId) {
+      var cachedModule = __webpack_module_cache__[moduleId];
+      if (cachedModule !== undefined) {
+        return cachedModule.exports;
+      }
+      var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+      };
+      __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+      return module.exports;
+    }
+    __webpack_require__.m = __webpack_modules__;
+    !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);
+        if (mode & 8) return value;
+        if (typeof value === "object" && value) {
+          if (mode & 4 && value.__esModule) return value;
+          if (mode & 16 && typeof value.then === "function") return value;
+        }
+        var ns = Object.create(null);
+        __webpack_require__.r(ns);
+        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((function(key) {
+            def[key] = function() {
+              return value[key];
+            };
+          }));
+        }
+        def["default"] = function() {
+          return value;
+        };
+        __webpack_require__.d(ns, def);
+        return ns;
+      };
+    }();
     !function() {
       __webpack_require__.d = function(exports, definition) {
         for (var key in definition) {
@@ -19,11 +106,86 @@
         }
       };
     }();
+    !function() {
+      __webpack_require__.f = {};
+      __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 {
+          return this || new Function("return this")();
+        } catch (e) {
+          if (typeof window === "object") return window;
+        }
+      }();
+    }();
     !function() {
       __webpack_require__.o = function(obj, prop) {
         return Object.prototype.hasOwnProperty.call(obj, prop);
       };
     }();
+    !function() {
+      var inProgress = {};
+      var dataWebpackPrefix = "tsparticles:";
+      __webpack_require__.l = function(url, done, key, chunkId) {
+        if (inProgress[url]) {
+          inProgress[url].push(done);
+          return;
+        }
+        var script, needAttach;
+        if (key !== undefined) {
+          var scripts = document.getElementsByTagName("script");
+          for (var i = 0; i < scripts.length; i++) {
+            var s = scripts[i];
+            if (s.getAttribute("src") == url || s.getAttribute("data-webpack") == dataWebpackPrefix + key) {
+              script = s;
+              break;
+            }
+          }
+        }
+        if (!script) {
+          needAttach = true;
+          script = document.createElement("script");
+          script.charset = "utf-8";
+          script.timeout = 120;
+          if (__webpack_require__.nc) {
+            script.setAttribute("nonce", __webpack_require__.nc);
+          }
+          script.setAttribute("data-webpack", dataWebpackPrefix + key);
+          script.src = url;
+        }
+        inProgress[url] = [ done ];
+        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((function(fn) {
+            return fn(event);
+          }));
+          if (prev) return prev(event);
+        };
+        var timeout = setTimeout(onScriptComplete.bind(null, undefined, {
+          type: "timeout",
+          target: script
+        }), 12e4);
+        script.onerror = onScriptComplete.bind(null, script.onerror);
+        script.onload = onScriptComplete.bind(null, script.onload);
+        needAttach && document.head.appendChild(script);
+      };
+    }();
     !function() {
       __webpack_require__.r = function(exports) {
         if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
@@ -36,6 +198,109 @@
         });
       };
     }();
+    !function() {
+      var scriptUrl;
+      if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
+      var document = __webpack_require__.g.document;
+      if (!scriptUrl && document) {
+        if (document.currentScript) scriptUrl = document.currentScript.src;
+        if (!scriptUrl) {
+          var scripts = document.getElementsByTagName("script");
+          if (scripts.length) scriptUrl = scripts[scripts.length - 1].src;
+        }
+      }
+      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 = 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((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 = function(event) {
+                if (__webpack_require__.o(installedChunks, chunkId)) {
+                  installedChunkData = installedChunks[chunkId];
+                  if (installedChunkData !== 0) installedChunks[chunkId] = undefined;
+                  if (installedChunkData) {
+                    var errorType = event && (event.type === "load" ? "missing" : event.type);
+                    var realSrc = event && event.target && event.target.src;
+                    error.message = "Loading chunk " + chunkId + " failed.\n(" + errorType + ": " + realSrc + ")";
+                    error.name = "ChunkLoadError";
+                    error.type = errorType;
+                    error.request = realSrc;
+                    installedChunkData[1](error);
+                  }
+                }
+              };
+              __webpack_require__.l(url, loadingEnded, "chunk-" + chunkId, chunkId);
+            } else installedChunks[chunkId] = 0;
+          }
+        }
+      };
+      __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((function(id) {
+          return installedChunks[id] !== 0;
+        }))) {
+          for (moduleId in moreModules) {
+            if (__webpack_require__.o(moreModules, moduleId)) {
+              __webpack_require__.m[moduleId] = moreModules[moduleId];
+            }
+          }
+          if (runtime) var result = runtime(__webpack_require__);
+        }
+        if (parentChunkLoadingFunction) parentChunkLoadingFunction(data);
+        for (;i < chunkIds.length; i++) {
+          chunkId = chunkIds[i];
+          if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
+            installedChunks[chunkId][0]();
+          }
+          installedChunks[chunkIds[i]] = 0;
+        }
+        return __webpack_require__.O(result);
+      };
+      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__, {
@@ -6326,6 +6591,7 @@
         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);
@@ -6625,6 +6891,7 @@
             this.drawers.set(type, drawer);
           }
         }
+        this._options.load(this._initialSourceOptions);
         this._options.load(this._sourceOptions);
         this.actualOptions = new Options;
         this.actualOptions.load(this._options);
@@ -10816,11 +11083,7 @@
     }
     async function loadPolygonMaskPlugin(tsParticles) {
       if (!isSsr() && !window.SVGPathSeg) {
-        await Promise.resolve().then((function() {
-          var e = new Error("Module is not available (weak dependency)");
-          e.code = "MODULE_NOT_FOUND";
-          throw e;
-        }));
+        await __webpack_require__.e(917).then(__webpack_require__.t.bind(__webpack_require__, 167, 23));
       }
       const plugin = new PolygonMask_plugin_Plugin;
       await tsParticles.addPlugin(plugin);
@@ -10899,6 +11162,7 @@
     tsParticles.init();
     const {particlesJS: particlesJS, pJSDom: pJSDom} = initPjs(tsParticles);
     loadFull(tsParticles);
+    __webpack_exports__ = __webpack_require__.O(__webpack_exports__);
     return __webpack_exports__;
   }();
 }));