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

package/295.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see 295.min.js.LICENSE.txt */
+(this.webpackChunk_tsparticles_plugin_poisson_disc=this.webpackChunk_tsparticles_plugin_poisson_disc||[]).push([[295],{295(i,s,t){t.d(s,{PoissonDiscPlugin:()=>a});var e=t(303);class o{constructor(){this.enable=!1,this.dimensions=2,this.radius=0,this.retries=30,this.steps=0}load(i){(0,e.isNull)(i)||(void 0!==i.enable&&(this.enable=i.enable),void 0!==i.dimensions&&(this.dimensions=i.dimensions),void 0!==i.radius&&(this.radius=i.radius),void 0!==i.retries&&(this.retries=i.retries))}}const n=2*Math.PI;class h{constructor(i,s,t,e,o){this.size={...i},this.radius=s,this.retries=t,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=o?{...o}:void 0,this.reset()}addPoint(i){const s={position:{...i},gridPosition:{x:Math.floor(i.x/this.cellSize),y:Math.floor(i.y/this.cellSize)}},t=this.points.length,e=this.grid[s.gridPosition.y];e&&(this.points.push(s),e[s.gridPosition.x]=t,this.active.push(t))}getRandom(i,s){return Math.floor((0,e.getRandom)()*(s-i))+i}initialiseGrid(){for(let i=0;i<=this.rows;i++){this.grid[i]=[];const s=this.grid[i];if(s)for(let i=0;i<=this.cols;i++)s[i]=-1}}reset(){if(this.points=[],this.active=[],this.grid=[],this.initialiseGrid(),this.firstPoint)this.addPoint(this.firstPoint);else{const i=0;this.addPoint({x:this.getRandom(i,this.size.width),y:this.getRandom(i,this.size.height)})}}async run(){this.reset();for(;this.active.length>0;)await this.steps(1)}async steps(i){for(let s=0;s<i;s++)this.active.length<=0||await this._step()}_getNewPoint(i,s){const t=s*(n/this.retries),o=this.getRandom(this.radius,2*this.radius),h=Math.cos(t)*o,r=Math.sin(t)*o,a={x:Math.floor(i.position.x+h),y:Math.floor(i.position.y+r)},c=Math.floor(a.x/this.cellSize),l=Math.floor(a.y/this.cellSize);if(a.x>0&&a.x<this.size.width&&a.y>0&&a.y<this.size.height){{const i=this.grid[l];if(!i)return;const s=i[c];if(void 0===s)return;if(!(s<0))return;for(let i=-1;i<=1;i++)for(let t=-1;t<=1;t++){const o={x:c+t,y:l+i};if(o.x>=0&&o.y>=0&&o.x<this.cols&&o.y<this.rows&&(o.x!==c||o.y!==l)&&s>=0){const i=s,t=this.points[i];if(!t)continue;if((0,e.getDistance)(a,t.position)<this.radius)return}}}return a}}async _step(){const i=this.getRandom(0,this.active.length);return new Promise((s=>{let t=!1;for(let s=0;s<this.retries;s++){const e=this.active[i];if(void 0===e)continue;const o=this.points[e];if(!o)continue;const n=this._getNewPoint(o,s);if(n){t=!0,this.addPoint(n);break}}if(!t){const s=1;this.active.splice(i,s)}s()}))}}class r{constructor(i){this._container=i,this._currentIndex=0}async init(){await this._initData()}particlePosition(i){const 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(){const i=this._container,s=i.actualOptions.poisson;if(!s?.enable)return;this.redrawTimeout&&clearTimeout(this.redrawTimeout);this.redrawTimeout=setTimeout((()=>{(async()=>{await this._initData(),await i.particles.redraw()})()}),250)}stop(){delete this.poissonDisc}async _initData(){const i=this._container,s=i.actualOptions.poisson,t=i.actualOptions.particles,o=i.canvas.size,n=i.retina.pixelRatio;if(!s?.enable)return;this._currentIndex=0,this.poissonDisc=new h(o,s.radius?s.radius*n:Math.max((0,e.getRangeMax)(t.size.value)*n,Math.sqrt(o.width*o.height/t.number.value)),s.retries,s.dimensions);s.steps>0?await this.poissonDisc.steps(s.steps):await this.poissonDisc.run()}}class a{constructor(){this.id="poisson"}getPlugin(i){return Promise.resolve(new r(i))}loadOptions(i,s){if(!this.needsPlugin(i)&&!this.needsPlugin(s))return;let t=i.poisson;void 0===t?.load&&(i.poisson=t=new o),t.load(s?.poisson)}needsPlugin(i){return i?.poisson?.enable??!1}}}}]);

package/295.min.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! tsParticles Poisson Disc Plugin v4.0.0-alpha.0 by Matteo Bruni */

package/browser/PoissonDisc.js

@@ -22,9 +22,12 @@ export class PoissonDisc {
                 x: Math.floor(inputPoint.x / this.cellSize),
                 y: Math.floor(inputPoint.y / this.cellSize),
             },
-        }, pointIndex = this.points.length;
+        }, pointIndex = this.points.length, row = this.grid[point.gridPosition.y];
+        if (!row) {
+            return;
+        }
         this.points.push(point);
