@tsparticles/path-perlin-noise 3.0.0-alpha.0

package/tsparticles.path.perlin.noise.js

@@ -0,0 +1,278 @@
+/*!
+ * 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
+ * v3.0.0-alpha.0
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("@tsparticles/engine"));
+	else if(typeof define === 'function' && define.amd)
+		define(["@tsparticles/engine"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("@tsparticles/engine")) : factory(root["window"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(this, (__WEBPACK_EXTERNAL_MODULE__533__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 533:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__533__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "loadPerlinNoisePath": () => (/* binding */ loadPerlinNoisePath),
+  "perlinNoisePathName": () => (/* binding */ perlinNoisePathName)
+});
+
+// EXTERNAL MODULE: external {"commonjs":"@tsparticles/engine","commonjs2":"@tsparticles/engine","amd":"@tsparticles/engine","root":"window"}
+var engine_root_window_ = __webpack_require__(533);
+;// CONCATENATED MODULE: ./dist/browser/Grad.js
+class Grad {
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  dot2(x, y) {
+    return this.x * x + this.y * y;
+  }
+  dot3(x, y, z) {
+    return this.dot2(x, y) + this.z * z;
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/PerlinNoise.js
+
+const grad3 = [new Grad(1, 1, 0), new Grad(-1, 1, 0), new Grad(1, -1, 0), new Grad(-1, -1, 0), new Grad(1, 0, 1), new Grad(-1, 0, 1), new Grad(1, 0, -1), new Grad(-1, 0, -1), new Grad(0, 1, 1), new Grad(0, -1, 1), new Grad(0, 1, -1), new Grad(0, -1, -1)];
+const p = [151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180];
+const perm = new Array(512);
+const gradP = new Array(512);
+function fade(t) {
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function lerp(a, b, t) {
+  return (1 - t) * a + t * b;
+}
+class PerlinNoise {
+  noise(x, y, z) {
+    let X = Math.floor(x),
+      Y = Math.floor(y),
+      Z = Math.floor(z);
+    x = x - X;
+    y = y - Y;
+    z = z - Z;
+    X = X & 255;
+    Y = Y & 255;
+    Z = Z & 255;
+    const n000 = gradP[X + perm[Y + perm[Z]]].dot3(x, y, z);
+    const n001 = gradP[X + perm[Y + perm[Z + 1]]].dot3(x, y, z - 1);
+    const n010 = gradP[X + perm[Y + 1 + perm[Z]]].dot3(x, y - 1, z);
+    const n011 = gradP[X + perm[Y + 1 + perm[Z + 1]]].dot3(x, y - 1, z - 1);
+    const n100 = gradP[X + 1 + perm[Y + perm[Z]]].dot3(x - 1, y, z);
+    const n101 = gradP[X + 1 + perm[Y + perm[Z + 1]]].dot3(x - 1, y, z - 1);
+    const n110 = gradP[X + 1 + perm[Y + 1 + perm[Z]]].dot3(x - 1, y - 1, z);
+    const n111 = gradP[X + 1 + perm[Y + 1 + perm[Z + 1]]].dot3(x - 1, y - 1, z - 1);
+    const u = fade(x);
+    const v = fade(y);
+    const w = fade(z);
+    return lerp(lerp(lerp(n000, n100, u), lerp(n001, n101, u), w), lerp(lerp(n010, n110, u), lerp(n011, n111, u), w), v);
+  }
+  seed(inputSeed) {
+    let seed = inputSeed;
+    if (seed > 0 && seed < 1) {
+      seed *= 65536;
+    }
+    seed = Math.floor(seed);
+    if (seed < 256) {
+      seed |= seed << 8;
+    }
+    for (let i = 0; i < 256; i++) {
+      const v = i & 1 ? p[i] ^ seed & 255 : p[i] ^ seed >> 8 & 255;
+      perm[i] = perm[i + 256] = v;
+      gradP[i] = gradP[i + 256] = grad3[v % 12];
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/PerlinNoiseGenerator.js
+
+
+class PerlinNoiseGenerator {
+  constructor() {
+    this.noiseGen = new PerlinNoise();
+    this.field = [];
+    this.noiseZ = 0;
+    this.options = {
+      draw: false,
+      size: 20,
+      increment: 0.004,
+      columns: 0,
+      rows: 0,
+      width: 0,
+      height: 0
+    };
+  }
+  generate(particle) {
+    const pos = particle.getPosition(),
+      point = {
+        x: Math.max(Math.floor(pos.x / this.options.size), 0),
+        y: Math.max(Math.floor(pos.y / this.options.size), 0)
+      },
+      v = engine_root_window_.Vector.origin;
+    if (!this.field || !this.field[point.x] || !this.field[point.x][point.y]) {
+      return v;
+    }
+    v.length = this.field[point.x][point.y][1];
+    v.angle = this.field[point.x][point.y][0];
+    return v;
+  }
+  init(container) {
+    this.container = container;
+    this.setup(container);
+  }
+  reset() {}
+  update() {
+    if (!this.container) {
+      return;
+    }
+    this.calculateField();
+    this.noiseZ += this.options.increment;
+    if (this.options.draw) {
+      this.container.canvas.draw(ctx => this.drawField(ctx));
+    }
+  }
+  calculateField() {
+    for (let x = 0; x < this.options.columns; x++) {
+      for (let y = 0; y < this.options.rows; y++) {
+        const angle = this.noiseGen.noise(x / 50, y / 50, this.noiseZ) * Math.PI * 2;
+        const length = this.noiseGen.noise(x / 100 + 40000, y / 100 + 40000, this.noiseZ);
+        this.field[x][y][0] = angle;
+        this.field[x][y][1] = length;
+      }
+    }
+  }
+  drawField(ctx) {
+    for (let x = 0; x < this.options.columns; x++) {
+      for (let y = 0; y < this.options.rows; y++) {
+        const angle = this.field[x][y][0];
+        const length = this.field[x][y][1];
+        ctx.setTransform(1, 0, 0, 1, x * this.options.size, y * this.options.size);
+        ctx.rotate(angle);
+        ctx.strokeStyle = "white";
+        ctx.beginPath();
+        ctx.moveTo(0, 0);
+        ctx.lineTo(0, this.options.size * length);
+        ctx.stroke();
+        ctx.setTransform(1, 0, 0, 1, 0, 0);
+      }
+    }
+  }
+  initField() {
+    this.field = new Array(this.options.columns);
+    for (let x = 0; x < this.options.columns; x++) {
+      this.field[x] = new Array(this.options.rows);
+      for (let y = 0; y < this.options.rows; y++) {
+        this.field[x][y] = [0, 0];
+      }
+    }
+  }
+  resetField(container) {
+    var _a;
+    const sourceOptions = container.actualOptions.particles.move.path.options;
+    this.options.size = sourceOptions.size > 0 ? sourceOptions.size : 20;
+    this.options.increment = sourceOptions.increment > 0 ? sourceOptions.increment : 0.004;
+    this.options.draw = !!sourceOptions.draw;
+    this.options.width = container.canvas.size.width;
+    this.options.height = container.canvas.size.height;
+    this.noiseGen.seed((_a = sourceOptions.seed) !== null && _a !== void 0 ? _a : (0,engine_root_window_.getRandom)());
+    this.options.columns = Math.floor(this.options.width / this.options.size) + 1;
+    this.options.rows = Math.floor(this.options.height / this.options.size) + 1;
+    this.initField();
+  }
+  setup(container) {
+    this.noiseZ = 0;
+    this.resetField(container);
+    window.addEventListener("resize", () => this.resetField(container));
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/index.js
+
+const perlinNoisePathName = "perlinNoise";
+function loadPerlinNoisePath(engine) {
+  engine.addPathGenerator(perlinNoisePathName, new PerlinNoiseGenerator());
+}
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/tsparticles.path.perlin.noise.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see tsparticles.path.perlin.noise.min.js.LICENSE.txt */
+!function(t,e){if("object"==typeof exports&&"object"==typeof module)module.exports=e(require("@tsparticles/engine"));else if("function"==typeof define&&define.amd)define(["@tsparticles/engine"],e);else{var i="object"==typeof exports?e(require("@tsparticles/engine")):e(t.window);for(var o in i)("object"==typeof exports?exports:t)[o]=i[o]}}(this,(t=>(()=>{"use strict";var e={533:e=>{e.exports=t}},i={};function o(t){var s=i[t];if(void 0!==s)return s.exports;var n=i[t]={exports:{}};return e[t](n,n.exports,o),n.exports}o.d=(t,e)=>{for(var i in e)o.o(e,i)&&!o.o(t,i)&&Object.defineProperty(t,i,{enumerable:!0,get:e[i]})},o.o=(t,e)=>Object.prototype.hasOwnProperty.call(t,e),o.r=t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})};var s={};return(()=>{o.r(s),o.d(s,{loadPerlinNoisePath:()=>f,perlinNoisePathName:()=>c});var t=o(533);class e{constructor(t,e,i){this.x=t,this.y=e,this.z=i}dot2(t,e){return this.x*t+this.y*e}dot3(t,e,i){return this.dot2(t,e)+this.z*i}}const i=[new e(1,1,0),new e(-1,1,0),new e(1,-1,0),new e(-1,-1,0),new e(1,0,1),new e(-1,0,1),new e(1,0,-1),new e(-1,0,-1),new e(0,1,1),new e(0,-1,1),new e(0,1,-1),new e(0,-1,-1)],n=[151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,168,68,175,74,165,71,134,139,48,27,166,77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208,89,18,169,200,196,135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,250,124,123,5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,223,183,170,213,119,248,152,2,44,154,163,70,221,153,101,155,167,43,172,9,129,22,39,253,19,98,108,110,79,113,224,232,178,185,112,104,218,246,97,228,251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,107,49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180],r=new Array(512),h=new Array(512);function l(t){return t*t*t*(t*(6*t-15)+10)}function a(t,e,i){return(1-i)*t+i*e}class d{noise(t,e,i){let o=Math.floor(t),s=Math.floor(e),n=Math.floor(i);t-=o,e-=s,i-=n,o&=255,s&=255,n&=255;const d=h[o+r[s+r[n]]].dot3(t,e,i),p=h[o+r[s+r[n+1]]].dot3(t,e,i-1),c=h[o+r[s+1+r[n]]].dot3(t,e-1,i),f=h[o+r[s+1+r[n+1]]].dot3(t,e-1,i-1),u=h[o+1+r[s+r[n]]].dot3(t-1,e,i),w=h[o+1+r[s+r[n+1]]].dot3(t-1,e,i-1),m=h[o+1+r[s+1+r[n]]].dot3(t-1,e-1,i),y=h[o+1+r[s+1+r[n+1]]].dot3(t-1,e-1,i-1),g=l(t),v=l(e),z=l(i);return a(a(a(d,u,g),a(p,w,g),z),a(a(c,m,g),a(f,y,g),z),v)}seed(t){let e=t;e>0&&e<1&&(e*=65536),e=Math.floor(e),e<256&&(e|=e<<8);for(let t=0;t<256;t++){const o=1&t?n[t]^255&e:n[t]^e>>8&255;r[t]=r[t+256]=o,h[t]=h[t+256]=i[o%12]}}}class p{constructor(){this.noiseGen=new d,this.field=[],this.noiseZ=0,this.options={draw:!1,size:20,increment:.004,columns:0,rows:0,width:0,height:0}}generate(e){const i=e.getPosition(),o=Math.max(Math.floor(i.x/this.options.size),0),s=Math.max(Math.floor(i.y/this.options.size),0),n=t.Vector.origin;return this.field&&this.field[o]&&this.field[o][s]?(n.length=this.field[o][s][1],n.angle=this.field[o][s][0],n):n}init(t){this.container=t,this.setup(t)}reset(){}update(){this.container&&(this.calculateField(),this.noiseZ+=this.options.increment,this.options.draw&&this.container.canvas.draw((t=>this.drawField(t))))}calculateField(){for(let t=0;t<this.options.columns;t++)for(let e=0;e<this.options.rows;e++){const i=this.noiseGen.noise(t/50,e/50,this.noiseZ)*Math.PI*2,o=this.noiseGen.noise(t/100+4e4,e/100+4e4,this.noiseZ);this.field[t][e][0]=i,this.field[t][e][1]=o}}drawField(t){for(let e=0;e<this.options.columns;e++)for(let i=0;i<this.options.rows;i++){const o=this.field[e][i][0],s=this.field[e][i][1];t.setTransform(1,0,0,1,e*this.options.size,i*this.options.size),t.rotate(o),t.strokeStyle="white",t.beginPath(),t.moveTo(0,0),t.lineTo(0,this.options.size*s),t.stroke(),t.setTransform(1,0,0,1,0,0)}}initField(){this.field=new Array(this.options.columns);for(let t=0;t<this.options.columns;t++){this.field[t]=new Array(this.options.rows);for(let e=0;e<this.options.rows;e++)this.field[t][e]=[0,0]}}resetField(e){var i;const o=e.actualOptions.particles.move.path.options;this.options.size=o.size>0?o.size:20,this.options.increment=o.increment>0?o.increment:.004,this.options.draw=!!o.draw,this.options.width=e.canvas.size.width,this.options.height=e.canvas.size.height,this.noiseGen.seed(null!==(i=o.seed)&&void 0!==i?i:(0,t.getRandom)()),this.options.columns=Math.floor(this.options.width/this.options.size)+1,this.options.rows=Math.floor(this.options.height/this.options.size)+1,this.initField()}setup(t){this.noiseZ=0,this.resetField(t),window.addEventListener("resize",(()=>this.resetField(t)))}}const c="perlinNoise";function f(t){t.addPathGenerator(c,new p)}})(),s})()));

package/tsparticles.path.perlin.noise.min.js.LICENSE.txt

@@ -0,0 +1,8 @@
+/*!
+ * 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
+ * v3.0.0-alpha.0
+ */

package/types/Grad.d.ts

@@ -0,0 +1,8 @@
+export declare class Grad {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    constructor(x: number, y: number, z: number);
+    dot2(x: number, y: number): number;
+    dot3(x: number, y: number, z: number): number;
+}

package/types/IPerlinOptions.d.ts

@@ -0,0 +1,9 @@
+export interface IPerlinOptions {
+    columns: number;
+    draw: boolean;
+    height: number;
+    increment: number;
+    rows: number;
+    size: number;
+    width: number;
+}

package/types/PerlinNoise.d.ts

@@ -0,0 +1,4 @@
+export declare class PerlinNoise {
+    noise(x: number, y: number, z: number): number;
+    seed(inputSeed: number): void;
+}

package/types/PerlinNoiseGenerator.d.ts

@@ -0,0 +1,21 @@
+import type { Container, IMovePathGenerator, Particle } from "@tsparticles/engine";
+import { Vector } from "@tsparticles/engine";
+import type { IPerlinOptions } from "./IPerlinOptions";
+import { PerlinNoise } from "./PerlinNoise";
+export declare class PerlinNoiseGenerator implements IMovePathGenerator {
+    container?: Container;
+    field: number[][][];
+    readonly noiseGen: PerlinNoise;
+    noiseZ: number;
+    readonly options: IPerlinOptions;
+    constructor();
+    generate(particle: Particle): Vector;
+    init(container: Container): void;
+    reset(): void;
+    update(): void;
+    private calculateField;
+    private drawField;
+    private initField;
+    private resetField;
+    private setup;
+}

package/types/index.d.ts

@@ -0,0 +1,3 @@
+import type { Engine } from "@tsparticles/engine";
+export declare const perlinNoisePathName = "perlinNoise";
+export declare function loadPerlinNoisePath(engine: Engine): void;

package/umd/Grad.js

@@ -0,0 +1,27 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Grad = void 0;
+    class Grad {
+        constructor(x, y, z) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+        }
+        dot2(x, y) {
+            return this.x * x + this.y * y;
+        }
+        dot3(x, y, z) {
+            return this.dot2(x, y) + this.z * z;
+        }
+    }
+    exports.Grad = Grad;
+});

package/umd/IPerlinOptions.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/umd/PerlinNoise.js

@@ -0,0 +1,88 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Grad"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PerlinNoise = void 0;
+    const Grad_1 = require("./Grad");
+    const grad3 = [
+        new Grad_1.Grad(1, 1, 0),
+        new Grad_1.Grad(-1, 1, 0),
+        new Grad_1.Grad(1, -1, 0),
+        new Grad_1.Grad(-1, -1, 0),
+        new Grad_1.Grad(1, 0, 1),
+        new Grad_1.Grad(-1, 0, 1),
+        new Grad_1.Grad(1, 0, -1),
+        new Grad_1.Grad(-1, 0, -1),
+        new Grad_1.Grad(0, 1, 1),
+        new Grad_1.Grad(0, -1, 1),
+        new Grad_1.Grad(0, 1, -1),
+        new Grad_1.Grad(0, -1, -1),
+    ];
+    const p = [
+        151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240,
+        21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33, 88,
+        237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83,
+        111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80,
+        73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64,
+        52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182,
+        189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22,
+        39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242, 193, 238, 210,
+        144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84,
+        204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78,
+        66, 215, 61, 156, 180,
+    ];
+    const perm = new Array(512);
+    const gradP = new Array(512);
+    function fade(t) {
+        return t * t * t * (t * (t * 6 - 15) + 10);
+    }
+    function lerp(a, b, t) {
+        return (1 - t) * a + t * b;
+    }
+    class PerlinNoise {
+        noise(x, y, z) {
+            let X = Math.floor(x), Y = Math.floor(y), Z = Math.floor(z);
+            x = x - X;
+            y = y - Y;
+            z = z - Z;
+            X = X & 255;
+            Y = Y & 255;
+            Z = Z & 255;
+            const n000 = gradP[X + perm[Y + perm[Z]]].dot3(x, y, z);
+            const n001 = gradP[X + perm[Y + perm[Z + 1]]].dot3(x, y, z - 1);
+            const n010 = gradP[X + perm[Y + 1 + perm[Z]]].dot3(x, y - 1, z);
+            const n011 = gradP[X + perm[Y + 1 + perm[Z + 1]]].dot3(x, y - 1, z - 1);
+            const n100 = gradP[X + 1 + perm[Y + perm[Z]]].dot3(x - 1, y, z);
+            const n101 = gradP[X + 1 + perm[Y + perm[Z + 1]]].dot3(x - 1, y, z - 1);
+            const n110 = gradP[X + 1 + perm[Y + 1 + perm[Z]]].dot3(x - 1, y - 1, z);
+            const n111 = gradP[X + 1 + perm[Y + 1 + perm[Z + 1]]].dot3(x - 1, y - 1, z - 1);
+            const u = fade(x);
+            const v = fade(y);
+            const w = fade(z);
+            return lerp(lerp(lerp(n000, n100, u), lerp(n001, n101, u), w), lerp(lerp(n010, n110, u), lerp(n011, n111, u), w), v);
+        }
+        seed(inputSeed) {
+            let seed = inputSeed;
+            if (seed > 0 && seed < 1) {
+                seed *= 65536;
+            }
+            seed = Math.floor(seed);
+            if (seed < 256) {
+                seed |= seed << 8;
+            }
+            for (let i = 0; i < 256; i++) {
+                const v = i & 1 ? p[i] ^ (seed & 255) : p[i] ^ ((seed >> 8) & 255);
+                perm[i] = perm[i + 256] = v;
+                gradP[i] = gradP[i + 256] = grad3[v % 12];
+            }
+        }
+    }
+    exports.PerlinNoise = PerlinNoise;
+});

