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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Matteo Bruni
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+[![banner](https://particles.js.org/images/banner3.png)](https://particles.js.org)
+
+# tsParticles Perlin Noise Path
+
+[![jsDelivr](https://data.jsdelivr.com/v1/package/npm/tsparticles-path-perlin-noise/badge)](https://www.jsdelivr.com/package/npm/tsparticles-path-perlin-noise)
+[![npmjs](https://badge.fury.io/js/tsparticles-path-perlin-noise.svg)](https://www.npmjs.com/package/tsparticles-path-perlin-noise)
+[![npmjs](https://img.shields.io/npm/dt/tsparticles-path-perlin-noise)](https://www.npmjs.com/package/tsparticles-path-perlin-noise) [![GitHub Sponsors](https://img.shields.io/github/sponsors/matteobruni)](https://github.com/sponsors/matteobruni)
+
+[tsParticles](https://github.com/matteobruni/tsparticles) path plugin for perlin noise movement.
+
+## How to use it
+
+### CDN / Vanilla JS / jQuery
+
+The CDN/Vanilla version JS has one required file in vanilla configuration:
+
+Including the `tsparticles.path.perlin.noise.min.js` file will export the function to load the path plugin:
+
+```text
+loadPerlinNoisePath
+```
+
+### Usage
+
+Once the scripts are loaded you can set up `tsParticles` and the path plugin like this:
+
+```javascript
+(async () => {
+  await loadPerlinNoisePath(tsParticles);
+
+  await tsParticles.load({
+    id: "tsparticles",
+    options: {
+      /* options */
+    },
+  });
+})();
+```
+
+### ESM / CommonJS
+
+This package is compatible also with ES or CommonJS modules, firstly this needs to be installed, like this:
+
+```shell
+$ npm install tsparticles-path-perlin-noise
+```
+
+or
+
+```shell
+$ yarn add tsparticles-path-perlin-noise
+```
+
+Then you need to import it in the app, like this:
+
+```javascript
+const { tsParticles } = require("tsparticles-engine");
+const { loadPerlinNoisePath } = require("tsparticles-path-perlin-noise");
+
+loadPerlinNoisePath(tsParticles);
+```
+
+or
+
+```javascript
+import { tsParticles } from "tsparticles-engine";
+import { loadPerlinNoisePath } from "tsparticles-path-perlin-noise";
+
+loadPerlinNoisePath(tsParticles);
+```

package/browser/Grad.js

@@ -0,0 +1,13 @@
+export 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;
+    }
+}

package/browser/IPerlinOptions.js

@@ -0,0 +1 @@
+export {};

package/browser/PerlinNoise.js

@@ -0,0 +1,74 @@
+import { Grad } from "./Grad";
+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;
+}
+export 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];
+        }
+    }
+}

package/browser/PerlinNoiseGenerator.js

@@ -0,0 +1,99 @@
+import { Vector, getRandom } from "@tsparticles/engine";
+import { PerlinNoise } from "./PerlinNoise";
+export 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 = 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 : 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));
+    }
+}

package/browser/index.js

@@ -0,0 +1,5 @@
+import { PerlinNoiseGenerator } from "./PerlinNoiseGenerator";
+export const perlinNoisePathName = "perlinNoise";
+export function loadPerlinNoisePath(engine) {
+    engine.addPathGenerator(perlinNoisePathName, new PerlinNoiseGenerator());
+}

package/cjs/Grad.js

@@ -0,0 +1,17 @@
+"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/cjs/IPerlinOptions.js

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

package/cjs/PerlinNoise.js

@@ -0,0 +1,78 @@
+"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/cjs/PerlinNoiseGenerator.js

@@ -0,0 +1,103 @@
+"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/cjs/index.js

@@ -0,0 +1,9 @@
+"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;

package/esm/Grad.js

@@ -0,0 +1,13 @@
+export 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;
+    }
+}

package/esm/IPerlinOptions.js

@@ -0,0 +1 @@
+export {};

package/esm/PerlinNoise.js

@@ -0,0 +1,74 @@
+import { Grad } from "./Grad";
+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;
+}
+export 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];
+        }
+    }
+}