-        this.grid[point.gridPosition.y][point.gridPosition.x] = pointIndex;
+        row[point.gridPosition.x] = pointIndex;
         this.active.push(pointIndex);
     }
     getRandom(min, max) {
@@ -33,8 +36,12 @@ export class PoissonDisc {
     initialiseGrid() {
         for (let y = 0; y <= this.rows; y++) {
             this.grid[y] = [];
+            const row = this.grid[y];
+            if (!row) {
+                continue;
+            }
             for (let x = 0; x <= this.cols; x++) {
-                this.grid[y][x] = -1;
+                row[x] = -1;
             }
         }
     }
@@ -85,7 +92,15 @@ export class PoissonDisc {
             newPoint.x < this.size.width &&
             newPoint.y > minCoordinate &&
             newPoint.y < this.size.height) {
-            if (this.grid[newGridCoords.y][newGridCoords.x] < gridMinValue) {
+            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 = {
@@ -97,8 +112,12 @@ export class PoissonDisc {
                             neighbourGrid.x < this.cols &&
                             neighbourGrid.y < this.rows &&
                             (neighbourGrid.x !== newGridCoords.x || neighbourGrid.y !== newGridCoords.y)) {
-                            if (this.grid[neighbourGrid.y][neighbourGrid.x] >= gridMinValue) {
-                                const neighbourIndex = this.grid[neighbourGrid.y][neighbourGrid.x], neighbour = this.points[neighbourIndex], dist = getDistance(newPoint, neighbour.position);
+                            if (point >= gridMinValue) {
+                                const neighbourIndex = point, neighbour = this.points[neighbourIndex];
+                                if (!neighbour) {
+                                    continue;
+                                }
+                                const dist = getDistance(newPoint, neighbour.position);
                                 if (dist < this.radius) {
                                     return;
                                 }
@@ -121,7 +140,15 @@ export class PoissonDisc {
         return new Promise(resolve => {
             let foundNewPoint = false;
             for (let tries = 0; tries < this.retries; tries++) {
-                const newPoint = this._getNewPoint(this.points[this.active[randomActive]], tries);
+                const randomActivePointIndex = this.active[randomActive];
+                if (randomActivePointIndex === undefined) {
+                    continue;
+                }
+                const point = this.points[randomActivePointIndex];
+                if (!point) {
+                    continue;
+                }
+                const newPoint = this._getNewPoint(point, tries);
                 if (newPoint) {
                     foundNewPoint = true;
                     this.addPoint(newPoint);

package/browser/PoissonDiscPlugin.js

@@ -1,12 +1,11 @@
 import { Poisson } from "./Options/Classes/Poisson.js";
 import { PoissonInstance } from "./PoissonInstance.js";
 export class PoissonDiscPlugin {
-    constructor(engine) {
+    constructor() {
         this.id = "poisson";
-        this._engine = engine;
     }
     getPlugin(container) {
-        return Promise.resolve(new PoissonInstance(container, this._engine));
+        return Promise.resolve(new PoissonInstance(container));
     }
     loadOptions(options, source) {
         if (!this.needsPlugin(options) && !this.needsPlugin(source)) {

package/browser/PoissonInstance.js

@@ -1,9 +1,8 @@
 import { getRangeMax } from "@tsparticles/engine";
 import { PoissonDisc } from "./PoissonDisc.js";
 export class PoissonInstance {
-    constructor(container, engine) {
+    constructor(container) {
         this._container = container;
-        this._engine = engine;
         this._currentIndex = 0;
     }
     async init() {
@@ -14,7 +13,7 @@ export class PoissonInstance {
         if (!this.poissonDisc || !(options?.enable ?? false) || this._currentIndex >= this.poissonDisc.points.length) {
             return;
         }
-        return position ?? this.poissonDisc?.points[this._currentIndex++]?.position;
+        return position ?? this.poissonDisc.points[this._currentIndex++]?.position;
     }
     resize() {
         const container = this._container, options = container.actualOptions.poisson;

package/browser/index.js

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

package/cjs/Interfaces/IPoissonPoint.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/cjs/Options/Classes/Poisson.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Poisson = void 0;
-const engine_1 = require("@tsparticles/engine");
-class Poisson {
+import { isNull } from "@tsparticles/engine";
+export class Poisson {
     constructor() {
         this.enable = false;
         this.dimensions = 2;
@@ -11,7 +8,7 @@ class Poisson {
         this.steps = 0;
     }
     load(data) {
-        if ((0, engine_1.isNull)(data)) {
+        if (isNull(data)) {
             return;
         }
         if (data.enable !== undefined) {
@@ -28,4 +25,3 @@ class Poisson {
         }
     }
 }
-exports.Poisson = Poisson;

package/cjs/Options/Interfaces/IPoisson.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/cjs/PoissonDisc.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PoissonDisc = void 0;
-const engine_1 = require("@tsparticles/engine");
+import { getDistance, getRandom } from "@tsparticles/engine";
 const double = 2, doublePI = Math.PI * double;
-class PoissonDisc {
+export class PoissonDisc {
     constructor(size, radius, retries, dimensions, firstPoint) {
         this.size = { ...size };
         this.radius = radius;
@@ -25,19 +22,26 @@ class PoissonDisc {
                 x: Math.floor(inputPoint.x / this.cellSize),
                 y: Math.floor(inputPoint.y / this.cellSize),
             },
-        }, pointIndex = this.points.length;
+        }, pointIndex = this.points.length, row = this.grid[point.gridPosition.y];
+        if (!row) {
+            return;
+        }
         this.points.push(point);
-        this.grid[point.gridPosition.y][point.gridPosition.x] = pointIndex;
+        row[point.gridPosition.x] = pointIndex;
         this.active.push(pointIndex);
     }
     getRandom(min, max) {
-        return Math.floor((0, engine_1.getRandom)() * (max - min)) + min;
+        return Math.floor(getRandom() * (max - min)) + min;
     }
     initialiseGrid() {
         for (let y = 0; y <= this.rows; y++) {
             this.grid[y] = [];
+            const row = this.grid[y];
+            if (!row) {
+                continue;
+            }
             for (let x = 0; x <= this.cols; x++) {
-                this.grid[y][x] = -1;
+                row[x] = -1;
             }
         }
     }
@@ -88,7 +92,15 @@ class PoissonDisc {
             newPoint.x < this.size.width &&
             newPoint.y > minCoordinate &&
             newPoint.y < this.size.height) {
-            if (this.grid[newGridCoords.y][newGridCoords.x] < gridMinValue) {
+            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 = {
@@ -100,8 +112,12 @@ class PoissonDisc {
                             neighbourGrid.x < this.cols &&
                             neighbourGrid.y < this.rows &&
                             (neighbourGrid.x !== newGridCoords.x || neighbourGrid.y !== newGridCoords.y)) {
-                            if (this.grid[neighbourGrid.y][neighbourGrid.x] >= gridMinValue) {
-                                const neighbourIndex = this.grid[neighbourGrid.y][neighbourGrid.x], neighbour = this.points[neighbourIndex], dist = (0, engine_1.getDistance)(newPoint, neighbour.position);
+                            if (point >= gridMinValue) {
+                                const neighbourIndex = point, neighbour = this.points[neighbourIndex];
+                                if (!neighbour) {
+                                    continue;
+                                }
+                                const dist = getDistance(newPoint, neighbour.position);
                                 if (dist < this.radius) {
                                     return;
                                 }
@@ -124,7 +140,15 @@ class PoissonDisc {
         return new Promise(resolve => {
             let foundNewPoint = false;
             for (let tries = 0; tries < this.retries; tries++) {
-                const newPoint = this._getNewPoint(this.points[this.active[randomActive]], tries);
+                const randomActivePointIndex = this.active[randomActive];
+                if (randomActivePointIndex === undefined) {
+                    continue;
+                }
+                const point = this.points[randomActivePointIndex];
+                if (!point) {
+                    continue;
+                }
+                const newPoint = this._getNewPoint(point, tries);
                 if (newPoint) {
                     foundNewPoint = true;
                     this.addPoint(newPoint);
@@ -139,4 +163,3 @@ class PoissonDisc {
         });
     }
 }
-exports.PoissonDisc = PoissonDisc;

package/cjs/PoissonDiscPlugin.js

@@ -1,15 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PoissonDiscPlugin = void 0;
-const Poisson_js_1 = require("./Options/Classes/Poisson.js");
-const PoissonInstance_js_1 = require("./PoissonInstance.js");
-class PoissonDiscPlugin {
-    constructor(engine) {
+import { Poisson } from "./Options/Classes/Poisson.js";
+import { PoissonInstance } from "./PoissonInstance.js";
+export class PoissonDiscPlugin {
+    constructor() {
         this.id = "poisson";
-        this._engine = engine;
     }
     getPlugin(container) {
-        return Promise.resolve(new PoissonInstance_js_1.PoissonInstance(container, this._engine));
+        return Promise.resolve(new PoissonInstance(container));
     }
     loadOptions(options, source) {
         if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
@@ -17,7 +13,7 @@ class PoissonDiscPlugin {
         }
         let poissonOptions = options.poisson;
         if (poissonOptions?.load === undefined) {
-            options.poisson = poissonOptions = new Poisson_js_1.Poisson();
+            options.poisson = poissonOptions = new Poisson();
         }
         poissonOptions.load(source?.poisson);
     }
@@ -25,4 +21,3 @@ class PoissonDiscPlugin {
         return options?.poisson?.enable ?? false;
     }
 }
-exports.PoissonDiscPlugin = PoissonDiscPlugin;

package/cjs/PoissonInstance.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PoissonInstance = void 0;
-const engine_1 = require("@tsparticles/engine");
-const PoissonDisc_js_1 = require("./PoissonDisc.js");
-class PoissonInstance {
-    constructor(container, engine) {
+import { getRangeMax } from "@tsparticles/engine";
+import { PoissonDisc } from "./PoissonDisc.js";
+export class PoissonInstance {
+    constructor(container) {
         this._container = container;
-        this._engine = engine;
         this._currentIndex = 0;
     }
     async init() {
@@ -17,7 +13,7 @@ class PoissonInstance {
         if (!this.poissonDisc || !(options?.enable ?? false) || this._currentIndex >= this.poissonDisc.points.length) {
             return;
         }
-        return position ?? this.poissonDisc?.points[this._currentIndex++]?.position;
+        return position ?? this.poissonDisc.points[this._currentIndex++]?.position;
     }
     resize() {
         const container = this._container, options = container.actualOptions.poisson;
@@ -44,9 +40,9 @@ class PoissonInstance {
             return;
         }
         this._currentIndex = 0;
-        this.poissonDisc = new PoissonDisc_js_1.PoissonDisc(canvasSize, poissonOptions.radius
+        this.poissonDisc = new PoissonDisc(canvasSize, poissonOptions.radius
             ? poissonOptions.radius * pixelRatio
-            : Math.max((0, engine_1.getRangeMax)(particlesOptions.size.value) * pixelRatio, Math.sqrt((canvasSize.width * canvasSize.height) / particlesOptions.number.value)), poissonOptions.retries, poissonOptions.dimensions);
+            : 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);
@@ -56,4 +52,3 @@ class PoissonInstance {
         }
     }
 }
-exports.PoissonInstance = PoissonInstance;

package/cjs/index.js

@@ -1,8 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadPoissonDiscPlugin = loadPoissonDiscPlugin;
-const PoissonDiscPlugin_js_1 = require("./PoissonDiscPlugin.js");
-async function loadPoissonDiscPlugin(engine, refresh = true) {
-    engine.checkVersion("3.9.1");
-    await engine.addPlugin(new PoissonDiscPlugin_js_1.PoissonDiscPlugin(engine), refresh);
+export function loadPoissonDiscPlugin(engine) {
+    engine.checkVersion("4.0.0-alpha.0");
+    engine.register(async (e) => {
+        const { PoissonDiscPlugin } = await import("./PoissonDiscPlugin.js");
+        e.addPlugin(new PoissonDiscPlugin());
+    });
 }

package/cjs/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist_browser_PoissonDiscPlugin_js.js

@@ -0,0 +1,60 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v4.0.0-alpha.0
+ */
+"use strict";
+/*
+ * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
+ */
+(this["webpackChunk_tsparticles_plugin_poisson_disc"] = this["webpackChunk_tsparticles_plugin_poisson_disc"] || []).push([["dist_browser_PoissonDiscPlugin_js"],{
+
+/***/ "./dist/browser/Options/Classes/Poisson.js"
+/*!*************************************************!*\
+  !*** ./dist/browser/Options/Classes/Poisson.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 */   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}");
+
+/***/ },
+
+/***/ "./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\nconst double = 2,\n  doublePI = Math.PI * double;\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 * (doublePI / this.retries),\n      newDist = this.getRandom(this.radius, this.radius * 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/PoissonDiscPlugin.js"
+/*!*******************************************!*\
+  !*** ./dist/browser/PoissonDiscPlugin.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 */   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/* harmony import */ var _PoissonInstance_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./PoissonInstance.js */ \"./dist/browser/PoissonInstance.js\");\n\n\nclass PoissonDiscPlugin {\n  constructor() {\n    this.id = \"poisson\";\n  }\n  getPlugin(container) {\n    return Promise.resolve(new _PoissonInstance_js__WEBPACK_IMPORTED_MODULE_1__.PoissonInstance(container));\n  }\n  loadOptions(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}");
+
+/***/ },
+
+/***/ "./dist/browser/PoissonInstance.js"
+/*!*****************************************!*\
+  !*** ./dist/browser/PoissonInstance.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 */   PoissonInstance: () => (/* binding */ PoissonInstance)\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 PoissonInstance {\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/PoissonInstance.js?\n}");
+
+/***/ }
+
+}]);

package/esm/PoissonDisc.js

@@ -22,9 +22,12 @@ export class PoissonDisc {
                 x: Math.floor(inputPoint.x / this.cellSize),
                 y: Math.floor(inputPoint.y / this.cellSize),
             },
-        }, pointIndex = this.points.length;
+        }, pointIndex = this.points.length, row = this.grid[point.gridPosition.y];
+        if (!row) {
+            return;
+        }
         this.points.push(point);
-        this.grid[point.gridPosition.y][point.gridPosition.x] = pointIndex;
+        row[point.gridPosition.x] = pointIndex;
         this.active.push(pointIndex);
     }
     getRandom(min, max) {
@@ -33,8 +36,12 @@ export class PoissonDisc {
     initialiseGrid() {
         for (let y = 0; y <= this.rows; y++) {
             this.grid[y] = [];
+            const row = this.grid[y];
+            if (!row) {
+                continue;
+            }
             for (let x = 0; x <= this.cols; x++) {
-                this.grid[y][x] = -1;
+                row[x] = -1;
             }
         }
     }
@@ -85,7 +92,15 @@ export class PoissonDisc {
             newPoint.x < this.size.width &&
             newPoint.y > minCoordinate &&
             newPoint.y < this.size.height) {
-            if (this.grid[newGridCoords.y][newGridCoords.x] < gridMinValue) {
+            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 = {
@@ -97,8 +112,12 @@ export class PoissonDisc {
                             neighbourGrid.x < this.cols &&
                             neighbourGrid.y < this.rows &&
                             (neighbourGrid.x !== newGridCoords.x || neighbourGrid.y !== newGridCoords.y)) {
-                            if (this.grid[neighbourGrid.y][neighbourGrid.x] >= gridMinValue) {
-                                const neighbourIndex = this.grid[neighbourGrid.y][neighbourGrid.x], neighbour = this.points[neighbourIndex], dist = getDistance(newPoint, neighbour.position);
+                            if (point >= gridMinValue) {
+                                const neighbourIndex = point, neighbour = this.points[neighbourIndex];
+                                if (!neighbour) {
+                                    continue;
+                                }
+                                const dist = getDistance(newPoint, neighbour.position);
                                 if (dist < this.radius) {
                                     return;
                                 }
@@ -121,7 +140,15 @@ export class PoissonDisc {
         return new Promise(resolve => {
             let foundNewPoint = false;
             for (let tries = 0; tries < this.retries; tries++) {
-                const newPoint = this._getNewPoint(this.points[this.active[randomActive]], tries);
+                const randomActivePointIndex = this.active[randomActive];
+                if (randomActivePointIndex === undefined) {
+                    continue;
+                }
+                const point = this.points[randomActivePointIndex];
+                if (!point) {
+                    continue;
+                }
+                const newPoint = this._getNewPoint(point, tries);
                 if (newPoint) {
                     foundNewPoint = true;
                     this.addPoint(newPoint);

package/esm/PoissonDiscPlugin.js

@@ -1,12 +1,11 @@
 import { Poisson } from "./Options/Classes/Poisson.js";
 import { PoissonInstance } from "./PoissonInstance.js";
 export class PoissonDiscPlugin {
-    constructor(engine) {
+    constructor() {
         this.id = "poisson";
-        this._engine = engine;
     }
     getPlugin(container) {
-        return Promise.resolve(new PoissonInstance(container, this._engine));
+        return Promise.resolve(new PoissonInstance(container));
     }
     loadOptions(options, source) {
         if (!this.needsPlugin(options) && !this.needsPlugin(source)) {

package/esm/PoissonInstance.js

@@ -1,9 +1,8 @@
 import { getRangeMax } from "@tsparticles/engine";
 import { PoissonDisc } from "./PoissonDisc.js";
 export class PoissonInstance {
-    constructor(container, engine) {
+    constructor(container) {
         this._container = container;
-        this._engine = engine;
         this._currentIndex = 0;
     }
     async init() {
@@ -14,7 +13,7 @@ export class PoissonInstance {
         if (!this.poissonDisc || !(options?.enable ?? false) || this._currentIndex >= this.poissonDisc.points.length) {
             return;
         }
-        return position ?? this.poissonDisc?.points[this._currentIndex++]?.position;
+        return position ?? this.poissonDisc.points[this._currentIndex++]?.position;
     }
     resize() {
         const container = this._container, options = container.actualOptions.poisson;

package/esm/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsparticles/plugin-poisson-disc",
-  "version": "3.9.1",
+  "version": "4.0.0-alpha.0",
   "description": "tsParticles poisson disc plugin",
   "homepage": "https://particles.js.org",
   "repository": {
@@ -85,9 +85,10 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@tsparticles/engine": "3.9.1"
+    "@tsparticles/engine": "4.0.0-alpha.0"
   },
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "type": "module"
 }