@tsparticles/simplex-noise 4.0.5 → 4.1.1

package/browser/Classes/SimplexNoise2D.js

@@ -1,25 +1,25 @@
 import { shuffleSeed } from "../utils.js";
 const half = 0.5;
 export class SimplexNoise2D {
-    _NORM_2D;
-    _SQUISH_2D;
-    _STRETCH_2D;
-    _base2D;
-    _gradients2D;
-    _lookup;
-    _lookupPairs2D;
-    _p2D;
-    _perm;
-    _perm2D;
+    #NORM_2D;
+    #SQUISH_2D;
+    #STRETCH_2D;
+    #base2D;
+    #gradients2D;
+    #lookup;
+    #lookupPairs2D;
+    #p2D;
+    #perm;
+    #perm2D;
     constructor() {
-        this._NORM_2D = 1 / 47;
-        this._SQUISH_2D = (Math.sqrt(2 + 1) - 1) * half;
-        this._STRETCH_2D = (1 / Math.sqrt(2 + 1) - 1) * half;
-        this._base2D = [
+        this.#NORM_2D = 1 / 47;
+        this.#SQUISH_2D = (Math.sqrt(2 + 1) - 1) * half;
+        this.#STRETCH_2D = (1 / Math.sqrt(2 + 1) - 1) * half;
+        this.#base2D = [
             [1, 1, 0, 1, 0, 1, 0, 0, 0],
             [1, 1, 0, 1, 0, 1, 2, 1, 1],
         ];
-        this._gradients2D = [
+        this.#gradients2D = [
             5,
             2,
             2,
@@ -37,8 +37,8 @@ export class SimplexNoise2D {
             -2,
             -5,
         ];
-        this._lookup = [];
-        this._lookupPairs2D = [
+        this.#lookup = [];
+        this.#lookupPairs2D = [
             0,
             1,
             1,
@@ -64,7 +64,7 @@ export class SimplexNoise2D {
             43,
             3,
         ];
-        this._p2D = [
+        this.#p2D = [
             0,
             0,
             1,
@@ -90,29 +90,29 @@ export class SimplexNoise2D {
             0,
             0,
         ];
-        this._perm = new Uint8Array(256);
-        this._perm2D = new Uint8Array(256);
+        this.#perm = new Uint8Array(256);
+        this.#perm2D = new Uint8Array(256);
     }
     noise(x, y) {
-        const { _gradients2D, _NORM_2D, _SQUISH_2D, _STRETCH_2D, _lookup, _perm, _perm2D } = this, stretchOffset = (x + y) * _STRETCH_2D, xs = x + stretchOffset, ys = y + stretchOffset, xsb = Math.floor(xs), ysb = Math.floor(ys), squishOffset = (xsb + ysb) * _SQUISH_2D, dx0 = x - (xsb + squishOffset), dy0 = y - (ysb + squishOffset), xins = xs - xsb, yins = ys - ysb, inSum = xins + yins, hash = (xins - yins + 1) | (inSum << 1) | ((inSum + yins) << 2) | ((inSum + xins) << 4);
+        const gradients2D = this.#gradients2D, NORM_2D = this.#NORM_2D, SQUISH_2D = this.#SQUISH_2D, STRETCH_2D = this.#STRETCH_2D, lookup = this.#lookup, perm = this.#perm, perm2D = this.#perm2D, stretchOffset = (x + y) * STRETCH_2D, xs = x + stretchOffset, ys = y + stretchOffset, xsb = Math.floor(xs), ysb = Math.floor(ys), squishOffset = (xsb + ysb) * SQUISH_2D, dx0 = x - (xsb + squishOffset), dy0 = y - (ysb + squishOffset), xins = xs - xsb, yins = ys - ysb, inSum = xins + yins, hash = (xins - yins + 1) | (inSum << 1) | ((inSum + yins) << 2) | ((inSum + xins) << 4);
         let value = 0;
-        for (let c = _lookup[hash]; c !== undefined; c = c.next) {
+        for (let c = lookup[hash]; c !== undefined; c = c.next) {
             const dx = dx0 + c.dx, dy = dy0 + c.dy, attn = 2 - dx * dx - dy * dy;
             if (attn <= 0) {
                 continue;
             }
-            const px = xsb + c.xsb, py = ysb + c.ysb, indexPartA = _perm[px & 0xff], index = _perm2D[(indexPartA + py) & 0xff], valuePart = _gradients2D[index] * dx + _gradients2D[index + 1] * dy;
+            const px = xsb + c.xsb, py = ysb + c.ysb, indexPartA = perm[px & 0xff], index = perm2D[(indexPartA + py) & 0xff], valuePart = gradients2D[index] * dx + gradients2D[index + 1] * dy;
             value += attn * attn * attn * attn * valuePart;
         }
-        return value * _NORM_2D;
+        return value * NORM_2D;
     }
     seed(clientSeed) {
-        const { _p2D, _base2D, _lookupPairs2D } = this, contributions = [];
-        for (let i = 0; i < _p2D.length; i += 4) {
-            const baseSet = _base2D[_p2D[i]];
+        const p2D = this.#p2D, base2D = this.#base2D, lookupPairs2D = this.#lookupPairs2D, contributions = [];
+        for (let i = 0; i < p2D.length; i += 4) {
+            const baseSet = base2D[p2D[i]];
             let previous = null, current = null;
             for (let k = 0; k < baseSet.length; k += 3) {
-                current = this._contribution2D(baseSet[k], baseSet[k + 1], baseSet[k + 2]);
+                current = this.#contribution2D(baseSet[k], baseSet[k + 1], baseSet[k + 2]);
                 if (previous === null) {
                     contributions[i / 4] = current;
                 }
@@ -122,15 +122,15 @@ export class SimplexNoise2D {
                 previous = current;
             }
             if (current) {
-                current.next = this._contribution2D(_p2D[i + 1], _p2D[i + 2], _p2D[i + 3]);
+                current.next = this.#contribution2D(p2D[i + 1], p2D[i + 2], p2D[i + 3]);
             }
         }
-        this._lookup = [];
-        for (let i = 0; i < _lookupPairs2D.length; i += 2) {
-            this._lookup[_lookupPairs2D[i]] = contributions[_lookupPairs2D[i + 1]];
+        this.#lookup = [];
+        for (let i = 0; i < lookupPairs2D.length; i += 2) {
+            this.#lookup[lookupPairs2D[i]] = contributions[lookupPairs2D[i + 1]];
         }
-        this._perm = new Uint8Array(256);
-        this._perm2D = new Uint8Array(256);
+        this.#perm = new Uint8Array(256);
+        this.#perm2D = new Uint8Array(256);
         const source = new Uint8Array(256);
         for (let i = 0; i < 256; i++) {
             source[i] = i;
@@ -145,16 +145,16 @@ export class SimplexNoise2D {
             if (r[0] < 0) {
                 r[0] += i + 1;
             }
-            this._perm[i] = source[r[0]];
-            this._perm2D[i] = this._perm[i] & 0x0e;
+            this.#perm[i] = source[r[0]];
+            this.#perm2D[i] = this.#perm[i] & 0x0e;
             source[r[0]] = source[i];
         }
     }
-    _contribution2D(multiplier, xsb, ysb) {
-        const { _SQUISH_2D } = this;
+    #contribution2D(multiplier, xsb, ysb) {
+        const SQUISH_2D = this.#SQUISH_2D;
         return {
-            dx: -xsb - multiplier * _SQUISH_2D,
-            dy: -ysb - multiplier * _SQUISH_2D,
+            dx: -xsb - multiplier * SQUISH_2D,
+            dy: -ysb - multiplier * SQUISH_2D,
             xsb,
             ysb,
         };

package/browser/Classes/SimplexNoise3D.js

@@ -1,26 +1,26 @@
 import { shuffleSeed } from "../utils.js";
 const third = 1 / 3;
 export class SimplexNoise3D {
-    _NORM_3D;
-    _SQUISH_3D;
-    _STRETCH_3D;
-    _base3D;
-    _gradients3D;
-    _lookup;
-    _lookupPairs3D;
-    _p3D;
-    _perm;
-    _perm3D;
+    #NORM_3D;
+    #SQUISH_3D;
+    #STRETCH_3D;
+    #base3D;
+    #gradients3D;
+    #lookup;
+    #lookupPairs3D;
+    #p3D;
+    #perm;
+    #perm3D;
     constructor() {
-        this._NORM_3D = 1 / 103;
-        this._SQUISH_3D = (Math.sqrt(3 + 1) - 1) * third;
-        this._STRETCH_3D = (1 / Math.sqrt(3 + 1) - 1) * third;
-        this._base3D = [
+        this.#NORM_3D = 1 / 103;
+        this.#SQUISH_3D = (Math.sqrt(3 + 1) - 1) * third;
+        this.#STRETCH_3D = (1 / Math.sqrt(3 + 1) - 1) * third;
+        this.#base3D = [
             [0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1],
             [2, 1, 1, 0, 2, 1, 0, 1, 2, 0, 1, 1, 3, 1, 1, 1],
             [1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 2, 1, 1, 0, 2, 1, 0, 1, 2, 0, 1, 1],
         ];
-        this._gradients3D = [
+        this.#gradients3D = [
             -11,
             4,
             4,
@@ -94,8 +94,8 @@ export class SimplexNoise3D {
             -4,
             -11,
         ];
-        this._lookup = [];
-        this._lookupPairs3D = [
+        this.#lookup = [];
+        this.#lookupPairs3D = [
             0,
             2,
             1,
@@ -241,7 +241,7 @@ export class SimplexNoise3D {
             2039,
             6,
         ];
-        this._p3D = [
+        this.#p3D = [
             0,
             0,
             1,
@@ -459,11 +459,11 @@ export class SimplexNoise3D {
             2,
             0,
         ];
-        this._perm = new Uint8Array(256);
-        this._perm3D = new Uint8Array(256);
+        this.#perm = new Uint8Array(256);
+        this.#perm3D = new Uint8Array(256);
     }
     noise(x, y, z) {
-        const { _STRETCH_3D, _NORM_3D, _SQUISH_3D, _lookup, _perm, _perm3D, _gradients3D } = this, stretchOffset = (x + y + z) * _STRETCH_3D, xs = x + stretchOffset, ys = y + stretchOffset, zs = z + stretchOffset, xsb = Math.floor(xs), ysb = Math.floor(ys), zsb = Math.floor(zs), squishOffset = (xsb + ysb + zsb) * _SQUISH_3D, dx0 = x - (xsb + squishOffset), dy0 = y - (ysb + squishOffset), dz0 = z - (zsb + squishOffset), xins = xs - xsb, yins = ys - ysb, zins = zs - zsb, inSum = xins + yins + zins, hash = (yins - zins + 1) |
+        const STRETCH_3D = this.#STRETCH_3D, NORM_3D = this.#NORM_3D, SQUISH_3D = this.#SQUISH_3D, lookup = this.#lookup, perm = this.#perm, perm3D = this.#perm3D, gradients3D = this.#gradients3D, stretchOffset = (x + y + z) * STRETCH_3D, xs = x + stretchOffset, ys = y + stretchOffset, zs = z + stretchOffset, xsb = Math.floor(xs), ysb = Math.floor(ys), zsb = Math.floor(zs), squishOffset = (xsb + ysb + zsb) * SQUISH_3D, dx0 = x - (xsb + squishOffset), dy0 = y - (ysb + squishOffset), dz0 = z - (zsb + squishOffset), xins = xs - xsb, yins = ys - ysb, zins = zs - zsb, inSum = xins + yins + zins, hash = (yins - zins + 1) |
             ((xins - yins + 1) << 1) |
             ((xins - zins + 1) << 2) |
             (inSum << 3) |
@@ -471,22 +471,22 @@ export class SimplexNoise3D {
             ((inSum + yins) << 7) |
             ((inSum + xins) << 9);
         let value = 0;
-        for (let c = _lookup[hash]; c !== undefined; c = c.next) {
+        for (let c = lookup[hash]; c !== undefined; c = c.next) {
             const dx = dx0 + c.dx, dy = dy0 + c.dy, dz = dz0 + c.dz, attn = 2 - dx * dx - dy * dy - dz * dz;
             if (attn > 0) {
-                const px = xsb + c.xsb, py = ysb + c.ysb, pz = zsb + c.zsb, indexPartA = _perm[px & 0xff], indexPartB = _perm[(indexPartA + py) & 0xff], index = _perm3D[(indexPartB + pz) & 0xff], valuePart = _gradients3D[index] * dx + _gradients3D[index + 1] * dy + _gradients3D[index + 2] * dz;
+                const px = xsb + c.xsb, py = ysb + c.ysb, pz = zsb + c.zsb, indexPartA = perm[px & 0xff], indexPartB = perm[(indexPartA + py) & 0xff], index = perm3D[(indexPartB + pz) & 0xff], valuePart = gradients3D[index] * dx + gradients3D[index + 1] * dy + gradients3D[index + 2] * dz;
                 value += attn * attn * attn * attn * valuePart;
             }
         }
-        return value * _NORM_3D;
+        return value * NORM_3D;
     }
     seed(clientSeed) {
-        const { _base3D, _lookupPairs3D, _p3D } = this, contributions = [];
-        for (let i = 0; i < _p3D.length; i += 9) {
-            const baseSet = _base3D[_p3D[i]];
+        const base3D = this.#base3D, lookupPairs3D = this.#lookupPairs3D, p3D = this.#p3D, contributions = [];
+        for (let i = 0; i < p3D.length; i += 9) {
+            const baseSet = base3D[p3D[i]];
             let previous = null, current = null;
             for (let k = 0; k < baseSet.length; k += 4) {
-                current = this._contribution3D(baseSet[k], baseSet[k + 1], baseSet[k + 2], baseSet[k + 3]);
+                current = this.#contribution3D(baseSet[k], baseSet[k + 1], baseSet[k + 2], baseSet[k + 3]);
                 if (previous === null) {
                     contributions[i / 9] = current;
                 }
@@ -496,16 +496,16 @@ export class SimplexNoise3D {
                 previous = current;
             }
             if (current) {
-                current.next = this._contribution3D(_p3D[i + 1], _p3D[i + 2], _p3D[i + 3], _p3D[i + 4]);
-                current.next.next = this._contribution3D(_p3D[i + 5], _p3D[i + 6], _p3D[i + 7], _p3D[i + 8]);
+                current.next = this.#contribution3D(p3D[i + 1], p3D[i + 2], p3D[i + 3], p3D[i + 4]);
+                current.next.next = this.#contribution3D(p3D[i + 5], p3D[i + 6], p3D[i + 7], p3D[i + 8]);
             }
         }
-        this._lookup = [];
-        for (let i = 0; i < _lookupPairs3D.length; i += 2) {
-            this._lookup[_lookupPairs3D[i]] = contributions[_lookupPairs3D[i + 1]];
+        this.#lookup = [];
+        for (let i = 0; i < lookupPairs3D.length; i += 2) {
+            this.#lookup[lookupPairs3D[i]] = contributions[lookupPairs3D[i + 1]];
         }
-        this._perm = new Uint8Array(256);
-        this._perm3D = new Uint8Array(256);
+        this.#perm = new Uint8Array(256);
+        this.#perm3D = new Uint8Array(256);
         const source = new Uint8Array(256);
         for (let i = 0; i < 256; i++) {
             source[i] = i;
@@ -520,17 +520,17 @@ export class SimplexNoise3D {
             if (r[0] < 0) {
                 r[0] += i + 1;
             }
-            this._perm[i] = source[r[0]];
-            this._perm3D[i] = (this._perm[i] % 24) * 3;
+            this.#perm[i] = source[r[0]];
+            this.#perm3D[i] = (this.#perm[i] % 24) * 3;
             source[r[0]] = source[i];
         }
     }
-    _contribution3D(multiplier, xsb, ysb, zsb) {
-        const { _SQUISH_3D } = this;
+    #contribution3D(multiplier, xsb, ysb, zsb) {
+        const SQUISH_3D = this.#SQUISH_3D;
         return {
-            dx: -xsb - multiplier * _SQUISH_3D,
-            dy: -ysb - multiplier * _SQUISH_3D,
-            dz: -zsb - multiplier * _SQUISH_3D,
+            dx: -xsb - multiplier * SQUISH_3D,
+            dy: -ysb - multiplier * SQUISH_3D,
+            dz: -zsb - multiplier * SQUISH_3D,
             xsb,
             ysb,
             zsb,

package/browser/Classes/SimplexNoise4D.js

@@ -1,24 +1,24 @@
 import { shuffleSeed } from "../utils.js";
 const quarter = 0.25;
 export class SimplexNoise4D {
-    _NORM_4D;
-    _SQUISH_4D;
-    _STRETCH_4D;
-    _base4D;
-    _gradients4D;
-    _lookup;
-    _lookupPairs4D;
-    _p4D;
-    _perm;
-    _perm4D;
+    #NORM_4D;
+    #SQUISH_4D;
+    #STRETCH_4D;
+    #base4D;
+    #gradients4D;
+    #lookup;
+    #lookupPairs4D;
+    #p4D;
+    #perm;
+    #perm4D;
     constructor() {
-        this._NORM_4D = 1 / 30;
-        this._SQUISH_4D = (Math.sqrt(4 + 1) - 1) * quarter;
-        this._STRETCH_4D = (1 / Math.sqrt(4 + 1) - 1) * quarter;
-        this._lookup = [];
-        this._perm = new Uint8Array(0);
-        this._perm4D = new Uint8Array(0);
-        this._base4D = [
+        this.#NORM_4D = 1 / 30;
+        this.#SQUISH_4D = (Math.sqrt(4 + 1) - 1) * quarter;
+        this.#STRETCH_4D = (1 / Math.sqrt(4 + 1) - 1) * quarter;
+        this.#lookup = [];
+        this.#perm = new Uint8Array(0);
+        this.#perm4D = new Uint8Array(0);
+        this.#base4D = [
             [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1],
             [3, 1, 1, 1, 0, 3, 1, 1, 0, 1, 3, 1, 0, 1, 1, 3, 0, 1, 1, 1, 4, 1, 1, 1, 1],
             [
@@ -126,7 +126,7 @@ export class SimplexNoise4D {
                 1,
             ],
         ];
-        this._gradients4D = [
+        this.#gradients4D = [
             3,
             1,
             1,
@@ -384,7 +384,7 @@ export class SimplexNoise4D {
             -1,
             -3,
         ];
-        this._lookupPairs4D = [
+        this.#lookupPairs4D = [
             0,
             3,
             1,
@@ -1506,7 +1506,7 @@ export class SimplexNoise4D {
             599295,
             10,
         ];
-        this._p4D = [
+        this.#p4D = [
             0,
             0,
             1,
@@ -2790,7 +2790,7 @@ export class SimplexNoise4D {
         ];
     }
     noise(x, y, z, w) {
-        const { _perm, _perm4D, _lookup, _STRETCH_4D, _SQUISH_4D, _gradients4D, _NORM_4D } = this, stretchOffset = (x + y + z + w) * _STRETCH_4D, xs = x + stretchOffset, ys = y + stretchOffset, zs = z + stretchOffset, ws = w + stretchOffset, xsb = Math.floor(xs), ysb = Math.floor(ys), zsb = Math.floor(zs), wsb = Math.floor(ws), squishOffset = (xsb + ysb + zsb + wsb) * _SQUISH_4D, dx0 = x - (xsb + squishOffset), dy0 = y - (ysb + squishOffset), dz0 = z - (zsb + squishOffset), dw0 = w - (wsb + squishOffset), xins = xs - xsb, yins = ys - ysb, zins = zs - zsb, wins = ws - wsb, inSum = xins + yins + zins + wins, hash = (zins - wins + 1) |
+        const perm = this.#perm, perm4D = this.#perm4D, lookup = this.#lookup, STRETCH_4D = this.#STRETCH_4D, SQUISH_4D = this.#SQUISH_4D, gradients4D = this.#gradients4D, NORM_4D = this.#NORM_4D, stretchOffset = (x + y + z + w) * STRETCH_4D, xs = x + stretchOffset, ys = y + stretchOffset, zs = z + stretchOffset, ws = w + stretchOffset, xsb = Math.floor(xs), ysb = Math.floor(ys), zsb = Math.floor(zs), wsb = Math.floor(ws), squishOffset = (xsb + ysb + zsb + wsb) * SQUISH_4D, dx0 = x - (xsb + squishOffset), dy0 = y - (ysb + squishOffset), dz0 = z - (zsb + squishOffset), dw0 = w - (wsb + squishOffset), xins = xs - xsb, yins = ys - ysb, zins = zs - zsb, wins = ws - wsb, inSum = xins + yins + zins + wins, hash = (zins - wins + 1) |
             ((yins - zins + 1) << 1) |
             ((yins - wins + 1) << 2) |
             ((xins - yins + 1) << 3) |
@@ -2802,25 +2802,25 @@ export class SimplexNoise4D {
             ((inSum + yins) << 14) |
             ((inSum + xins) << 17);
         let value = 0;
-        for (let c = _lookup[hash]; c !== undefined; c = c.next) {
+        for (let c = lookup[hash]; c !== undefined; c = c.next) {
             const dx = dx0 + c.dx, dy = dy0 + c.dy, dz = dz0 + c.dz, dw = dw0 + c.dw, attn = 2 - dx * dx - dy * dy - dz * dz - dw * dw;
             if (attn > 0) {
-                const px = xsb + c.xsb, py = ysb + c.ysb, pz = zsb + c.zsb, pw = wsb + c.wsb, indexPartA = _perm[px & 0xff], indexPartB = _perm[(indexPartA + py) & 0xff], indexPartC = _perm[(indexPartB + pz) & 0xff], index = _perm4D[(indexPartC + pw) & 0xff], valuePart = _gradients4D[index] * dx +
-                    _gradients4D[index + 1] * dy +
-                    _gradients4D[index + 2] * dz +
-                    _gradients4D[index + 3] * dw;
+                const px = xsb + c.xsb, py = ysb + c.ysb, pz = zsb + c.zsb, pw = wsb + c.wsb, indexPartA = perm[px & 0xff], indexPartB = perm[(indexPartA + py) & 0xff], indexPartC = perm[(indexPartB + pz) & 0xff], index = perm4D[(indexPartC + pw) & 0xff], valuePart = gradients4D[index] * dx +
+                    gradients4D[index + 1] * dy +
+                    gradients4D[index + 2] * dz +
+                    gradients4D[index + 3] * dw;
                 value += attn * attn * attn * attn * valuePart;
             }
         }
-        return value * _NORM_4D;
+        return value * NORM_4D;
     }
     seed(clientSeed) {
-        const { _p4D, _base4D, _lookupPairs4D } = this, contributions = [];
-        for (let i = 0; i < _p4D.length; i += 16) {
-            const baseSet = _base4D[_p4D[i]];
+        const p4D = this.#p4D, base4D = this.#base4D, lookupPairs4D = this.#lookupPairs4D, contributions = [];
+        for (let i = 0; i < p4D.length; i += 16) {
+            const baseSet = base4D[p4D[i]];
             let previous = null, current = null;
             for (let k = 0; k < baseSet.length; k += 5) {
-                current = this._contribution4D(baseSet[k], baseSet[k + 1], baseSet[k + 2], baseSet[k + 3], baseSet[k + 4]);
+                current = this.#contribution4D(baseSet[k], baseSet[k + 1], baseSet[k + 2], baseSet[k + 3], baseSet[k + 4]);
                 if (previous === null) {
                     contributions[i / 16] = current;
                 }
@@ -2830,17 +2830,17 @@ export class SimplexNoise4D {
                 previous = current;
             }
             if (current) {
-                current.next = this._contribution4D(_p4D[i + 1], _p4D[i + 2], _p4D[i + 3], _p4D[i + 4], _p4D[i + 5]);
-                current.next.next = this._contribution4D(_p4D[i + 6], _p4D[i + 7], _p4D[i + 8], _p4D[i + 9], _p4D[i + 10]);
-                current.next.next.next = this._contribution4D(_p4D[i + 11], _p4D[i + 12], _p4D[i + 13], _p4D[i + 14], _p4D[i + 15]);
+                current.next = this.#contribution4D(p4D[i + 1], p4D[i + 2], p4D[i + 3], p4D[i + 4], p4D[i + 5]);
+                current.next.next = this.#contribution4D(p4D[i + 6], p4D[i + 7], p4D[i + 8], p4D[i + 9], p4D[i + 10]);
+                current.next.next.next = this.#contribution4D(p4D[i + 11], p4D[i + 12], p4D[i + 13], p4D[i + 14], p4D[i + 15]);
             }
         }
-        this._lookup = [];
-        for (let i = 0; i < _lookupPairs4D.length; i += 2) {
-            this._lookup[_lookupPairs4D[i]] = contributions[_lookupPairs4D[i + 1]];
+        this.#lookup = [];
+        for (let i = 0; i < lookupPairs4D.length; i += 2) {
+            this.#lookup[lookupPairs4D[i]] = contributions[lookupPairs4D[i + 1]];
         }
-        this._perm = new Uint8Array(256);
-        this._perm4D = new Uint8Array(256);
+        this.#perm = new Uint8Array(256);
+        this.#perm4D = new Uint8Array(256);
         const source = new Uint8Array(256);
         for (let i = 0; i < 256; i++) {
             source[i] = i;
@@ -2855,18 +2855,18 @@ export class SimplexNoise4D {
             if (r[0] < 0) {
                 r[0] += i + 1;
             }
-            this._perm[i] = source[r[0]];
-            this._perm4D[i] = this._perm[i] & 0xfc;
+            this.#perm[i] = source[r[0]];
+            this.#perm4D[i] = this.#perm[i] & 0xfc;
             source[r[0]] = source[i];
         }
     }
-    _contribution4D(multiplier, xsb, ysb, zsb, wsb) {
-        const { _SQUISH_4D } = this;
+    #contribution4D(multiplier, xsb, ysb, zsb, wsb) {
+        const SQUISH_4D = this.#SQUISH_4D;
         return {
-            dx: -xsb - multiplier * _SQUISH_4D,
-            dy: -ysb - multiplier * _SQUISH_4D,
-            dz: -zsb - multiplier * _SQUISH_4D,
-            dw: -wsb - multiplier * _SQUISH_4D,
+            dx: -xsb - multiplier * SQUISH_4D,
+            dy: -ysb - multiplier * SQUISH_4D,
+            dz: -zsb - multiplier * SQUISH_4D,
+            dw: -wsb - multiplier * SQUISH_4D,
             xsb,
             ysb,
             zsb,

package/cjs/Classes/SimplexNoise2D.js

@@ -1,25 +1,25 @@
 import { shuffleSeed } from "../utils.js";
 const half = 0.5;
 export class SimplexNoise2D {
-    _NORM_2D;
-    _SQUISH_2D;
-    _STRETCH_2D;
-    _base2D;
-    _gradients2D;
-    _lookup;
-    _lookupPairs2D;
-    _p2D;
-    _perm;
-    _perm2D;
+    #NORM_2D;
+    #SQUISH_2D;
+    #STRETCH_2D;
+    #base2D;
+    #gradients2D;
+    #lookup;
+    #lookupPairs2D;
+    #p2D;
+    #perm;
+    #perm2D;
     constructor() {
-        this._NORM_2D = 1 / 47;
-        this._SQUISH_2D = (Math.sqrt(2 + 1) - 1) * half;
-        this._STRETCH_2D = (1 / Math.sqrt(2 + 1) - 1) * half;
-        this._base2D = [
+        this.#NORM_2D = 1 / 47;
+        this.#SQUISH_2D = (Math.sqrt(2 + 1) - 1) * half;
+        this.#STRETCH_2D = (1 / Math.sqrt(2 + 1) - 1) * half;
+        this.#base2D = [
             [1, 1, 0, 1, 0, 1, 0, 0, 0],
             [1, 1, 0, 1, 0, 1, 2, 1, 1],
         ];
-        this._gradients2D = [
+        this.#gradients2D = [
             5,
             2,
             2,
@@ -37,8 +37,8 @@ export class SimplexNoise2D {
             -2,
             -5,
         ];
-        this._lookup = [];
-        this._lookupPairs2D = [
+        this.#lookup = [];
+        this.#lookupPairs2D = [
             0,
             1,
             1,
@@ -64,7 +64,7 @@ export class SimplexNoise2D {
             43,
             3,
         ];
-        this._p2D = [
+        this.#p2D = [
             0,
             0,
             1,
@@ -90,29 +90,29 @@ export class SimplexNoise2D {
             0,
             0,
         ];
-        this._perm = new Uint8Array(256);
-        this._perm2D = new Uint8Array(256);
+        this.#perm = new Uint8Array(256);
+        this.#perm2D = new Uint8Array(256);
     }
     noise(x, y) {
-        const { _gradients2D, _NORM_2D, _SQUISH_2D, _STRETCH_2D, _lookup, _perm, _perm2D } = this, stretchOffset = (x + y) * _STRETCH_2D, xs = x + stretchOffset, ys = y + stretchOffset, xsb = Math.floor(xs), ysb = Math.floor(ys), squishOffset = (xsb + ysb) * _SQUISH_2D, dx0 = x - (xsb + squishOffset), dy0 = y - (ysb + squishOffset), xins = xs - xsb, yins = ys - ysb, inSum = xins + yins, hash = (xins - yins + 1) | (inSum << 1) | ((inSum + yins) << 2) | ((inSum + xins) << 4);
+        const gradients2D = this.#gradients2D, NORM_2D = this.#NORM_2D, SQUISH_2D = this.#SQUISH_2D, STRETCH_2D = this.#STRETCH_2D, lookup = this.#lookup, perm = this.#perm, perm2D = this.#perm2D, stretchOffset = (x + y) * STRETCH_2D, xs = x + stretchOffset, ys = y + stretchOffset, xsb = Math.floor(xs), ysb = Math.floor(ys), squishOffset = (xsb + ysb) * SQUISH_2D, dx0 = x - (xsb + squishOffset), dy0 = y - (ysb + squishOffset), xins = xs - xsb, yins = ys - ysb, inSum = xins + yins, hash = (xins - yins + 1) | (inSum << 1) | ((inSum + yins) << 2) | ((inSum + xins) << 4);
         let value = 0;
-        for (let c = _lookup[hash]; c !== undefined; c = c.next) {
+        for (let c = lookup[hash]; c !== undefined; c = c.next) {
             const dx = dx0 + c.dx, dy = dy0 + c.dy, attn = 2 - dx * dx - dy * dy;
             if (attn <= 0) {
                 continue;
             }
-            const px = xsb + c.xsb, py = ysb + c.ysb, indexPartA = _perm[px & 0xff], index = _perm2D[(indexPartA + py) & 0xff], valuePart = _gradients2D[index] * dx + _gradients2D[index + 1] * dy;
+            const px = xsb + c.xsb, py = ysb + c.ysb, indexPartA = perm[px & 0xff], index = perm2D[(indexPartA + py) & 0xff], valuePart = gradients2D[index] * dx + gradients2D[index + 1] * dy;
             value += attn * attn * attn * attn * valuePart;
         }
-        return value * _NORM_2D;
+        return value * NORM_2D;
     }
     seed(clientSeed) {
-        const { _p2D, _base2D, _lookupPairs2D } = this, contributions = [];
-        for (let i = 0; i < _p2D.length; i += 4) {
-            const baseSet = _base2D[_p2D[i]];
+        const p2D = this.#p2D, base2D = this.#base2D, lookupPairs2D = this.#lookupPairs2D, contributions = [];
+        for (let i = 0; i < p2D.length; i += 4) {
+            const baseSet = base2D[p2D[i]];
             let previous = null, current = null;
             for (let k = 0; k < baseSet.length; k += 3) {
-                current = this._contribution2D(baseSet[k], baseSet[k + 1], baseSet[k + 2]);
+                current = this.#contribution2D(baseSet[k], baseSet[k + 1], baseSet[k + 2]);
                 if (previous === null) {
                     contributions[i / 4] = current;
                 }
@@ -122,15 +122,15 @@ export class SimplexNoise2D {
                 previous = current;
             }
             if (current) {
-                current.next = this._contribution2D(_p2D[i + 1], _p2D[i + 2], _p2D[i + 3]);
+                current.next = this.#contribution2D(p2D[i + 1], p2D[i + 2], p2D[i + 3]);
             }
         }
-        this._lookup = [];
-        for (let i = 0; i < _lookupPairs2D.length; i += 2) {
-            this._lookup[_lookupPairs2D[i]] = contributions[_lookupPairs2D[i + 1]];
+        this.#lookup = [];
+        for (let i = 0; i < lookupPairs2D.length; i += 2) {
+            this.#lookup[lookupPairs2D[i]] = contributions[lookupPairs2D[i + 1]];
         }
-        this._perm = new Uint8Array(256);
-        this._perm2D = new Uint8Array(256);
+        this.#perm = new Uint8Array(256);
+        this.#perm2D = new Uint8Array(256);
         const source = new Uint8Array(256);
         for (let i = 0; i < 256; i++) {
             source[i] = i;
@@ -145,16 +145,16 @@ export class SimplexNoise2D {
             if (r[0] < 0) {
                 r[0] += i + 1;
             }
-            this._perm[i] = source[r[0]];
-            this._perm2D[i] = this._perm[i] & 0x0e;
+            this.#perm[i] = source[r[0]];
+            this.#perm2D[i] = this.#perm[i] & 0x0e;
             source[r[0]] = source[i];
         }
     }
-    _contribution2D(multiplier, xsb, ysb) {
-        const { _SQUISH_2D } = this;
+    #contribution2D(multiplier, xsb, ysb) {
+        const SQUISH_2D = this.#SQUISH_2D;
         return {
-            dx: -xsb - multiplier * _SQUISH_2D,
-            dy: -ysb - multiplier * _SQUISH_2D,
+            dx: -xsb - multiplier * SQUISH_2D,
+            dy: -ysb - multiplier * SQUISH_2D,
             xsb,
             ysb,
         };