@tsparticles/plugin-poisson-disc 4.0.0-alpha.8 → 4.0.0-beta.0

package/56.min.js

@@ -0,0 +1 @@
+"use strict";(this.webpackChunk_tsparticles_plugin_poisson_disc=this.webpackChunk_tsparticles_plugin_poisson_disc||[]).push([[56],{56(i,t,s){s.d(t,{PoissonDisc:()=>h});var e=s(303);class h{active;cellSize;cols;dimensions;firstPoint;grid;points;radius;retries;rows;size;constructor(i,t,s,e,h){this.size={...i},this.radius=t,this.retries=s,this.dimensions=e,this.cellSize=Math.floor(this.radius/Math.sqrt(this.dimensions)),this.cols=Math.floor(this.size.width/this.cellSize),this.rows=Math.floor(this.size.height/this.cellSize),this.points=[],this.active=[],this.grid=[],this.firstPoint=h?{...h}:void 0,this.reset()}addPoint(i){let t={position:{...i},gridPosition:{x:Math.floor(i.x/this.cellSize),y:Math.floor(i.y/this.cellSize)}},s=this.points.length,e=this.grid[t.gridPosition.y];e&&(this.points.push(t),e[t.gridPosition.x]=s,this.active.push(s))}getRandom(i,t){return Math.floor((0,e.getRandom)()*(t-i))+i}initialiseGrid(){for(let i=0;i<=this.rows;i++){this.grid[i]=[];let t=this.grid[i];if(t)for(let i=0;i<=this.cols;i++)t[i]=-1}}reset(){this.points=[],this.active=[],this.grid=[],this.initialiseGrid(),this.firstPoint?this.addPoint(this.firstPoint):this.addPoint({x:this.getRandom(0,this.size.width),y:this.getRandom(0,this.size.height)})}async run(){this.reset();let i=0;for(;this.active.length>0;)this.steps(1),++i%100==0&&await new Promise(i=>setTimeout(i))}steps(i){for(let t=0;t<i;t++)this.active.length<=0||this._step()}_getNewPoint(i,t){let s=t*(e.doublePI/this.retries),h=this.getRandom(this.radius,this.radius*e.double),o={x:Math.cos(s)*h,y:Math.sin(s)*h},r={x:Math.floor(i.position.x+o.x),y:Math.floor(i.position.y+o.y)},n={x:Math.floor(r.x/this.cellSize),y:Math.floor(r.y/this.cellSize)};if(r.x<=0||r.x>=this.size.width||r.y<=0||r.y>=this.size.height)return;let l=this.grid[n.y];if(!l)return;let a=l[n.x];if(void 0!==a&&!(a>=0)){for(let i=-1;i<=1;i++)for(let t=-1;t<=1;t++){if(!i&&!t)continue;let s={x:n.x+t,y:n.y+i};if(s.x<0||s.y<0||s.x>=this.cols||s.y>=this.rows)continue;let h=this.grid[s.y]?.[s.x];if(void 0===h||h<0)continue;let o=this.points[h];if(o&&(0,e.getDistance)(r,o.position)<this.radius)return}return r}}_step(){let i=this.getRandom(0,this.active.length),t=!1;for(let s=0;s<this.retries;s++){let e=this.active[i];if(void 0===e)continue;let h=this.points[e];if(!h)continue;let o=this._getNewPoint(h,s);if(o){t=!0,this.addPoint(o);break}}t||this.active.splice(i,1)}}}}]);

package/960.min.js

@@ -0,0 +1 @@
+"use strict";(this.webpackChunk_tsparticles_plugin_poisson_disc=this.webpackChunk_tsparticles_plugin_poisson_disc||[]).push([[960],{960(i,s,t){t.d(s,{PoissonDiscPluginInstance:()=>n});var e=t(303);class n{poissonDisc;redrawTimeout;_container;_currentIndex;constructor(i){this._container=i,this._currentIndex=0}async init(){await this._initData()}particlePosition(i){let s=this._container.actualOptions.poisson;if(this.poissonDisc&&s?.enable&&!(this._currentIndex>=this.poissonDisc.points.length))return i??this.poissonDisc.points[this._currentIndex++]?.position}resize(){let i=this._container,s=i.actualOptions.poisson;s?.enable&&(this.redrawTimeout&&clearTimeout(this.redrawTimeout),this.redrawTimeout=setTimeout(()=>{(async()=>{this._container.destroyed||(await this._initData(),await i.particles.redraw())})()},250))}stop(){delete this.poissonDisc}async _initData(){let i=this._container,s=i.actualOptions.poisson,n=i.actualOptions.particles,a=i.canvas.size,o=i.retina.pixelRatio;if(!s?.enable)return;this._currentIndex=0;let{PoissonDisc:r}=await t.e(56).then(t.bind(t,56));this.poissonDisc=new r(a,s.radius?s.radius*o:Math.max((0,e.getRangeMax)(n.size.value)*o,Math.sqrt(a.width*a.height/n.number.value)),s.retries,s.dimensions),s.steps>0?this.poissonDisc.steps(s.steps):await this.poissonDisc.run()}}}}]);

package/964.min.js

