fastnoiselite-builder 0.2.0 → 0.4.0

package/dist/tsl/index.js

@@ -1,29 +1,40 @@
 import { wgslFn as L } from "three/tsl";
-import { P as A, b as G, c as X, G as Ne, i as Ie, R as Se, f as $e, C as M, e as C, A as fe, D as h, F as _, j as w, N as f, T as m } from "../ANoiseBuilder-CexggqMu.js";
-import { k as ga } from "../ANoiseBuilder-CexggqMu.js";
+import { P as G, b as X, c as Y, G as Ie, i as Se, R as $e, f as ke, C as M, e as C, A as ce, D as h, F as _, j as w, N as f, T as m } from "../ANoiseBuilder-BWuN_IAo.js";
+import { k as Da } from "../ANoiseBuilder-BWuN_IAo.js";
+function A(d, e) {
+  if (!e) return d;
+  const l = new Set(
+    [...d.matchAll(/\bfn\s+(\w+)\s*\(/g)].map((t) => t[1])
+  ), i = new Set(
+    [...d.matchAll(/\bconst\s+(\w+)\s*:/g)].map((t) => t[1])
+  ), a = /* @__PURE__ */ new Set([...l, ...i]);
+  if (a.size === 0) return d;
+  const r = [...a].sort((t, o) => o.length - t.length), s = new RegExp(`\\b(${r.join("|")})\\b`, "g");
+  return d.replace(s, `${e}_$1`);
+}
 function E() {
-  return `const PRIME_X: i32 = ${A};
-const PRIME_Y: i32 = ${G};
-const PRIME_Z: i32 = ${X};`;
+  return `const PRIME_X: i32 = ${G};
+const PRIME_Y: i32 = ${X};
+const PRIME_Z: i32 = ${Y};`;
 }
-function Y(d, e) {
-  const t = Array.from(e).map((i) => {
+function W(d, e) {
+  const l = Array.from(e).map((i) => {
     const a = i.toString();
     return a.includes(".") || a.includes("e") ? a : a + ".0";
   }).join(", ");
-  return `const ${d}: array<f32, ${e.length}> = array<f32, ${e.length}>(${t});`;
-}
-function W() {
-  return Y("GRADIENTS_2D", Ne);
+  return `const ${d}: array<f32, ${e.length}> = array<f32, ${e.length}>(${l});`;
 }
 function j() {
-  return Y("GRADIENTS_3D", Ie);
+  return W("GRADIENTS_2D", Ie);
 }
-function ce() {
-  return Y("RAND_VECS_2D", Se);
+function V() {
+  return W("GRADIENTS_3D", Se);
 }
 function ue() {
-  return Y("RAND_VECS_3D", $e);
+  return W("RAND_VECS_2D", $e);
+}
+function Re() {
+  return W("RAND_VECS_3D", ke);
 }
 function N() {
   return `fn imul(a: i32, b: i32) -> i32 {
@@ -40,7 +51,7 @@ function S() {
   return i32(u32(seed ^ xPrimed ^ yPrimed ^ zPrimed) * 0x27d4eb2du);
 }`;
 }
-function O() {
+function q() {
   return `fn valCoordR2(seed: i32, xPrimed: i32, yPrimed: i32) -> f32 {
   var uh = u32(hashR2(seed, xPrimed, yPrimed));
   uh = uh * uh;
@@ -48,7 +59,7 @@ function O() {
   return f32(i32(uh)) * (1.0 / 2147483648.0);
 }`;
 }
-function q() {
+function J() {
   return `fn valCoordR3(seed: i32, xPrimed: i32, yPrimed: i32, zPrimed: i32) -> f32 {
   var uh = u32(hashR3(seed, xPrimed, yPrimed, zPrimed));
   uh = uh * uh;
@@ -56,7 +67,7 @@ function q() {
   return f32(i32(uh)) * (1.0 / 2147483648.0);
 }`;
 }
-function V() {
+function F() {
   return `fn gradCoordR2(seed: i32, xPrimed: i32, yPrimed: i32, xd: f32, yd: f32) -> f32 {
   var hash = hashR2(seed, xPrimed, yPrimed);
   hash = hash ^ (hash >> 15u);
@@ -66,7 +77,7 @@ function V() {
   return xd * xg + yd * yg;
 }`;
 }
-function F() {
+function T() {
   return `fn gradCoordR3(seed: i32, xPrimed: i32, yPrimed: i32, zPrimed: i32, xd: f32, yd: f32, zd: f32) -> f32 {
   var hash = hashR3(seed, xPrimed, yPrimed, zPrimed);
   hash = hash ^ (hash >> 15u);
@@ -77,34 +88,34 @@ function F() {
   return xd * xg + yd * yg + zd * zg;
 }`;
 }
-function J() {
+function Q() {
   return `fn interpHermite(t: f32) -> f32 {
   return t * t * (3.0 - 2.0 * t);
 }`;
 }
-function Q() {
+function U() {
   return `fn interpQuintic(t: f32) -> f32 {
   return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
 }`;
 }
-function U() {
+function K() {
   return `fn cubicLerp(a: f32, b: f32, c: f32, d: f32, t: f32) -> f32 {
   let p = d - c - (a - b);
   return t * t * t * p + t * t * (a - b - p) + t * (c - a) + b;
 }`;
 }
-function K() {
+function ee() {
   return `fn pingPong(t_in: f32) -> f32 {
   var t = t_in - trunc(t_in * 0.5) * 2.0;
   return select(2.0 - t, t, t < 1.0);
 }`;
 }
-function ke() {
+function be() {
   return `
 ${E()}
 ${I()}
-${O()}
-${J()}
+${q()}
+${Q()}
 
 fn value2d(seed: i32, x: f32, y: f32) -> f32 {
   let x0i = i32(floor(x));
@@ -125,12 +136,12 @@ fn value2d(seed: i32, x: f32, y: f32) -> f32 {
 }
 `;
 }
-function be() {
+function Le() {
   return `
 ${E()}
 ${S()}
-${q()}
 ${J()}
+${Q()}
 
 fn value3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
   let x0i = i32(floor(x));
@@ -160,8 +171,8 @@ fn value3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
 }
 `;
 }
-const Le = ["primes", "hashR2", "valCoordR2", "interpHermite"], we = ["primes", "hashR3", "valCoordR3", "interpHermite"];
-function Ae() {
+const we = ["primes", "hashR2", "valCoordR2", "interpHermite"], Ae = ["primes", "hashR3", "valCoordR3", "interpHermite"];
+function Ge() {
   return `
 fn value2d(seed: i32, x: f32, y: f32) -> f32 {
   let x0i = i32(floor(x));
@@ -182,7 +193,7 @@ fn value2d(seed: i32, x: f32, y: f32) -> f32 {
 }
 `;
 }
-function Ge() {
+function Xe() {
   return `
 fn value3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
   let x0i = i32(floor(x));
@@ -212,14 +223,14 @@ fn value3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
 }
 `;
 }
-const Xe = ["primes", "gradients2D", "hashR2", "gradCoordR2", "interpQuintic"], Ye = ["primes", "gradients3D", "hashR3", "gradCoordR3", "interpQuintic"];
-function We() {
+const Ye = ["primes", "gradients2D", "hashR2", "gradCoordR2", "interpQuintic"], We = ["primes", "gradients3D", "hashR3", "gradCoordR3", "interpQuintic"];
+function je() {
   return `
 ${E()}
-${W()}
+${j()}
 ${I()}
-${V()}
-${Q()}
+${F()}
+${U()}
 
 fn perlin2d(seed: i32, x: f32, y: f32) -> f32 {
   let x0i = i32(floor(x));
@@ -253,13 +264,13 @@ fn perlin2d(seed: i32, x: f32, y: f32) -> f32 {
 }
 `;
 }
-function je() {
+function Ve() {
   return `
 ${E()}
-${j()}
+${V()}
 ${S()}
-${F()}
-${Q()}
+${T()}
+${U()}
 
 fn perlin3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
   let x0i = i32(floor(x));
@@ -312,7 +323,7 @@ fn perlin3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
 }
 `;
 }
-function Ve() {
+function Fe() {
   return `fn perlin2d(seed: i32, x: f32, y: f32) -> f32 {
   let x0i = i32(floor(x));
   let y0i = i32(floor(y));
@@ -344,7 +355,7 @@ function Ve() {
   return mix(xf0, xf1, ys) * 1.4247691104677813;
 }`;
 }
-function Fe() {
+function Te() {
   return `fn perlin3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
   let x0i = i32(floor(x));
   let y0i = i32(floor(y));
@@ -395,16 +406,16 @@ function Fe() {
   return mix(yf0, yf1, zs) * 0.964921414852142333984375;
 }`;
 }
-const Re = A << 1 | 0, _e = G << 1 | 0, Te = X << 1 | 0, Ze = ["primes", "primesDouble", "imul", "hashR2", "valCoordR2", "cubicLerp"], Be = ["primes", "primesDouble", "imul", "hashR3", "valCoordR3", "cubicLerp"];
-function He() {
+const _e = G << 1 | 0, ve = X << 1 | 0, Ze = Y << 1 | 0, Be = ["primes", "primesDouble", "imul", "hashR2", "valCoordR2", "cubicLerp"], He = ["primes", "primesDouble", "imul", "hashR3", "valCoordR3", "cubicLerp"];
+function Oe() {
   return `
 ${E()}
-const PRIME_X_2: i32 = ${Re};
-const PRIME_Y_2: i32 = ${_e};
+const PRIME_X_2: i32 = ${_e};
+const PRIME_Y_2: i32 = ${ve};
 ${N()}
 ${I()}
-${O()}
-${U()}
+${q()}
+${K()}
 
 fn valuecubic2d(seed: i32, x: f32, y: f32) -> f32 {
   let fx1 = floor(x);
@@ -434,16 +445,16 @@ fn valuecubic2d(seed: i32, x: f32, y: f32) -> f32 {
 }
 `;
 }
-function Oe() {
+function qe() {
   return `
 ${E()}
-const PRIME_X_2: i32 = ${Re};
-const PRIME_Y_2: i32 = ${_e};
-const PRIME_Z_2: i32 = ${Te};
+const PRIME_X_2: i32 = ${_e};
+const PRIME_Y_2: i32 = ${ve};
+const PRIME_Z_2: i32 = ${Ze};
 ${N()}
 ${S()}
-${q()}
-${U()}
+${J()}
+${K()}
 
 fn valuecubic3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
   let fx1 = floor(x);
@@ -500,7 +511,7 @@ fn valuecubic3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
 }
 `;
 }
-function qe() {
+function Je() {
   return `
 fn valuecubic2d(seed: i32, x: f32, y: f32) -> f32 {
   let fx1 = floor(x);
@@ -530,7 +541,7 @@ fn valuecubic2d(seed: i32, x: f32, y: f32) -> f32 {
 }
 `;
 }
-function Je() {
+function Qe() {
   return `
 fn valuecubic3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
   let fx1 = floor(x);
@@ -587,30 +598,30 @@ fn valuecubic3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
 }
 `;
 }
-const ee = ["primes", "gradients2D", "imul", "hashR2", "gradCoordR2"], ae = ["primes", "gradients3D", "imul", "hashR3", "gradCoordR3"];
-function ie() {
+const ae = ["primes", "gradients2D", "imul", "hashR2", "gradCoordR2"], ie = ["primes", "gradients3D", "imul", "hashR3", "gradCoordR3"];
+function re() {
   return `
 ${E()}
-${W()}
+${j()}
 ${N()}
 ${I()}
-${V()}
+${F()}
 
-${B()}
+${H()}
 `;
 }
-function re() {
+function se() {
   return `
 ${E()}
-${j()}
+${V()}
 ${N()}
 ${S()}
-${F()}
+${T()}
 
-${H()}
+${O()}
 `;
 }
-function B() {
+function H() {
   return `fn opensimplex2_2d(seed: i32, x: f32, y: f32) -> f32 {
   let G2: f32 = 0.21132486540518713;
 
@@ -664,7 +675,7 @@ function B() {
   return (n0 + n1 + n2) * 99.83685446303647;
 }`;
 }
-function H() {
+function O() {
   return `fn opensimplex2_3d(seed_in: i32, x: f32, y: f32, z: f32) -> f32 {
   var seed = seed_in;
   var i = i32(floor(x + 0.5));
@@ -740,16 +751,16 @@ function H() {
   return value * 32.69428253173828125;
 }`;
 }
-const ve = A << 1 | 0, ze = G << 1 | 0, Qe = X << 1 | 0;
-function Ue() {
+const ze = G << 1 | 0, pe = X << 1 | 0, Ue = Y << 1 | 0;
+function Ke() {
   return `
 ${E()}
-const PRIME_X_2: i32 = ${ve};
-const PRIME_Y_2: i32 = ${ze};
-${W()}
+const PRIME_X_2: i32 = ${ze};
+const PRIME_Y_2: i32 = ${pe};
+${j()}
 ${N()}
 ${I()}
-${V()}
+${F()}
 
 fn opensimplex2s_2d(seed_in: i32, x: f32, y: f32) -> f32 {
   let seed = seed_in;
@@ -851,16 +862,16 @@ fn opensimplex2s_2d(seed_in: i32, x: f32, y: f32) -> f32 {
 }
 `;
 }
-function Ke() {
+function ea() {
   return `
 ${E()}
-const PRIME_X_2: i32 = ${ve};
-const PRIME_Y_2: i32 = ${ze};
-const PRIME_Z_2: i32 = ${Qe};
-${j()}
+const PRIME_X_2: i32 = ${ze};
+const PRIME_Y_2: i32 = ${pe};
+const PRIME_Z_2: i32 = ${Ue};
+${V()}
 ${N()}
 ${S()}
-${F()}
+${T()}
 
 fn opensimplex2s_3d(seed_in: i32, x: f32, y: f32, z: f32) -> f32 {
   let seed = seed_in;
@@ -1019,8 +1030,8 @@ fn opensimplex2s_3d(seed_in: i32, x: f32, y: f32, z: f32) -> f32 {
 }
 `;
 }
-const ea = ["primes", "primesDouble", "gradients2D", "imul", "hashR2", "gradCoordR2"], aa = ["primes", "primesDouble", "gradients3D", "imul", "hashR3", "gradCoordR3"];
-function ia() {
+const aa = ["primes", "primesDouble", "gradients2D", "imul", "hashR2", "gradCoordR2"], ia = ["primes", "primesDouble", "gradients3D", "imul", "hashR3", "gradCoordR3"];
+function ra() {
   return `
 fn opensimplex2s_2d(seed_in: i32, x: f32, y: f32) -> f32 {
   let seed = seed_in;
@@ -1122,7 +1133,7 @@ fn opensimplex2s_2d(seed_in: i32, x: f32, y: f32) -> f32 {
 }
 `;
 }
-function ra() {
+function sa() {
   return `
 fn opensimplex2s_3d(seed_in: i32, x: f32, y: f32, z: f32) -> f32 {
   let seed = seed_in;
@@ -1281,8 +1292,8 @@ fn opensimplex2s_3d(seed_in: i32, x: f32, y: f32, z: f32) -> f32 {
 }
 `;
 }
-const pe = 0.43701595, me = 0.39614353;
-function he(d) {
+const me = 0.43701595, he = 0.39614353;
+function Ee(d) {
   switch (d) {
     case M.Euclidean:
     case M.EuclideanSq:
@@ -1293,7 +1304,7 @@ function he(d) {
       return "return abs(vecX) + abs(vecY) + vecX * vecX + vecY * vecY;";
   }
 }
-function Ee(d) {
+function Me(d) {
   switch (d) {
     case M.Euclidean:
     case M.EuclideanSq:
@@ -1304,7 +1315,7 @@ function Ee(d) {
       return "return abs(vecX) + abs(vecY) + abs(vecZ) + vecX * vecX + vecY * vecY + vecZ * vecZ;";
   }
 }
-function T(d) {
+function Z(d) {
   switch (d) {
     case C.CellValue:
       return "return f32(closestHash) * (1.0 / 2147483648.0);";
@@ -1322,24 +1333,24 @@ function T(d) {
       return "return d0 / d1 - 1.0;";
   }
 }
-function sa(d, e, t) {
-  const i = pe * t, r = d === M.Euclidean && e !== C.CellValue ? `
+function ta(d, e, l) {
+  const i = me * l, r = d === M.Euclidean && e !== C.CellValue ? `
   distance0 = sqrt(distance0);
   distance1 = sqrt(distance1);` : "";
   return `
 ${E()}
 ${N()}
 ${I()}
-${ce()}
+${ue()}
 
 const CELL_JITTER_2D: f32 = ${i};
 
 fn cellDist2d(vecX: f32, vecY: f32) -> f32 {
-  ${he(d)}
+  ${Ee(d)}
 }
 
 fn cellReturn2d(d0: f32, d1: f32, closestHash: i32) -> f32 {
-  ${T(e)}
+  ${Z(e)}
 }
 
 fn cellular2d(seed: i32, x: f32, y: f32) -> f32 {
@@ -1380,24 +1391,24 @@ ${r}
 }
 `;
 }
-function ta(d, e, t) {
-  const i = me * t, r = d === M.Euclidean && e !== C.CellValue ? `
+function la(d, e, l) {
+  const i = he * l, r = d === M.Euclidean && e !== C.CellValue ? `
   distance0 = sqrt(distance0);
   distance1 = sqrt(distance1);` : "";
   return `
 ${E()}
 ${N()}
 ${S()}
-${ue()}
+${Re()}
 
 const CELL_JITTER_3D: f32 = ${i};
 
 fn cellDist3d(vecX: f32, vecY: f32, vecZ: f32) -> f32 {
-  ${Ee(d)}
+  ${Me(d)}
 }
 
 fn cellReturn3d(d0: f32, d1: f32, closestHash: i32) -> f32 {
-  ${T(e)}
+  ${Z(e)}
 }
 
 fn cellular3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
@@ -1446,20 +1457,20 @@ ${r}
 }
 `;
 }
-const la = ["primes", "imul", "hashR2", "randVecs2D"], da = ["primes", "imul", "hashR3", "randVecs3D"];
-function oa(d, e, t) {
-  const i = pe * t, r = d === M.Euclidean && e !== C.CellValue ? `
+const da = ["primes", "imul", "hashR2", "randVecs2D"], oa = ["primes", "imul", "hashR3", "randVecs3D"];
+function xa(d, e, l) {
+  const i = me * l, r = d === M.Euclidean && e !== C.CellValue ? `
   distance0 = sqrt(distance0);
   distance1 = sqrt(distance1);` : "";
   return `
 const CELL_JITTER_2D: f32 = ${i};
 
 fn cellDist2d(vecX: f32, vecY: f32) -> f32 {
-  ${he(d)}
+  ${Ee(d)}
 }
 
 fn cellReturn2d(d0: f32, d1: f32, closestHash: i32) -> f32 {
-  ${T(e)}
+  ${Z(e)}
 }
 
 fn cellular2d(seed: i32, x: f32, y: f32) -> f32 {
@@ -1500,19 +1511,19 @@ ${r}
 }
 `;
 }
-function xa(d, e, t) {
-  const i = me * t, r = d === M.Euclidean && e !== C.CellValue ? `
+function na(d, e, l) {
+  const i = he * l, r = d === M.Euclidean && e !== C.CellValue ? `
   distance0 = sqrt(distance0);
   distance1 = sqrt(distance1);` : "";
   return `
 const CELL_JITTER_3D: f32 = ${i};
 
 fn cellDist3d(vecX: f32, vecY: f32, vecZ: f32) -> f32 {
-  ${Ee(d)}
+  ${Me(d)}
 }
 
 fn cellReturn3d(d0: f32, d1: f32, closestHash: i32) -> f32 {
-  ${T(e)}
+  ${Z(e)}
 }
 
 fn cellular3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
@@ -1561,16 +1572,16 @@ ${r}
 }
 `;
 }
-function k(d, e, t, i, a, r, s, l) {
+function k(d, e, l, i, a, r, s, t) {
   return `
 ${d}
 
 fn noise(x: f32, y: f32) -> f32 {
   var sum: f32 = 0.0;
-  var amp: f32 = ${l};
+  var amp: f32 = ${t};
   var px = x;
   var py = y;
-  var s: i32 = ${t | 0};
+  var s: i32 = ${l | 0};
 
   for (var i: i32 = 0; i < ${i}; i++) {
     let n = ${e}(s, px, py);
@@ -1587,17 +1598,17 @@ fn noise(x: f32, y: f32) -> f32 {
 }
 `;
 }
-function b(d, e, t, i, a, r, s, l) {
+function b(d, e, l, i, a, r, s, t) {
   return `
 ${d}
 
 fn noise(x: f32, y: f32, z: f32) -> f32 {
   var sum: f32 = 0.0;
-  var amp: f32 = ${l};
+  var amp: f32 = ${t};
   var px = x;
   var py = y;
   var pz = z;
-  var s: i32 = ${t | 0};
+  var s: i32 = ${l | 0};
 
   for (var i: i32 = 0; i < ${i}; i++) {
     let n = ${e}(s, px, py, pz);
@@ -1615,16 +1626,16 @@ fn noise(x: f32, y: f32, z: f32) -> f32 {
 }
 `;
 }
-function se(d, e, t, i, a, r, s, l) {
+function te(d, e, l, i, a, r, s, t) {
   return `
 ${d}
 
 fn noise(x: f32, y: f32) -> f32 {
   var sum: f32 = 0.0;
-  var amp: f32 = ${l};
+  var amp: f32 = ${t};
   var px = x;
   var py = y;
-  var s: i32 = ${t | 0};
+  var s: i32 = ${l | 0};
 
   for (var i: i32 = 0; i < ${i}; i++) {
     var n = ${e}(s, px, py);
@@ -1642,17 +1653,17 @@ fn noise(x: f32, y: f32) -> f32 {
 }
 `;
 }
-function te(d, e, t, i, a, r, s, l) {
+function le(d, e, l, i, a, r, s, t) {
   return `
 ${d}
 
 fn noise(x: f32, y: f32, z: f32) -> f32 {
   var sum: f32 = 0.0;
-  var amp: f32 = ${l};
+  var amp: f32 = ${t};
   var px = x;
   var py = y;
   var pz = z;
-  var s: i32 = ${t | 0};
+  var s: i32 = ${l | 0};
 
   for (var i: i32 = 0; i < ${i}; i++) {
     var n = ${e}(s, px, py, pz);
@@ -1671,17 +1682,17 @@ fn noise(x: f32, y: f32, z: f32) -> f32 {
 }
 `;
 }
-function na(d, e, t, i, a, r, s, l, o) {
+function ya(d, e, l, i, a, r, s, t, o) {
   return `
 ${d}
-${K()}
+${ee()}
 
 fn noise(x: f32, y: f32) -> f32 {
   var sum: f32 = 0.0;
-  var amp: f32 = ${l};
+  var amp: f32 = ${t};
   var px = x;
   var py = y;
-  var s: i32 = ${t | 0};
+  var s: i32 = ${l | 0};
 
   for (var i: i32 = 0; i < ${i}; i++) {
     let n = pingPong((${e}(s, px, py) + 1.0) * ${o});
@@ -1698,18 +1709,18 @@ fn noise(x: f32, y: f32) -> f32 {
 }
 `;
 }
-function ya(d, e, t, i, a, r, s, l, o) {
+function fa(d, e, l, i, a, r, s, t, o) {
   return `
 ${d}
-${K()}
+${ee()}
 
 fn noise(x: f32, y: f32, z: f32) -> f32 {
   var sum: f32 = 0.0;
-  var amp: f32 = ${l};
+  var amp: f32 = ${t};
   var px = x;
   var py = y;
   var pz = z;
-  var s: i32 = ${t | 0};
+  var s: i32 = ${l | 0};
 
   for (var i: i32 = 0; i < ${i}; i++) {
     let n = pingPong((${e}(s, px, py, pz) + 1.0) * ${o});
@@ -1727,27 +1738,27 @@ fn noise(x: f32, y: f32, z: f32) -> f32 {
 }
 `;
 }
-const fa = {
+const ca = {
   primes: E,
-  primesDouble: () => `const PRIME_X_2: i32 = ${A << 1 | 0};
-const PRIME_Y_2: i32 = ${G << 1 | 0};
-const PRIME_Z_2: i32 = ${X << 1 | 0};`,
+  primesDouble: () => `const PRIME_X_2: i32 = ${G << 1 | 0};
+const PRIME_Y_2: i32 = ${X << 1 | 0};
+const PRIME_Z_2: i32 = ${Y << 1 | 0};`,
   imul: N,
   hashR2: I,
   hashR3: S,
-  gradients2D: W,
-  gradients3D: j,
-  randVecs2D: ce,
-  randVecs3D: ue,
-  valCoordR2: O,
-  valCoordR3: q,
-  gradCoordR2: V,
-  gradCoordR3: F,
-  interpHermite: J,
-  interpQuintic: Q,
-  cubicLerp: U,
-  pingPong: K
-}, ca = {
+  gradients2D: j,
+  gradients3D: V,
+  randVecs2D: ue,
+  randVecs3D: Re,
+  valCoordR2: q,
+  valCoordR3: J,
+  gradCoordR2: F,
+  gradCoordR3: T,
+  interpHermite: Q,
+  interpQuintic: U,
+  cubicLerp: K,
+  pingPong: ee
+}, ua = {
   primesDouble: ["primes"],
   hashR2: ["primes"],
   hashR3: ["primes"],
@@ -1756,37 +1767,37 @@ const PRIME_Z_2: i32 = ${X << 1 | 0};`,
   gradCoordR2: ["hashR2", "primes", "gradients2D"],
   gradCoordR3: ["hashR3", "primes", "gradients3D"]
 };
-function Me(...d) {
+function Pe(...d) {
   const e = /* @__PURE__ */ new Set();
-  function t(a) {
+  function l(a) {
     if (e.has(a)) return;
-    const r = ca[a];
+    const r = ua[a];
     if (r)
-      for (const s of r) t(s);
+      for (const s of r) l(s);
     e.add(a);
   }
   for (const a of d)
-    for (const r of a) t(r);
+    for (const r of a) l(r);
   const i = [];
   for (const a of e)
-    i.push(fa[a]());
+    i.push(ca[a]());
   return i.join(`
 `);
 }
-const le = [
+const de = [
   "primes",
   "imul",
   "hashR2",
   "randVecs2D",
   "interpHermite"
-], de = [
+], oe = [
   "primes",
   "imul",
   "hashR3",
   "randVecs3D",
   "interpHermite"
 ];
-function oe() {
+function xe() {
   return `
 fn basicgrid_warp2d(seed: i32, x: f32, y: f32) -> vec2<f32> {
   let x0i = i32(floor(x));
@@ -1818,7 +1829,7 @@ fn basicgrid_warp2d(seed: i32, x: f32, y: f32) -> vec2<f32> {
   );
 }`;
 }
-function xe() {
+function ne() {
   return `
 fn basicgrid_warp3d(seed: i32, x: f32, y: f32, z: f32) -> vec3<f32> {
   let x0i = i32(floor(x));
@@ -1877,30 +1888,30 @@ fn basicgrid_warp3d(seed: i32, x: f32, y: f32, z: f32) -> vec3<f32> {
   );
 }`;
 }
-const Pe = 1.7320508075688772, ua = 0.5 * (Pe - 1), P = (3 - Pe) / 6, Ra = [
+const Ce = 1.7320508075688772, Ra = 0.5 * (Ce - 1), P = (3 - Ce) / 6, _a = [
   "primes",
   "imul",
   "hashR2",
   "randVecs2D"
-], _a = [
+], va = [
   "primes",
   "imul",
   "hashR2",
   "randVecs2D",
   "gradients2D"
-], va = [
+], za = [
   "primes",
   "imul",
   "hashR3",
   "randVecs3D"
-], za = [
+], pa = [
   "primes",
   "imul",
   "hashR3",
   "randVecs3D",
   "gradients3D"
 ];
-function ne(d, e) {
+function ye(d, e) {
   return `
 fn os2_warp2d_contrib(seed: i32, ip: i32, jp: i32, dx: f32, dy: f32, a_in: f32) -> vec3<f32> {
   if (a_in <= 0.0) { return vec3<f32>(0.0, 0.0, 0.0); }
@@ -1922,7 +1933,7 @@ fn os2_warp2d_contrib(seed: i32, ip: i32, jp: i32, dx: f32, dy: f32, a_in: f32)
 }
 
 fn os2_warp2d(seed: i32, cx: f32, cy: f32) -> vec2<f32> {
-  let t0 = (cx + cy) * ${ua};
+  let t0 = (cx + cy) * ${Ra};
   let x = (cx + t0) * ${d};
   let y = (cy + t0) * ${d};
 
@@ -1969,7 +1980,7 @@ fn os2_warp2d(seed: i32, cx: f32, cy: f32) -> vec2<f32> {
   );
 }`;
 }
-function ye(d) {
+function fe(d) {
   return `
 fn os2_warp3d_contrib(s: i32, ip: i32, jp: i32, kp: i32, dx: f32, dy: f32, dz: f32, a_in: f32) -> vec3<f32> {
   if (a_in <= 0.0) { return vec3<f32>(0.0, 0.0, 0.0); }
@@ -2085,7 +2096,7 @@ fn os2_warp3d(seed_in: i32, x_in: f32, y_in: f32, z_in: f32) -> vec3<f32> {
   return vec3<f32>(vx, vy, vz);
 }`;
 }
-class Ea extends fe {
+class Ma extends ce {
   buildTSL2D() {
     const { domainWarpType: e } = this.config;
     return e === h.None ? this.buildNoWarp2D() : this.buildWithWarp2D();
@@ -2094,7 +2105,7 @@ class Ea extends fe {
    * Original path: no domain warp
    */
   buildNoWarp2D() {
-    const { seed: e, fractalType: t } = this.config, i = this.getBaseNoiseWGSL2D();
+    const { seed: e, fractalType: l } = this.config, i = this.getBaseNoiseWGSL2D();
     let a, r;
     i.needsSkew ? (a = `${i.wgsl}
 
@@ -2103,16 +2114,16 @@ fn ${i.fnName}_skewed(seed: i32, x: f32, y: f32) -> f32 {
   let t = (x + y) * F2;
   return ${i.fnName}(seed, x + t, y + t);
 }`, r = `${i.fnName}_skewed`) : (a = i.wgsl, r = i.fnName);
-    let s, l;
-    if (t === _.None)
-      l = `${r}_entry_core`, s = `${a}
+    let s, t;
+    if (l === _.None)
+      t = `${r}_entry_core`, s = `${a}
 
-fn ${l}(x: f32, y: f32) -> f32 {
+fn ${t}(x: f32, y: f32) -> f32 {
   return ${r}(${e | 0}, x, y);
 }`;
     else {
       const x = this.calculateFractalBounding();
-      switch (t) {
+      switch (l) {
         case _.FBm:
           s = k(
             a,
@@ -2126,7 +2137,7 @@ fn ${l}(x: f32, y: f32) -> f32 {
           );
           break;
         case _.Ridged:
-          s = se(
+          s = te(
             a,
             r,
             e,
@@ -2138,7 +2149,7 @@ fn ${l}(x: f32, y: f32) -> f32 {
           );
           break;
         case _.PingPong:
-          s = na(
+          s = ya(
             a,
             r,
             e,
@@ -2162,13 +2173,13 @@ fn ${l}(x: f32, y: f32) -> f32 {
             x
           );
       }
-      l = "noise";
+      t = "noise";
     }
     const o = `fn noise_entry(x_in: f32, y_in: f32) -> f32 {
-  return ${l}(x_in * ${this.config.frequency}, y_in * ${this.config.frequency});
+  return ${t}(x_in * ${this.config.frequency}, y_in * ${this.config.frequency});
 }
 ${s}`;
-    return L(o);
+    return L(A(o, this._prefix));
   }
   /**
    * Warp-enabled path: single wgslFn with deduplicated helpers
@@ -2176,16 +2187,16 @@ ${s}`;
   buildWithWarp2D() {
     const {
       seed: e,
-      fractalType: t,
+      fractalType: l,
       frequency: i,
       domainWarpFrequency: a,
       domainWarpFractalType: r,
       domainWarpFractalOctaves: s,
-      domainWarpFractalLacunarity: l,
+      domainWarpFractalLacunarity: t,
       domainWarpFractalGain: o
     } = this.config, x = this.calculateWarpFractalBounding(), z = this.config.domainWarpAmplitude * x, n = this.getWarpAmplitudeMultiplier(), y = this.getBaseNoiseWGSLCore2D(), c = this.getWarpWGSL2D(), p = [y.helpers, c.helpers];
-    t === _.PingPong && p.push(["pingPong"]);
-    const R = Me(...p);
+    l === _.PingPong && p.push(["pingPong"]);
+    const R = Pe(...p);
     let v = y.fnName, u = y.core;
     y.needsSkew && (u += `
 
@@ -2198,7 +2209,7 @@ fn ${y.fnName}_skewed(seed: i32, x: f32, y: f32) -> f32 {
       u,
       v,
       e,
-      t
+      l
     ), $ = `fn noise_entry(x_in: f32, y_in: f32) -> f32 {
   var x = x_in;
   var y = y_in;
@@ -2207,7 +2218,7 @@ ${this.buildWarpDispatch2D(
       a,
       r,
       s,
-      l,
+      t,
       o,
       z,
       n,
@@ -2218,11 +2229,11 @@ ${this.buildWarpDispatch2D(
 ${R}
 ${c.core}
 ${D.wgsl}`;
-    return L($);
+    return L(A($, this._prefix));
   }
-  buildWarpDispatch2D(e, t, i, a, r, s, l, o, x) {
+  buildWarpDispatch2D(e, l, i, a, r, s, t, o, x) {
     if (i === w.None) {
-      const y = l * o;
+      const y = t * o;
       return `  // Domain warp
   {
     let warp_d = ${x}(${e | 0}, x, y);
@@ -2234,7 +2245,7 @@ ${D.wgsl}`;
     let n = `  // Fractal domain warp
 `;
     if (z) {
-      let y = l;
+      let y = t;
       for (let c = 0; c < a; c++) {
         const p = e + c | 0, R = y * o;
         n += `  {
@@ -2248,7 +2259,7 @@ ${D.wgsl}`;
       n += `  var dx: f32 = 0.0;
   var dy: f32 = 0.0;
 `;
-      let y = l;
+      let y = t;
       for (let c = 0; c < a; c++) {
         const p = e + c | 0, R = y * o;
         n += `  {
@@ -2264,18 +2275,18 @@ ${D.wgsl}`;
     }
     return n;
   }
-  buildNoiseFractal2DCore(e, t, i, a) {
+  buildNoiseFractal2DCore(e, l, i, a) {
     if (a === _.None) {
-      const y = `${t}_entry_core`;
+      const y = `${l}_entry_core`;
       return { wgsl: `${e}
 
 fn ${y}(x: f32, y: f32) -> f32 {
-  return ${t}(${i | 0}, x, y);
+  return ${l}(${i | 0}, x, y);
 }`, fnName: y };
     }
     const r = this.calculateFractalBounding(), {
       fractalOctaves: s,
-      fractalLacunarity: l,
+      fractalLacunarity: t,
       fractalGain: o,
       fractalWeightedStrength: x,
       fractalPingPongStrength: z
@@ -2285,22 +2296,22 @@ fn ${y}(x: f32, y: f32) -> f32 {
       case _.FBm:
         n = k(
           e,
-          t,
+          l,
           i,
           s,
-          l,
+          t,
           o,
           x,
           r
         );
         break;
       case _.Ridged:
-        n = se(
+        n = te(
           e,
-          t,
+          l,
           i,
           s,
-          l,
+          t,
           o,
           x,
           r
@@ -2317,12 +2328,12 @@ fn noise(x: f32, y: f32) -> f32 {
   var s: i32 = ${i | 0};
 
   for (var i: i32 = 0; i < ${s}; i++) {
-    let n = pingPong((${t}(s, px, py) + 1.0) * ${z});
+    let n = pingPong((${l}(s, px, py) + 1.0) * ${z});
     sum += (n - 0.5) * 2.0 * amp;
     amp *= mix(1.0, n, ${x});
 
-    px *= ${l};
-    py *= ${l};
+    px *= ${t};
+    py *= ${t};
     amp *= ${o};
     s += 1;
   }
@@ -2333,10 +2344,10 @@ fn noise(x: f32, y: f32) -> f32 {
       default:
         n = k(
           e,
-          t,
+          l,
           i,
           s,
-          l,
+          t,
           o,
           x,
           r
@@ -2348,33 +2359,33 @@ fn noise(x: f32, y: f32) -> f32 {
     switch (this.config.domainWarpType) {
       case h.BasicGrid:
         return {
-          core: oe(),
+          core: xe(),
           fnName: "basicgrid_warp2d",
-          helpers: le
+          helpers: de
         };
       case h.OpenSimplex2:
         return {
-          core: ne(
+          core: ye(
             this.config.domainWarpFrequency,
             !1
           ),
           fnName: "os2_warp2d",
-          helpers: _a
+          helpers: va
         };
       case h.OpenSimplex2Reduced:
         return {
-          core: ne(
+          core: ye(
             this.config.domainWarpFrequency,
             !0
           ),
           fnName: "os2_warp2d",
-          helpers: Ra
+          helpers: _a
         };
       default:
         return {
-          core: oe(),
+          core: xe(),
           fnName: "basicgrid_warp2d",
-          helpers: le
+          helpers: de
         };
     }
   }
@@ -2382,55 +2393,55 @@ fn noise(x: f32, y: f32) -> f32 {
     switch (this.config.noiseType) {
       case f.Value:
         return {
-          core: Ae(),
+          core: Ge(),
           fnName: "value2d",
-          helpers: Le,
+          helpers: we,
           needsSkew: !1
         };
       case f.Perlin:
         return {
-          core: Ve(),
+          core: Fe(),
           fnName: "perlin2d",
-          helpers: Xe,
+          helpers: Ye,
           needsSkew: !1
         };
       case f.ValueCubic:
         return {
-          core: qe(),
+          core: Je(),
           fnName: "valuecubic2d",
-          helpers: Ze,
+          helpers: Be,
           needsSkew: !1
         };
       case f.OpenSimplex2:
         return {
-          core: B(),
+          core: H(),
           fnName: "opensimplex2_2d",
-          helpers: ee,
+          helpers: ae,
           needsSkew: !0
         };
       case f.OpenSimplex2S:
         return {
-          core: ia(),
+          core: ra(),
           fnName: "opensimplex2s_2d",
-          helpers: ea,
+          helpers: aa,
           needsSkew: !0
         };
       case f.Cellular:
         return {
-          core: oa(
+          core: xa(
             this.config.cellularDistanceFunction,
             this.config.cellularReturnType,
             this.config.cellularJitter
           ),
           fnName: "cellular2d",
-          helpers: la,
+          helpers: da,
           needsSkew: !1
         };
       default:
         return {
-          core: B(),
+          core: H(),
           fnName: "opensimplex2_2d",
-          helpers: ee,
+          helpers: ae,
           needsSkew: !0
         };
     }
@@ -2439,37 +2450,37 @@ fn noise(x: f32, y: f32) -> f32 {
     switch (this.config.noiseType) {
       case f.Value:
         return {
-          wgsl: ke(),
+          wgsl: be(),
           fnName: "value2d",
           needsSkew: !1
         };
       case f.Perlin:
         return {
-          wgsl: We(),
+          wgsl: je(),
           fnName: "perlin2d",
           needsSkew: !1
         };
       case f.ValueCubic:
         return {
-          wgsl: He(),
+          wgsl: Oe(),
           fnName: "valuecubic2d",
           needsSkew: !1
         };
       case f.OpenSimplex2:
         return {
-          wgsl: ie(),
+          wgsl: re(),
           fnName: "opensimplex2_2d",
           needsSkew: !0
         };
       case f.OpenSimplex2S:
         return {
-          wgsl: Ue(),
+          wgsl: Ke(),
           fnName: "opensimplex2s_2d",
           needsSkew: !0
         };
       case f.Cellular:
         return {
-          wgsl: sa(
+          wgsl: ta(
             this.config.cellularDistanceFunction,
             this.config.cellularReturnType,
             this.config.cellularJitter
@@ -2479,14 +2490,14 @@ fn noise(x: f32, y: f32) -> f32 {
         };
       default:
         return {
-          wgsl: ie(),
+          wgsl: re(),
           fnName: "opensimplex2_2d",
           needsSkew: !0
         };
     }
   }
 }
-function Z(d) {
+function B(d) {
   switch (d) {
     case m.ImproveXYPlanes:
       return `{
@@ -2517,32 +2528,32 @@ function Z(d) {
       return "";
   }
 }
-class Ma extends fe {
+class Pa extends ce {
   buildTSL3D() {
     const {
       seed: e,
-      noiseType: t,
+      noiseType: l,
       fractalType: i,
       frequency: a,
       rotationType3D: r,
       domainWarpType: s
     } = this.config;
-    let l, o;
+    let t, o;
     switch (r) {
       case m.ImproveXYPlanes:
-        l = m.ImproveXYPlanes, o = m.ImproveXYPlanes;
+        t = m.ImproveXYPlanes, o = m.ImproveXYPlanes;
         break;
       case m.ImproveXZPlanes:
-        l = m.ImproveXZPlanes, o = m.ImproveXZPlanes;
+        t = m.ImproveXZPlanes, o = m.ImproveXZPlanes;
         break;
       default:
-        switch (t) {
+        switch (l) {
           case f.OpenSimplex2:
           case f.OpenSimplex2S:
-            l = m.DefaultOpenSimplex2;
+            t = m.DefaultOpenSimplex2;
             break;
           default:
-            l = m.None;
+            t = m.None;
         }
         switch (s) {
           case h.OpenSimplex2:
@@ -2555,24 +2566,24 @@ class Ma extends fe {
     }
     return s === h.None ? this.buildNoWarp3D(
       e,
-      t,
+      l,
       i,
       a,
-      l
+      t
     ) : this.buildWithWarp3D(
       e,
-      t,
+      l,
       i,
       a,
-      l,
+      t,
       o
     );
   }
   /**
    * Original path: no domain warp, unchanged from before
    */
-  buildNoWarp3D(e, t, i, a, r) {
-    const s = this.getBaseNoiseWGSL3D(), l = Z(r);
+  buildNoWarp3D(e, l, i, a, r) {
+    const s = this.getBaseNoiseWGSL3D(), t = B(r);
     let o, x;
     if (i === _.None)
       o = s.wgsl, x = s.fnName, o += `
@@ -2596,7 +2607,7 @@ fn noise_core(x: f32, y: f32, z: f32) -> f32 {
           );
           break;
         case _.Ridged:
-          o = te(
+          o = le(
             s.wgsl,
             s.fnName,
             e,
@@ -2608,7 +2619,7 @@ fn noise_core(x: f32, y: f32, z: f32) -> f32 {
           );
           break;
         case _.PingPong:
-          o = ya(
+          o = fa(
             s.wgsl,
             s.fnName,
             e,
@@ -2638,18 +2649,18 @@ fn noise_core(x: f32, y: f32, z: f32) -> f32 {
   var x = x_in * ${a};
   var y = y_in * ${a};
   var z = z_in * ${a};
-  ${l}
+  ${t}
   return ${x}(x, y, z);
 }
 ${o}`;
-    return L(z);
+    return L(A(z, this._prefix));
   }
   /**
    * Warp-enabled path: single wgslFn with deduplicated helpers
    */
-  buildWithWarp3D(e, t, i, a, r, s) {
+  buildWithWarp3D(e, l, i, a, r, s) {
     const {
-      domainWarpType: l,
+      domainWarpType: t,
       domainWarpFrequency: o,
       domainWarpFractalType: x,
       domainWarpFractalOctaves: z,
@@ -2657,18 +2668,18 @@ ${o}`;
       domainWarpFractalGain: y
     } = this.config, c = this.calculateWarpFractalBounding(), p = this.config.domainWarpAmplitude * c, R = this.getWarpAmplitudeMultiplier3D(), v = this.getBaseNoiseWGSLCore3D(), u = this.getWarpWGSL3D(), D = [v.helpers, u.helpers];
     i === _.PingPong && D.push(["pingPong"]);
-    const g = Me(...D), $ = this.buildNoiseFractal3DCore(
+    const g = Pe(...D), $ = this.buildNoiseFractal3DCore(
       v.core,
       v.fnName,
       e,
       i
-    ), Ce = Z(s), ge = Z(r), De = `fn noise_entry(x_in: f32, y_in: f32, z_in: f32) -> f32 {
+    ), ge = B(s), De = B(r), Ne = `fn noise_entry(x_in: f32, y_in: f32, z_in: f32) -> f32 {
   var x = x_in;
   var y = y_in;
   var z = z_in;
 ${this.buildWarpDispatch3D(
       e,
-      l,
+      t,
       o,
       x,
       z,
@@ -2676,25 +2687,25 @@ ${this.buildWarpDispatch3D(
       y,
       p,
       R,
-      Ce,
+      ge,
       u.fnName
     )}
   x *= ${a};
   y *= ${a};
   z *= ${a};
-  ${ge}
+  ${De}
   return ${$.fnName}(x, y, z);
 }
 ${g}
 ${u.core}
 ${$.wgsl}`;
-    return L(De);
+    return L(A(Ne, this._prefix));
   }
   /**
    * Build warp dispatch code for the entry function.
    * Warp functions return unit displacement; amplitude is applied here.
    */
-  buildWarpDispatch3D(e, t, i, a, r, s, l, o, x, z, n) {
+  buildWarpDispatch3D(e, l, i, a, r, s, t, o, x, z, n) {
     const y = z ? z.replace(/\bx\b/g, "wx").replace(/\by\b/g, "wy").replace(/\bz\b/g, "wz") : "";
     if (a === w.None) {
       const R = o * x;
@@ -2733,7 +2744,7 @@ ${$.wgsl}`;
     y += wd${u}.y * ${g};
     z += wd${u}.z * ${g};
   }
-`, R *= l, v *= s;
+`, R *= t, v *= s;
       }
     } else {
       p += `  var dx: f32 = 0.0;
@@ -2756,7 +2767,7 @@ ${$.wgsl}`;
     dy += wd${u}.y * ${g};
     dz += wd${u}.z * ${g};
   }
-`, R *= l, v *= s;
+`, R *= t, v *= s;
       }
       p += `  x += dx;
   y += dy;
@@ -2768,16 +2779,16 @@ ${$.wgsl}`;
   /**
    * Build noise + fractal WGSL from core-only noise (no helpers)
    */
-  buildNoiseFractal3DCore(e, t, i, a) {
+  buildNoiseFractal3DCore(e, l, i, a) {
     if (a === _.None)
       return { wgsl: `${e}
 
 fn noise_core(x: f32, y: f32, z: f32) -> f32 {
-  return ${t}(${i | 0}, x, y, z);
+  return ${l}(${i | 0}, x, y, z);
 }`, fnName: "noise_core" };
     const r = this.calculateFractalBounding(), {
       fractalOctaves: s,
-      fractalLacunarity: l,
+      fractalLacunarity: t,
       fractalGain: o,
       fractalWeightedStrength: x,
       fractalPingPongStrength: z
@@ -2787,22 +2798,22 @@ fn noise_core(x: f32, y: f32, z: f32) -> f32 {
       case _.FBm:
         n = b(
           e,
-          t,
+          l,
           i,
           s,
-          l,
+          t,
           o,
           x,
           r
         );
         break;
       case _.Ridged:
-        n = te(
+        n = le(
           e,
-          t,
+          l,
           i,
           s,
-          l,
+          t,
           o,
           x,
           r
@@ -2820,13 +2831,13 @@ fn noise(x: f32, y: f32, z: f32) -> f32 {
   var s: i32 = ${i | 0};
 
   for (var i: i32 = 0; i < ${s}; i++) {
-    let n = pingPong((${t}(s, px, py, pz) + 1.0) * ${z});
+    let n = pingPong((${l}(s, px, py, pz) + 1.0) * ${z});
     sum += (n - 0.5) * 2.0 * amp;
     amp *= mix(1.0, n, ${x});
 
-    px *= ${l};
-    py *= ${l};
-    pz *= ${l};
+    px *= ${t};
+    py *= ${t};
+    pz *= ${t};
     amp *= ${o};
     s += 1;
   }
@@ -2837,10 +2848,10 @@ fn noise(x: f32, y: f32, z: f32) -> f32 {
       default:
         n = b(
           e,
-          t,
+          l,
           i,
           s,
-          l,
+          t,
           o,
           x,
           r
@@ -2855,27 +2866,27 @@ fn noise(x: f32, y: f32, z: f32) -> f32 {
     switch (this.config.domainWarpType) {
       case h.BasicGrid:
         return {
-          core: xe(),
+          core: ne(),
           fnName: "basicgrid_warp3d",
-          helpers: de
+          helpers: oe
         };
       case h.OpenSimplex2:
         return {
-          core: ye(!1),
+          core: fe(!1),
           fnName: "os2_warp3d",
-          helpers: za
+          helpers: pa
         };
       case h.OpenSimplex2Reduced:
         return {
-          core: ye(!0),
+          core: fe(!0),
           fnName: "os2_warp3d",
-          helpers: va
+          helpers: za
         };
       default:
         return {
-          core: xe(),
+          core: ne(),
           fnName: "basicgrid_warp3d",
-          helpers: de
+          helpers: oe
         };
     }
   }
@@ -2886,49 +2897,49 @@ fn noise(x: f32, y: f32, z: f32) -> f32 {
     switch (this.config.noiseType) {
       case f.Value:
         return {
-          core: Ge(),
+          core: Xe(),
           fnName: "value3d",
-          helpers: we
+          helpers: Ae
         };
       case f.Perlin:
         return {
-          core: Fe(),
+          core: Te(),
           fnName: "perlin3d",
-          helpers: Ye
+          helpers: We
         };
       case f.ValueCubic:
         return {
-          core: Je(),
+          core: Qe(),
           fnName: "valuecubic3d",
-          helpers: Be
+          helpers: He
         };
       case f.OpenSimplex2:
         return {
-          core: H(),
+          core: O(),
           fnName: "opensimplex2_3d",
-          helpers: ae
+          helpers: ie
         };
       case f.OpenSimplex2S:
         return {
-          core: ra(),
+          core: sa(),
           fnName: "opensimplex2s_3d",
-          helpers: aa
+          helpers: ia
         };
       case f.Cellular:
         return {
-          core: xa(
+          core: na(
             this.config.cellularDistanceFunction,
             this.config.cellularReturnType,
             this.config.cellularJitter
           ),
           fnName: "cellular3d",
-          helpers: da
+          helpers: oa
         };
       default:
         return {
-          core: H(),
+          core: O(),
           fnName: "opensimplex2_3d",
-          helpers: ae
+          helpers: ie
         };
     }
   }
@@ -2949,27 +2960,27 @@ fn noise(x: f32, y: f32, z: f32) -> f32 {
   getBaseNoiseWGSL3D() {
     switch (this.config.noiseType) {
       case f.Value:
-        return { wgsl: be(), fnName: "value3d" };
+        return { wgsl: Le(), fnName: "value3d" };
       case f.Perlin:
-        return { wgsl: je(), fnName: "perlin3d" };
+        return { wgsl: Ve(), fnName: "perlin3d" };
       case f.ValueCubic:
         return {
-          wgsl: Oe(),
+          wgsl: qe(),
           fnName: "valuecubic3d"
         };
       case f.OpenSimplex2:
         return {
-          wgsl: re(),
+          wgsl: se(),
           fnName: "opensimplex2_3d"
         };
       case f.OpenSimplex2S:
         return {
-          wgsl: Ke(),
+          wgsl: ea(),
           fnName: "opensimplex2s_3d"
         };
       case f.Cellular:
         return {
-          wgsl: ta(
+          wgsl: la(
             this.config.cellularDistanceFunction,
             this.config.cellularReturnType,
             this.config.cellularJitter
@@ -2978,7 +2989,7 @@ fn noise(x: f32, y: f32, z: f32) -> f32 {
         };
       default:
         return {
-          wgsl: re(),
+          wgsl: se(),
           fnName: "opensimplex2_3d"
         };
     }
@@ -2991,8 +3002,8 @@ export {
   h as DomainWarpType,
   _ as FractalType,
   f as NoiseType,
-  ga as RotationType3D,
-  Ea as TSLNoiseBuilder2D,
-  Ma as TSLNoiseBuilder3D,
+  Da as RotationType3D,
+  Ma as TSLNoiseBuilder2D,
+  Pa as TSLNoiseBuilder3D,
   m as TransformType3D
 };