package/umd/PerlinNoiseGenerator.js

@@ -0,0 +1,113 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@tsparticles/engine", "./PerlinNoise"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PerlinNoiseGenerator = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const PerlinNoise_1 = require("./PerlinNoise");
+    class PerlinNoiseGenerator {
+        constructor() {
+            this.noiseGen = new PerlinNoise_1.PerlinNoise();
+            this.field = [];
+            this.noiseZ = 0;
+            this.options = {
+                draw: false,
+                size: 20,
+                increment: 0.004,
+                columns: 0,
+                rows: 0,
+                width: 0,
+                height: 0,
+            };
+        }
+        generate(particle) {
+            const pos = particle.getPosition(), point = {
+                x: Math.max(Math.floor(pos.x / this.options.size), 0),
+                y: Math.max(Math.floor(pos.y / this.options.size), 0),
+            }, v = engine_1.Vector.origin;
+            if (!this.field || !this.field[point.x] || !this.field[point.x][point.y]) {
+                return v;
+            }
+            v.length = this.field[point.x][point.y][1];
+            v.angle = this.field[point.x][point.y][0];
+            return v;
+        }
+        init(container) {
+            this.container = container;
+            this.setup(container);
+        }
+        reset() {
+        }
+        update() {
+            if (!this.container) {
+                return;
+            }
+            this.calculateField();
+            this.noiseZ += this.options.increment;
+            if (this.options.draw) {
+                this.container.canvas.draw((ctx) => this.drawField(ctx));
+            }
+        }
+        calculateField() {
+            for (let x = 0; x < this.options.columns; x++) {
+                for (let y = 0; y < this.options.rows; y++) {
+                    const angle = this.noiseGen.noise(x / 50, y / 50, this.noiseZ) * Math.PI * 2;
+                    const length = this.noiseGen.noise(x / 100 + 40000, y / 100 + 40000, this.noiseZ);
+                    this.field[x][y][0] = angle;
+                    this.field[x][y][1] = length;
+                }
+            }
+        }
+        drawField(ctx) {
+            for (let x = 0; x < this.options.columns; x++) {
+                for (let y = 0; y < this.options.rows; y++) {
+                    const angle = this.field[x][y][0];
+                    const length = this.field[x][y][1];
+                    ctx.setTransform(1, 0, 0, 1, x * this.options.size, y * this.options.size);
+                    ctx.rotate(angle);
+                    ctx.strokeStyle = "white";
+                    ctx.beginPath();
+                    ctx.moveTo(0, 0);
+                    ctx.lineTo(0, this.options.size * length);
+                    ctx.stroke();
+                    ctx.setTransform(1, 0, 0, 1, 0, 0);
+                }
+            }
+        }
+        initField() {
+            this.field = new Array(this.options.columns);
+            for (let x = 0; x < this.options.columns; x++) {
+                this.field[x] = new Array(this.options.rows);
+                for (let y = 0; y < this.options.rows; y++) {
+                    this.field[x][y] = [0, 0];
+                }
+            }
+        }
+        resetField(container) {
+            var _a;
+            const sourceOptions = container.actualOptions.particles.move.path.options;
+            this.options.size = sourceOptions.size > 0 ? sourceOptions.size : 20;
+            this.options.increment = sourceOptions.increment > 0 ? sourceOptions.increment : 0.004;
+            this.options.draw = !!sourceOptions.draw;
+            this.options.width = container.canvas.size.width;
+            this.options.height = container.canvas.size.height;
+            this.noiseGen.seed((_a = sourceOptions.seed) !== null && _a !== void 0 ? _a : (0, engine_1.getRandom)());
+            this.options.columns = Math.floor(this.options.width / this.options.size) + 1;
+            this.options.rows = Math.floor(this.options.height / this.options.size) + 1;
+            this.initField();
+        }
+        setup(container) {
+            this.noiseZ = 0;
+            this.resetField(container);
+            window.addEventListener("resize", () => this.resetField(container));
+        }
+    }
+    exports.PerlinNoiseGenerator = PerlinNoiseGenerator;
+});

package/umd/index.js

@@ -0,0 +1,19 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./PerlinNoiseGenerator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadPerlinNoisePath = exports.perlinNoisePathName = void 0;
+    const PerlinNoiseGenerator_1 = require("./PerlinNoiseGenerator");
+    exports.perlinNoisePathName = "perlinNoise";
+    function loadPerlinNoisePath(engine) {
+        engine.addPathGenerator(exports.perlinNoisePathName, new PerlinNoiseGenerator_1.PerlinNoiseGenerator());
+    }
+    exports.loadPerlinNoisePath = loadPerlinNoisePath;
+});