@@ -0,0 +1 @@
+"use strict";(this.webpackChunk_tsparticles_plugin_poisson_disc=this.webpackChunk_tsparticles_plugin_poisson_disc||[]).push([[964],{964(s,i,e){e.d(i,{PoissonDiscPlugin:()=>o});var n=e(303);class t{dimensions;enable;radius;retries;steps;constructor(){this.enable=!1,this.dimensions=2,this.radius=0,this.retries=30,this.steps=0}load(s){(0,n.isNull)(s)||(void 0!==s.enable&&(this.enable=s.enable),void 0!==s.dimensions&&(this.dimensions=s.dimensions),void 0!==s.radius&&(this.radius=s.radius),void 0!==s.retries&&(this.retries=s.retries))}}class o{id="poisson";async getPlugin(s){let{PoissonDiscPluginInstance:i}=await e.e(960).then(e.bind(e,960));return new i(s)}loadOptions(s,i,e){if(!this.needsPlugin(i)&&!this.needsPlugin(e))return;let n=i.poisson;n?.load===void 0&&(i.poisson=n=new t),n.load(e?.poisson)}needsPlugin(s){return s?.poisson?.enable??!1}}}}]);

package/browser/Options/Classes/Poisson.js

@@ -1,5 +1,10 @@
 import { isNull } from "@tsparticles/engine";
 export class Poisson {
+    dimensions;
+    enable;
+    radius;
+    retries;
+    steps;
     constructor() {
         this.enable = false;
         this.dimensions = 2;

package/browser/PoissonDisc.js

@@ -1,5 +1,16 @@
 import { double, doublePI, getDistance, getRandom } from "@tsparticles/engine";
 export class PoissonDisc {
+    active;
+    cellSize;
+    cols;
+    dimensions;
+    firstPoint;
+    grid;
+    points;
+    radius;
+    retries;
+    rows;
+    size;
     constructor(size, radius, retries, dimensions, firstPoint) {
         this.size = { ...size };
         this.radius = radius;
@@ -62,18 +73,22 @@ export class PoissonDisc {
     }
     async run() {
         this.reset();
-        const minCount = 0, step = 1;
+        const minCount = 0, step = 1, yieldEvery = 100, yieldStepModule = 0;
+        let iterations = 0;
         while (this.active.length > minCount) {
-            await this.steps(step);
+            this.steps(step);
+            if (++iterations % yieldEvery === yieldStepModule) {
+                await new Promise(resolve => setTimeout(resolve));
+            }
         }
     }
-    async steps(steps) {
+    steps(steps) {
         const minCount = 0;
         for (let i = 0; i < steps; i++) {
             if (this.active.length <= minCount) {
                 continue;
             }
-            await this._step();
+            this._step();
         }
     }
     _getNewPoint(currentPoint, tries) {
@@ -87,78 +102,75 @@ export class PoissonDisc {
             x: Math.floor(newPoint.x / this.cellSize),
             y: Math.floor(newPoint.y / this.cellSize),
         };
-        if (newPoint.x > minCoordinate &&
-            newPoint.x < this.size.width &&
-            newPoint.y > minCoordinate &&
-            newPoint.y < this.size.height) {
-            const row = this.grid[newGridCoords.y];
-            if (!row) {
-                return;
-            }
-            const point = row[newGridCoords.x];
-            if (point === undefined) {
-                return;
-            }
-            if (point < gridMinValue) {
-                for (let i = -1; i <= maxNeighbourIndex; i++) {
-                    for (let j = -1; j <= maxNeighbourIndex; j++) {
-                        const neighbourGrid = {
-                            x: newGridCoords.x + j,
-                            y: newGridCoords.y + i,
-                        };
-                        if (neighbourGrid.x >= minCoordinate &&
-                            neighbourGrid.y >= minCoordinate &&
-                            neighbourGrid.x < this.cols &&
-                            neighbourGrid.y < this.rows &&
-                            (neighbourGrid.x !== newGridCoords.x || neighbourGrid.y !== newGridCoords.y)) {
-                            if (point >= gridMinValue) {
-                                const neighbourIndex = point, neighbour = this.points[neighbourIndex];
-                                if (!neighbour) {
-                                    continue;
-                                }
-                                const dist = getDistance(newPoint, neighbour.position);
-                                if (dist < this.radius) {
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                return;
-            }
+        if (newPoint.x <= minCoordinate ||
+            newPoint.x >= this.size.width ||
+            newPoint.y <= minCoordinate ||
+            newPoint.y >= this.size.height) {
+            return;
         }
-        else {
+        const row = this.grid[newGridCoords.y];
+        if (!row) {
             return;
         }
-        return newPoint;
-    }
-    async _step() {
-        const minCount = 0, randomActive = this.getRandom(minCount, this.active.length);
-        return new Promise(resolve => {
-            let foundNewPoint = false;
-            for (let tries = 0; tries < this.retries; tries++) {
-                const randomActivePointIndex = this.active[randomActive];
-                if (randomActivePointIndex === undefined) {
+        const cellValue = row[newGridCoords.x];
+        if (cellValue === undefined) {
+            return;
+        }
+        if (cellValue >= gridMinValue) {
+            return;
+        }
+        for (let i = -1; i <= maxNeighbourIndex; i++) {
+            for (let j = -1; j <= maxNeighbourIndex; j++) {
+                if (!i && !j) {
+                    continue;
+                }
+                const neighbourGrid = {
+                    x: newGridCoords.x + j,
+                    y: newGridCoords.y + i,
+                };
+                if (neighbourGrid.x < minCoordinate ||
+                    neighbourGrid.y < minCoordinate ||
+                    neighbourGrid.x >= this.cols ||
+                    neighbourGrid.y >= this.rows) {
+                    continue;
+                }
+                const neighbourCellValue = this.grid[neighbourGrid.y]?.[neighbourGrid.x];
+                if (neighbourCellValue === undefined || neighbourCellValue < gridMinValue) {
                     continue;
                 }
-                const point = this.points[randomActivePointIndex];
-                if (!point) {
+                const neighbour = this.points[neighbourCellValue];
+                if (!neighbour) {
                     continue;
                 }
-                const newPoint = this._getNewPoint(point, tries);
-                if (newPoint) {
-                    foundNewPoint = true;
-                    this.addPoint(newPoint);
-                    break;
+                if (getDistance(newPoint, neighbour.position) < this.radius) {
+                    return;
                 }
             }
-            if (!foundNewPoint) {
-                const deleteCount = 1;
-                this.active.splice(randomActive, deleteCount);
+        }
+        return newPoint;
+    }
+    _step() {
+        const minCount = 0, randomActive = this.getRandom(minCount, this.active.length);
+        let foundNewPoint = false;
+        for (let tries = 0; tries < this.retries; tries++) {
+            const randomActivePointIndex = this.active[randomActive];
+            if (randomActivePointIndex === undefined) {
+                continue;
+            }
+            const point = this.points[randomActivePointIndex];
+            if (!point) {
+                continue;
             }
-            resolve();
-        });
+            const newPoint = this._getNewPoint(point, tries);
+            if (newPoint) {
+                foundNewPoint = true;
+                this.addPoint(newPoint);
+                break;
+            }
+        }
+        if (!foundNewPoint) {
+            const deleteCount = 1;
+            this.active.splice(randomActive, deleteCount);
+        }
     }
 }

package/browser/PoissonDiscPlugin.js

@@ -1,8 +1,6 @@
 import { Poisson } from "./Options/Classes/Poisson.js";
 export class PoissonDiscPlugin {
-    constructor() {
-        this.id = "poisson";
-    }
+    id = "poisson";
     async getPlugin(container) {
         const { PoissonDiscPluginInstance } = await import("./PoissonDiscPluginInstance.js");
         return new PoissonDiscPluginInstance(container);

package/browser/PoissonDiscPluginInstance.js

@@ -1,6 +1,9 @@
 import { getRangeMax } from "@tsparticles/engine";
-import { PoissonDisc } from "./PoissonDisc.js";
 export class PoissonDiscPluginInstance {
+    poissonDisc;
+    redrawTimeout;
+    _container;
+    _currentIndex;
     constructor(container) {
         this._container = container;
         this._currentIndex = 0;
@@ -26,6 +29,9 @@ export class PoissonDiscPluginInstance {
         const timeout = 250;
         this.redrawTimeout = setTimeout(() => {
             void (async () => {
+                if (this._container.destroyed) {
+                    return;
+                }
                 await this._initData();
                 await container.particles.redraw();
             })();
@@ -40,12 +46,13 @@ export class PoissonDiscPluginInstance {
             return;
         }
         this._currentIndex = 0;
+        const { PoissonDisc } = await import("./PoissonDisc.js");
         this.poissonDisc = new PoissonDisc(canvasSize, poissonOptions.radius
             ? poissonOptions.radius * pixelRatio
             : Math.max(getRangeMax(particlesOptions.size.value) * pixelRatio, Math.sqrt((canvasSize.width * canvasSize.height) / particlesOptions.number.value)), poissonOptions.retries, poissonOptions.dimensions);
         const noSteps = 0;
         if (poissonOptions.steps > noSteps) {
-            await this.poissonDisc.steps(poissonOptions.steps);
+            this.poissonDisc.steps(poissonOptions.steps);
         }
         else {
             await this.poissonDisc.run();

package/browser/index.js

@@ -1,5 +1,5 @@
 export async function loadPoissonDiscPlugin(engine) {
-    engine.checkVersion("4.0.0-alpha.8");
+    engine.checkVersion("4.0.0-beta.0");
     await engine.register(async (e) => {
         const { PoissonDiscPlugin } = await import("./PoissonDiscPlugin.js");
         e.addPlugin(new PoissonDiscPlugin());

package/cjs/Options/Classes/Poisson.js

@@ -1,5 +1,10 @@
 import { isNull } from "@tsparticles/engine";
 export class Poisson {
+    dimensions;
+    enable;
+    radius;
+    retries;
+    steps;
     constructor() {
         this.enable = false;
         this.dimensions = 2;

package/cjs/PoissonDisc.js

@@ -1,5 +1,16 @@
 import { double, doublePI, getDistance, getRandom } from "@tsparticles/engine";
 export class PoissonDisc {
+    active;
+    cellSize;
+    cols;
+    dimensions;
+    firstPoint;
+    grid;
+    points;
+    radius;
+    retries;
+    rows;
+    size;
     constructor(size, radius, retries, dimensions, firstPoint) {
         this.size = { ...size };
         this.radius = radius;
@@ -62,18 +73,22 @@ export class PoissonDisc {
     }
     async run() {
         this.reset();
-        const minCount = 0, step = 1;
+        const minCount = 0, step = 1, yieldEvery = 100, yieldStepModule = 0;
+        let iterations = 0;
         while (this.active.length > minCount) {
-            await this.steps(step);
+            this.steps(step);
+            if (++iterations % yieldEvery === yieldStepModule) {
+                await new Promise(resolve => setTimeout(resolve));
+            }
         }
     }
-    async steps(steps) {
+    steps(steps) {
         const minCount = 0;
         for (let i = 0; i < steps; i++) {
             if (this.active.length <= minCount) {
                 continue;
             }
-            await this._step();
+            this._step();
         }
     }
     _getNewPoint(currentPoint, tries) {
@@ -87,78 +102,75 @@ export class PoissonDisc {
             x: Math.floor(newPoint.x / this.cellSize),
             y: Math.floor(newPoint.y / this.cellSize),
         };
-        if (newPoint.x > minCoordinate &&
-            newPoint.x < this.size.width &&
-            newPoint.y > minCoordinate &&
-            newPoint.y < this.size.height) {
-            const row = this.grid[newGridCoords.y];
-            if (!row) {
-                return;
-            }
-            const point = row[newGridCoords.x];
-            if (point === undefined) {
-                return;
-            }
-            if (point < gridMinValue) {
-                for (let i = -1; i <= maxNeighbourIndex; i++) {
-                    for (let j = -1; j <= maxNeighbourIndex; j++) {
-                        const neighbourGrid = {
-                            x: newGridCoords.x + j,
-                            y: newGridCoords.y + i,
-                        };
-                        if (neighbourGrid.x >= minCoordinate &&
-                            neighbourGrid.y >= minCoordinate &&
-                            neighbourGrid.x < this.cols &&
-                            neighbourGrid.y < this.rows &&
-                            (neighbourGrid.x !== newGridCoords.x || neighbourGrid.y !== newGridCoords.y)) {
-                            if (point >= gridMinValue) {
-                                const neighbourIndex = point, neighbour = this.points[neighbourIndex];
-                                if (!neighbour) {
-                                    continue;
-                                }
-                                const dist = getDistance(newPoint, neighbour.position);
-                                if (dist < this.radius) {
-                                    return;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            else {
-                return;
-            }
+        if (newPoint.x <= minCoordinate ||
+            newPoint.x >= this.size.width ||
+            newPoint.y <= minCoordinate ||
+            newPoint.y >= this.size.height) {
+            return;
         }
-        else {
+        const row = this.grid[newGridCoords.y];
+        if (!row) {
             return;
         }
-        return newPoint;
-    }
-    async _step() {
-        const minCount = 0, randomActive = this.getRandom(minCount, this.active.length);
-        return new Promise(resolve => {
-            let foundNewPoint = false;
-            for (let tries = 0; tries < this.retries; tries++) {
-                const randomActivePointIndex = this.active[randomActive];
-                if (randomActivePointIndex === undefined) {
+        const cellValue = row[newGridCoords.x];
+        if (cellValue === undefined) {
+            return;
+        }
+        if (cellValue >= gridMinValue) {
+            return;
+        }
+        for (let i = -1; i <= maxNeighbourIndex; i++) {
+            for (let j = -1; j <= maxNeighbourIndex; j++) {
+                if (!i && !j) {
+                    continue;
+                }
+                const neighbourGrid = {
+                    x: newGridCoords.x + j,
+                    y: newGridCoords.y + i,
+                };
+                if (neighbourGrid.x < minCoordinate ||
+                    neighbourGrid.y < minCoordinate ||
+                    neighbourGrid.x >= this.cols ||
+                    neighbourGrid.y >= this.rows) {
+                    continue;
+                }
+                const neighbourCellValue = this.grid[neighbourGrid.y]?.[neighbourGrid.x];
+                if (neighbourCellValue === undefined || neighbourCellValue < gridMinValue) {
                     continue;
                 }
-                const point = this.points[randomActivePointIndex];
-                if (!point) {
+                const neighbour = this.points[neighbourCellValue];
+                if (!neighbour) {
                     continue;
                 }
-                const newPoint = this._getNewPoint(point, tries);
-                if (newPoint) {
-                    foundNewPoint = true;
-                    this.addPoint(newPoint);
-                    break;
+                if (getDistance(newPoint, neighbour.position) < this.radius) {
+                    return;
                 }
             }
-            if (!foundNewPoint) {
-                const deleteCount = 1;
-                this.active.splice(randomActive, deleteCount);
+        }
+        return newPoint;
+    }
+    _step() {
+        const minCount = 0, randomActive = this.getRandom(minCount, this.active.length);
+        let foundNewPoint = false;
+        for (let tries = 0; tries < this.retries; tries++) {
+            const randomActivePointIndex = this.active[randomActive];
+            if (randomActivePointIndex === undefined) {
+                continue;
+            }
+            const point = this.points[randomActivePointIndex];
+            if (!point) {
+                continue;
             }
-            resolve();
-        });
+            const newPoint = this._getNewPoint(point, tries);
+            if (newPoint) {
+                foundNewPoint = true;
+                this.addPoint(newPoint);
+                break;
+            }
+        }
+        if (!foundNewPoint) {
+            const deleteCount = 1;
+            this.active.splice(randomActive, deleteCount);
+        }
     }
 }

package/cjs/PoissonDiscPlugin.js

@@ -1,8 +1,6 @@
 import { Poisson } from "./Options/Classes/Poisson.js";
 export class PoissonDiscPlugin {
-    constructor() {
-        this.id = "poisson";
-    }
+    id = "poisson";
     async getPlugin(container) {
         const { PoissonDiscPluginInstance } = await import("./PoissonDiscPluginInstance.js");
         return new PoissonDiscPluginInstance(container);

package/cjs/PoissonDiscPluginInstance.js

@@ -1,6 +1,9 @@
 import { getRangeMax } from "@tsparticles/engine";
-import { PoissonDisc } from "./PoissonDisc.js";
 export class PoissonDiscPluginInstance {
+    poissonDisc;
+    redrawTimeout;
+    _container;
+    _currentIndex;
     constructor(container) {
         this._container = container;
         this._currentIndex = 0;
@@ -26,6 +29,9 @@ export class PoissonDiscPluginInstance {
         const timeout = 250;
         this.redrawTimeout = setTimeout(() => {
             void (async () => {
+                if (this._container.destroyed) {
+                    return;
+                }
                 await this._initData();
                 await container.particles.redraw();
             })();
@@ -40,12 +46,13 @@ export class PoissonDiscPluginInstance {
             return;
         }
         this._currentIndex = 0;
+        const { PoissonDisc } = await import("./PoissonDisc.js");
         this.poissonDisc = new PoissonDisc(canvasSize, poissonOptions.radius
             ? poissonOptions.radius * pixelRatio
             : Math.max(getRangeMax(particlesOptions.size.value) * pixelRatio, Math.sqrt((canvasSize.width * canvasSize.height) / particlesOptions.number.value)), poissonOptions.retries, poissonOptions.dimensions);
         const noSteps = 0;
         if (poissonOptions.steps > noSteps) {
-            await this.poissonDisc.steps(poissonOptions.steps);
+            this.poissonDisc.steps(poissonOptions.steps);
         }
         else {
             await this.poissonDisc.run();

package/cjs/index.js

@@ -1,5 +1,5 @@
 export async function loadPoissonDiscPlugin(engine) {
-    engine.checkVersion("4.0.0-alpha.8");
+    engine.checkVersion("4.0.0-beta.0");
     await engine.register(async (e) => {
         const { PoissonDiscPlugin } = await import("./PoissonDiscPlugin.js");
         e.addPlugin(new PoissonDiscPlugin());

package/dist_browser_PoissonDiscPluginInstance_js.js

@@ -4,7 +4,7 @@
  * Demo / Generator : https://particles.js.org/
  * GitHub : https://www.github.com/matteobruni/tsparticles
  * How to use? : Check the GitHub README
- * v4.0.0-alpha.8
+ * v4.0.0-beta.0
  */
 "use strict";
 /*
@@ -17,23 +17,13 @@
  */
 (this["webpackChunk_tsparticles_plugin_poisson_disc"] = this["webpackChunk_tsparticles_plugin_poisson_disc"] || []).push([["dist_browser_PoissonDiscPluginInstance_js"],{
 
-/***/ "./dist/browser/PoissonDisc.js"
-/*!*************************************!*\
-  !*** ./dist/browser/PoissonDisc.js ***!
-  \*************************************/
-(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
-
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   PoissonDisc: () => (/* binding */ PoissonDisc)\n/* harmony export */ });\n/* harmony import */ var _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @tsparticles/engine */ \"@tsparticles/engine\");\n\nclass PoissonDisc {\n  constructor(size, radius, retries, dimensions, firstPoint) {\n    this.size = {\n      ...size\n    };\n    this.radius = radius;\n    this.retries = retries;\n    this.dimensions = dimensions;\n    this.cellSize = Math.floor(this.radius / Math.sqrt(this.dimensions));\n    this.cols = Math.floor(this.size.width / this.cellSize);\n    this.rows = Math.floor(this.size.height / this.cellSize);\n    this.points = [];\n    this.active = [];\n    this.grid = [];\n    this.firstPoint = firstPoint ? {\n      ...firstPoint\n    } : undefined;\n    this.reset();\n  }\n  addPoint(inputPoint) {\n    const point = {\n        position: {\n          ...inputPoint\n        },\n        gridPosition: {\n          x: Math.floor(inputPoint.x / this.cellSize),\n          y: Math.floor(inputPoint.y / this.cellSize)\n        }\n      },\n      pointIndex = this.points.length,\n      row = this.grid[point.gridPosition.y];\n    if (!row) {\n      return;\n    }\n    this.points.push(point);\n    row[point.gridPosition.x] = pointIndex;\n    this.active.push(pointIndex);\n  }\n  getRandom(min, max) {\n    return Math.floor((0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.getRandom)() * (max - min)) + min;\n  }\n  initialiseGrid() {\n    for (let y = 0; y <= this.rows; y++) {\n      this.grid[y] = [];\n      const row = this.grid[y];\n      if (!row) {\n        continue;\n      }\n      for (let x = 0; x <= this.cols; x++) {\n        row[x] = -1;\n      }\n    }\n  }\n  reset() {\n    this.points = [];\n    this.active = [];\n    this.grid = [];\n    this.initialiseGrid();\n    if (this.firstPoint) {\n      this.addPoint(this.firstPoint);\n    } else {\n      const minCoordinate = 0;\n      this.addPoint({\n        x: this.getRandom(minCoordinate, this.size.width),\n        y: this.getRandom(minCoordinate, this.size.height)\n      });\n    }\n  }\n  async run() {\n    this.reset();\n    const minCount = 0,\n      step = 1;\n    while (this.active.length > minCount) {\n      await this.steps(step);\n    }\n  }\n  async steps(steps) {\n    const minCount = 0;\n    for (let i = 0; i < steps; i++) {\n      if (this.active.length <= minCount) {\n        continue;\n      }\n      await this._step();\n    }\n  }\n  _getNewPoint(currentPoint, tries) {\n    const minCoordinate = 0,\n      gridMinValue = 0,\n      maxNeighbourIndex = 1,\n      newAngle = tries * (_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.doublePI / this.retries),\n      newDist = this.getRandom(this.radius, this.radius * _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.double),\n      offset = {\n        x: Math.cos(newAngle) * newDist,\n        y: Math.sin(newAngle) * newDist\n      },\n      newPoint = {\n        x: Math.floor(currentPoint.position.x + offset.x),\n        y: Math.floor(currentPoint.position.y + offset.y)\n      },\n      newGridCoords = {\n        x: Math.floor(newPoint.x / this.cellSize),\n        y: Math.floor(newPoint.y / this.cellSize)\n      };\n    if (newPoint.x > minCoordinate && newPoint.x < this.size.width && newPoint.y > minCoordinate && newPoint.y < this.size.height) {\n      const row = this.grid[newGridCoords.y];\n      if (!row) {\n        return;\n      }\n      const point = row[newGridCoords.x];\n      if (point === undefined) {\n        return;\n      }\n      if (point < gridMinValue) {\n        for (let i = -1; i <= maxNeighbourIndex; i++) {\n          for (let j = -1; j <= maxNeighbourIndex; j++) {\n            const neighbourGrid = {\n              x: newGridCoords.x + j,\n              y: newGridCoords.y + i\n            };\n            if (neighbourGrid.x >= minCoordinate && neighbourGrid.y >= minCoordinate && neighbourGrid.x < this.cols && neighbourGrid.y < this.rows && (neighbourGrid.x !== newGridCoords.x || neighbourGrid.y !== newGridCoords.y)) {\n              if (point >= gridMinValue) {\n                const neighbourIndex = point,\n                  neighbour = this.points[neighbourIndex];\n                if (!neighbour) {\n                  continue;\n                }\n                const dist = (0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.getDistance)(newPoint, neighbour.position);\n                if (dist < this.radius) {\n                  return;\n                }\n              }\n            }\n          }\n        }\n      } else {\n        return;\n      }\n    } else {\n      return;\n    }\n    return newPoint;\n  }\n  async _step() {\n    const minCount = 0,\n      randomActive = this.getRandom(minCount, this.active.length);\n    return new Promise(resolve => {\n      let foundNewPoint = false;\n      for (let tries = 0; tries < this.retries; tries++) {\n        const randomActivePointIndex = this.active[randomActive];\n        if (randomActivePointIndex === undefined) {\n          continue;\n        }\n        const point = this.points[randomActivePointIndex];\n        if (!point) {\n          continue;\n        }\n        const newPoint = this._getNewPoint(point, tries);\n        if (newPoint) {\n          foundNewPoint = true;\n          this.addPoint(newPoint);\n          break;\n        }\n      }\n      if (!foundNewPoint) {\n        const deleteCount = 1;\n        this.active.splice(randomActive, deleteCount);\n      }\n      resolve();\n    });\n  }\n}\n\n//# sourceURL=webpack://@tsparticles/plugin-poisson-disc/./dist/browser/PoissonDisc.js?\n}");
-
-/***/ },
-
 /***/ "./dist/browser/PoissonDiscPluginInstance.js"
 /*!***************************************************!*\
   !*** ./dist/browser/PoissonDiscPluginInstance.js ***!
   \***************************************************/
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   PoissonDiscPluginInstance: () => (/* binding */ PoissonDiscPluginInstance)\n/* harmony export */ });\n/* harmony import */ var _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @tsparticles/engine */ \"@tsparticles/engine\");\n/* harmony import */ var _PoissonDisc_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./PoissonDisc.js */ \"./dist/browser/PoissonDisc.js\");\n\n\nclass PoissonDiscPluginInstance {\n  constructor(container) {\n    this._container = container;\n    this._currentIndex = 0;\n  }\n  async init() {\n    await this._initData();\n  }\n  particlePosition(position) {\n    const container = this._container,\n      options = container.actualOptions.poisson;\n    if (!this.poissonDisc || !(options?.enable ?? false) || this._currentIndex >= this.poissonDisc.points.length) {\n      return;\n    }\n    return position ?? this.poissonDisc.points[this._currentIndex++]?.position;\n  }\n  resize() {\n    const container = this._container,\n      options = container.actualOptions.poisson;\n    if (!(options?.enable ?? false)) {\n      return;\n    }\n    if (this.redrawTimeout) {\n      clearTimeout(this.redrawTimeout);\n    }\n    const timeout = 250;\n    this.redrawTimeout = setTimeout(() => {\n      void (async () => {\n        await this._initData();\n        await container.particles.redraw();\n      })();\n    }, timeout);\n  }\n  stop() {\n    delete this.poissonDisc;\n  }\n  async _initData() {\n    const container = this._container,\n      poissonOptions = container.actualOptions.poisson,\n      particlesOptions = container.actualOptions.particles,\n      canvasSize = container.canvas.size,\n      pixelRatio = container.retina.pixelRatio;\n    if (!poissonOptions?.enable) {\n      return;\n    }\n    this._currentIndex = 0;\n    this.poissonDisc = new _PoissonDisc_js__WEBPACK_IMPORTED_MODULE_1__.PoissonDisc(canvasSize, poissonOptions.radius ? poissonOptions.radius * pixelRatio : Math.max((0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.getRangeMax)(particlesOptions.size.value) * pixelRatio, Math.sqrt(canvasSize.width * canvasSize.height / particlesOptions.number.value)), poissonOptions.retries, poissonOptions.dimensions);\n    const noSteps = 0;\n    if (poissonOptions.steps > noSteps) {\n      await this.poissonDisc.steps(poissonOptions.steps);\n    } else {\n      await this.poissonDisc.run();\n    }\n  }\n}\n\n//# sourceURL=webpack://@tsparticles/plugin-poisson-disc/./dist/browser/PoissonDiscPluginInstance.js?\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   PoissonDiscPluginInstance: () => (/* binding */ PoissonDiscPluginInstance)\n/* harmony export */ });\n/* harmony import */ var _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @tsparticles/engine */ \"@tsparticles/engine\");\n\nclass PoissonDiscPluginInstance {\n    poissonDisc;\n    redrawTimeout;\n    _container;\n    _currentIndex;\n    constructor(container){\n        this._container = container;\n        this._currentIndex = 0;\n    }\n    async init() {\n        await this._initData();\n    }\n    particlePosition(position) {\n        const container = this._container, options = container.actualOptions.poisson;\n        if (!this.poissonDisc || !(options?.enable ?? false) || this._currentIndex >= this.poissonDisc.points.length) {\n            return;\n        }\n        return position ?? this.poissonDisc.points[this._currentIndex++]?.position;\n    }\n    resize() {\n        const container = this._container, options = container.actualOptions.poisson;\n        if (!(options?.enable ?? false)) {\n            return;\n        }\n        if (this.redrawTimeout) {\n            clearTimeout(this.redrawTimeout);\n        }\n        const timeout = 250;\n        this.redrawTimeout = setTimeout(()=>{\n            void (async ()=>{\n                if (this._container.destroyed) {\n                    return;\n                }\n                await this._initData();\n                await container.particles.redraw();\n            })();\n        }, timeout);\n    }\n    stop() {\n        delete this.poissonDisc;\n    }\n    async _initData() {\n        const container = this._container, poissonOptions = container.actualOptions.poisson, particlesOptions = container.actualOptions.particles, canvasSize = container.canvas.size, pixelRatio = container.retina.pixelRatio;\n        if (!poissonOptions?.enable) {\n            return;\n        }\n        this._currentIndex = 0;\n        const { PoissonDisc } = await __webpack_require__.e(/*! import() */ \"dist_browser_PoissonDisc_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./PoissonDisc.js */ \"./dist/browser/PoissonDisc.js\"));\n        this.poissonDisc = new PoissonDisc(canvasSize, poissonOptions.radius ? poissonOptions.radius * pixelRatio : Math.max((0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.getRangeMax)(particlesOptions.size.value) * pixelRatio, Math.sqrt(canvasSize.width * canvasSize.height / particlesOptions.number.value)), poissonOptions.retries, poissonOptions.dimensions);\n        const noSteps = 0;\n        if (poissonOptions.steps > noSteps) {\n            this.poissonDisc.steps(poissonOptions.steps);\n        } else {\n            await this.poissonDisc.run();\n        }\n    }\n}\n\n\n//# sourceURL=webpack://@tsparticles/plugin-poisson-disc/./dist/browser/PoissonDiscPluginInstance.js?\n}");
 
 /***/ }
 

package/dist_browser_PoissonDiscPlugin_js.js

@@ -4,7 +4,7 @@
  * Demo / Generator : https://particles.js.org/
  * GitHub : https://www.github.com/matteobruni/tsparticles
  * How to use? : Check the GitHub README
- * v4.0.0-alpha.8
+ * v4.0.0-beta.0
  */
 "use strict";
 /*
@@ -23,7 +23,7 @@
   \*************************************************/
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   Poisson: () => (/* binding */ Poisson)\n/* harmony export */ });\n/* harmony import */ var _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @tsparticles/engine */ \"@tsparticles/engine\");\n\nclass Poisson {\n  constructor() {\n    this.enable = false;\n    this.dimensions = 2;\n    this.radius = 0;\n    this.retries = 30;\n    this.steps = 0;\n  }\n  load(data) {\n    if ((0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.isNull)(data)) {\n      return;\n    }\n    if (data.enable !== undefined) {\n      this.enable = data.enable;\n    }\n    if (data.dimensions !== undefined) {\n      this.dimensions = data.dimensions;\n    }\n    if (data.radius !== undefined) {\n      this.radius = data.radius;\n    }\n    if (data.retries !== undefined) {\n      this.retries = data.retries;\n    }\n  }\n}\n\n//# sourceURL=webpack://@tsparticles/plugin-poisson-disc/./dist/browser/Options/Classes/Poisson.js?\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   Poisson: () => (/* binding */ Poisson)\n/* harmony export */ });\n/* harmony import */ var _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @tsparticles/engine */ \"@tsparticles/engine\");\n\nclass Poisson {\n    dimensions;\n    enable;\n    radius;\n    retries;\n    steps;\n    constructor(){\n        this.enable = false;\n        this.dimensions = 2;\n        this.radius = 0;\n        this.retries = 30;\n        this.steps = 0;\n    }\n    load(data) {\n        if ((0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.isNull)(data)) {\n            return;\n        }\n        if (data.enable !== undefined) {\n            this.enable = data.enable;\n        }\n        if (data.dimensions !== undefined) {\n            this.dimensions = data.dimensions;\n        }\n        if (data.radius !== undefined) {\n            this.radius = data.radius;\n        }\n        if (data.retries !== undefined) {\n            this.retries = data.retries;\n        }\n    }\n}\n\n\n//# sourceURL=webpack://@tsparticles/plugin-poisson-disc/./dist/browser/Options/Classes/Poisson.js?\n}");
 
 /***/ },
 
@@ -33,7 +33,7 @@ eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpa
   \*******************************************/
 (__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   PoissonDiscPlugin: () => (/* binding */ PoissonDiscPlugin)\n/* harmony export */ });\n/* harmony import */ var _Options_Classes_Poisson_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Options/Classes/Poisson.js */ \"./dist/browser/Options/Classes/Poisson.js\");\n\nclass PoissonDiscPlugin {\n  constructor() {\n    this.id = \"poisson\";\n  }\n  async getPlugin(container) {\n    const {\n      PoissonDiscPluginInstance\n    } = await __webpack_require__.e(/*! import() */ \"dist_browser_PoissonDiscPluginInstance_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./PoissonDiscPluginInstance.js */ \"./dist/browser/PoissonDiscPluginInstance.js\"));\n    return new PoissonDiscPluginInstance(container);\n  }\n  loadOptions(_container, options, source) {\n    if (!this.needsPlugin(options) && !this.needsPlugin(source)) {\n      return;\n    }\n    let poissonOptions = options.poisson;\n    if (poissonOptions?.load === undefined) {\n      options.poisson = poissonOptions = new _Options_Classes_Poisson_js__WEBPACK_IMPORTED_MODULE_0__.Poisson();\n    }\n    poissonOptions.load(source?.poisson);\n  }\n  needsPlugin(options) {\n    return options?.poisson?.enable ?? false;\n  }\n}\n\n//# sourceURL=webpack://@tsparticles/plugin-poisson-disc/./dist/browser/PoissonDiscPlugin.js?\n}");
+eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   PoissonDiscPlugin: () => (/* binding */ PoissonDiscPlugin)\n/* harmony export */ });\n/* harmony import */ var _Options_Classes_Poisson_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Options/Classes/Poisson.js */ \"./dist/browser/Options/Classes/Poisson.js\");\n\nclass PoissonDiscPlugin {\n    id = \"poisson\";\n    async getPlugin(container) {\n        const { PoissonDiscPluginInstance } = await __webpack_require__.e(/*! import() */ \"dist_browser_PoissonDiscPluginInstance_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./PoissonDiscPluginInstance.js */ \"./dist/browser/PoissonDiscPluginInstance.js\"));\n        return new PoissonDiscPluginInstance(container);\n    }\n    loadOptions(_container, options, source) {\n        if (!this.needsPlugin(options) && !this.needsPlugin(source)) {\n            return;\n        }\n        let poissonOptions = options.poisson;\n        if (poissonOptions?.load === undefined) {\n            options.poisson = poissonOptions = new _Options_Classes_Poisson_js__WEBPACK_IMPORTED_MODULE_0__.Poisson();\n        }\n        poissonOptions.load(source?.poisson);\n    }\n    needsPlugin(options) {\n        return options?.poisson?.enable ?? false;\n    }\n}\n\n\n//# sourceURL=webpack://@tsparticles/plugin-poisson-disc/./dist/browser/PoissonDiscPlugin.js?\n}");
 
 /***/ }