fastnoiselite-builder 0.1.0 → 0.2.0

package/dist/tsl/index.js

@@ -0,0 +1,2998 @@
+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";
+function E() {
+  return `const PRIME_X: i32 = ${A};
+const PRIME_Y: i32 = ${G};
+const PRIME_Z: i32 = ${X};`;
+}
+function Y(d, e) {
+  const t = 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);
+}
+function j() {
+  return Y("GRADIENTS_3D", Ie);
+}
+function ce() {
+  return Y("RAND_VECS_2D", Se);
+}
+function ue() {
+  return Y("RAND_VECS_3D", $e);
+}
+function N() {
+  return `fn imul(a: i32, b: i32) -> i32 {
+  return i32(u32(a) * u32(b));
+}`;
+}
+function I() {
+  return `fn hashR2(seed: i32, xPrimed: i32, yPrimed: i32) -> i32 {
+  return i32(u32(seed ^ xPrimed ^ yPrimed) * 0x27d4eb2du);
+}`;
+}
+function S() {
+  return `fn hashR3(seed: i32, xPrimed: i32, yPrimed: i32, zPrimed: i32) -> i32 {
+  return i32(u32(seed ^ xPrimed ^ yPrimed ^ zPrimed) * 0x27d4eb2du);
+}`;
+}
+function O() {
+  return `fn valCoordR2(seed: i32, xPrimed: i32, yPrimed: i32) -> f32 {
+  var uh = u32(hashR2(seed, xPrimed, yPrimed));
+  uh = uh * uh;
+  uh = uh ^ (uh << 19u);
+  return f32(i32(uh)) * (1.0 / 2147483648.0);
+}`;
+}
+function q() {
+  return `fn valCoordR3(seed: i32, xPrimed: i32, yPrimed: i32, zPrimed: i32) -> f32 {
+  var uh = u32(hashR3(seed, xPrimed, yPrimed, zPrimed));
+  uh = uh * uh;
+  uh = uh ^ (uh << 19u);
+  return f32(i32(uh)) * (1.0 / 2147483648.0);
+}`;
+}
+function V() {
+  return `fn gradCoordR2(seed: i32, xPrimed: i32, yPrimed: i32, xd: f32, yd: f32) -> f32 {
+  var hash = hashR2(seed, xPrimed, yPrimed);
+  hash = hash ^ (hash >> 15u);
+  hash = hash & 254;
+  let xg = GRADIENTS_2D[hash];
+  let yg = GRADIENTS_2D[hash | 1];
+  return xd * xg + yd * yg;
+}`;
+}
+function F() {
+  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);
+  hash = hash & 252;
+  let xg = GRADIENTS_3D[hash];
+  let yg = GRADIENTS_3D[hash | 1];
+  let zg = GRADIENTS_3D[hash | 2];
+  return xd * xg + yd * yg + zd * zg;
+}`;
+}
+function J() {
+  return `fn interpHermite(t: f32) -> f32 {
+  return t * t * (3.0 - 2.0 * t);
+}`;
+}
+function Q() {
+  return `fn interpQuintic(t: f32) -> f32 {
+  return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+}`;
+}
+function U() {
+  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() {
+  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() {
+  return `
+${E()}
+${I()}
+${O()}
+${J()}
+
+fn value2d(seed: i32, x: f32, y: f32) -> f32 {
+  let x0i = i32(floor(x));
+  let y0i = i32(floor(y));
+
+  let xs = interpHermite(x - f32(x0i));
+  let ys = interpHermite(y - f32(y0i));
+
+  let x0 = x0i * PRIME_X;
+  let y0 = y0i * PRIME_Y;
+  let x1 = x0 + PRIME_X;
+  let y1 = y0 + PRIME_Y;
+
+  let xf0 = mix(valCoordR2(seed, x0, y0), valCoordR2(seed, x1, y0), xs);
+  let xf1 = mix(valCoordR2(seed, x0, y1), valCoordR2(seed, x1, y1), xs);
+
+  return mix(xf0, xf1, ys);
+}
+`;
+}
+function be() {
+  return `
+${E()}
+${S()}
+${q()}
+${J()}
+
+fn value3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
+  let x0i = i32(floor(x));
+  let y0i = i32(floor(y));
+  let z0i = i32(floor(z));
+
+  let xs = interpHermite(x - f32(x0i));
+  let ys = interpHermite(y - f32(y0i));
+  let zs = interpHermite(z - f32(z0i));
+
+  let x0 = x0i * PRIME_X;
+  let y0 = y0i * PRIME_Y;
+  let z0 = z0i * PRIME_Z;
+  let x1 = x0 + PRIME_X;
+  let y1 = y0 + PRIME_Y;
+  let z1 = z0 + PRIME_Z;
+
+  let xf00 = mix(valCoordR3(seed, x0, y0, z0), valCoordR3(seed, x1, y0, z0), xs);
+  let xf10 = mix(valCoordR3(seed, x0, y1, z0), valCoordR3(seed, x1, y1, z0), xs);
+  let xf01 = mix(valCoordR3(seed, x0, y0, z1), valCoordR3(seed, x1, y0, z1), xs);
+  let xf11 = mix(valCoordR3(seed, x0, y1, z1), valCoordR3(seed, x1, y1, z1), xs);
+
+  let yf0 = mix(xf00, xf10, ys);
+  let yf1 = mix(xf01, xf11, ys);
+
+  return mix(yf0, yf1, zs);
+}
+`;
+}
+const Le = ["primes", "hashR2", "valCoordR2", "interpHermite"], we = ["primes", "hashR3", "valCoordR3", "interpHermite"];
+function Ae() {
+  return `
+fn value2d(seed: i32, x: f32, y: f32) -> f32 {
+  let x0i = i32(floor(x));
+  let y0i = i32(floor(y));
+
+  let xs = interpHermite(x - f32(x0i));
+  let ys = interpHermite(y - f32(y0i));
+
+  let x0 = x0i * PRIME_X;
+  let y0 = y0i * PRIME_Y;
+  let x1 = x0 + PRIME_X;
+  let y1 = y0 + PRIME_Y;
+
+  let xf0 = mix(valCoordR2(seed, x0, y0), valCoordR2(seed, x1, y0), xs);
+  let xf1 = mix(valCoordR2(seed, x0, y1), valCoordR2(seed, x1, y1), xs);
+
+  return mix(xf0, xf1, ys);
+}
+`;
+}
+function Ge() {
+  return `
+fn value3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
+  let x0i = i32(floor(x));
+  let y0i = i32(floor(y));
+  let z0i = i32(floor(z));
+
+  let xs = interpHermite(x - f32(x0i));
+  let ys = interpHermite(y - f32(y0i));
+  let zs = interpHermite(z - f32(z0i));
+
+  let x0 = x0i * PRIME_X;
+  let y0 = y0i * PRIME_Y;
+  let z0 = z0i * PRIME_Z;
+  let x1 = x0 + PRIME_X;
+  let y1 = y0 + PRIME_Y;
+  let z1 = z0 + PRIME_Z;
+
+  let xf00 = mix(valCoordR3(seed, x0, y0, z0), valCoordR3(seed, x1, y0, z0), xs);
+  let xf10 = mix(valCoordR3(seed, x0, y1, z0), valCoordR3(seed, x1, y1, z0), xs);
+  let xf01 = mix(valCoordR3(seed, x0, y0, z1), valCoordR3(seed, x1, y0, z1), xs);
+  let xf11 = mix(valCoordR3(seed, x0, y1, z1), valCoordR3(seed, x1, y1, z1), xs);
+
+  let yf0 = mix(xf00, xf10, ys);
+  let yf1 = mix(xf01, xf11, ys);
+
+  return mix(yf0, yf1, zs);
+}
+`;
+}
+const Xe = ["primes", "gradients2D", "hashR2", "gradCoordR2", "interpQuintic"], Ye = ["primes", "gradients3D", "hashR3", "gradCoordR3", "interpQuintic"];
+function We() {
+  return `
+${E()}
+${W()}
+${I()}
+${V()}
+${Q()}
+
+fn perlin2d(seed: i32, x: f32, y: f32) -> f32 {
+  let x0i = i32(floor(x));
+  let y0i = i32(floor(y));
+
+  let xd0 = x - f32(x0i);
+  let yd0 = y - f32(y0i);
+  let xd1 = xd0 - 1.0;
+  let yd1 = yd0 - 1.0;
+
+  let xs = interpQuintic(xd0);
+  let ys = interpQuintic(yd0);
+
+  let x0 = x0i * PRIME_X;
+  let y0 = y0i * PRIME_Y;
+  let x1 = x0 + PRIME_X;
+  let y1 = y0 + PRIME_Y;
+
+  let xf0 = mix(
+    gradCoordR2(seed, x0, y0, xd0, yd0),
+    gradCoordR2(seed, x1, y0, xd1, yd0),
+    xs
+  );
+  let xf1 = mix(
+    gradCoordR2(seed, x0, y1, xd0, yd1),
+    gradCoordR2(seed, x1, y1, xd1, yd1),
+    xs
+  );
+
+  return mix(xf0, xf1, ys) * 1.4247691104677813;
+}
+`;
+}
+function je() {
+  return `
+${E()}
+${j()}
+${S()}
+${F()}
+${Q()}
+
+fn perlin3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
+  let x0i = i32(floor(x));
+  let y0i = i32(floor(y));
+  let z0i = i32(floor(z));
+
+  let xd0 = x - f32(x0i);
+  let yd0 = y - f32(y0i);
+  let zd0 = z - f32(z0i);
+  let xd1 = xd0 - 1.0;
+  let yd1 = yd0 - 1.0;
+  let zd1 = zd0 - 1.0;
+
+  let xs = interpQuintic(xd0);
+  let ys = interpQuintic(yd0);
+  let zs = interpQuintic(zd0);
+
+  let x0 = x0i * PRIME_X;
+  let y0 = y0i * PRIME_Y;
+  let z0 = z0i * PRIME_Z;
+  let x1 = x0 + PRIME_X;
+  let y1 = y0 + PRIME_Y;
+  let z1 = z0 + PRIME_Z;
+
+  let xf00 = mix(
+    gradCoordR3(seed, x0, y0, z0, xd0, yd0, zd0),
+    gradCoordR3(seed, x1, y0, z0, xd1, yd0, zd0),
+    xs
+  );
+  let xf10 = mix(
+    gradCoordR3(seed, x0, y1, z0, xd0, yd1, zd0),
+    gradCoordR3(seed, x1, y1, z0, xd1, yd1, zd0),
+    xs
+  );
+  let xf01 = mix(
+    gradCoordR3(seed, x0, y0, z1, xd0, yd0, zd1),
+    gradCoordR3(seed, x1, y0, z1, xd1, yd0, zd1),
+    xs
+  );
+  let xf11 = mix(
+    gradCoordR3(seed, x0, y1, z1, xd0, yd1, zd1),
+    gradCoordR3(seed, x1, y1, z1, xd1, yd1, zd1),
+    xs
+  );
+
+  let yf0 = mix(xf00, xf10, ys);
+  let yf1 = mix(xf01, xf11, ys);
+
+  return mix(yf0, yf1, zs) * 0.964921414852142333984375;
+}
+`;
+}
+function Ve() {
+  return `fn perlin2d(seed: i32, x: f32, y: f32) -> f32 {
+  let x0i = i32(floor(x));
+  let y0i = i32(floor(y));
+
+  let xd0 = x - f32(x0i);
+  let yd0 = y - f32(y0i);
+  let xd1 = xd0 - 1.0;
+  let yd1 = yd0 - 1.0;
+
+  let xs = interpQuintic(xd0);
+  let ys = interpQuintic(yd0);
+
+  let x0 = x0i * PRIME_X;
+  let y0 = y0i * PRIME_Y;
+  let x1 = x0 + PRIME_X;
+  let y1 = y0 + PRIME_Y;
+
+  let xf0 = mix(
+    gradCoordR2(seed, x0, y0, xd0, yd0),
+    gradCoordR2(seed, x1, y0, xd1, yd0),
+    xs
+  );
+  let xf1 = mix(
+    gradCoordR2(seed, x0, y1, xd0, yd1),
+    gradCoordR2(seed, x1, y1, xd1, yd1),
+    xs
+  );
+
+  return mix(xf0, xf1, ys) * 1.4247691104677813;
+}`;
+}
+function Fe() {
+  return `fn perlin3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
+  let x0i = i32(floor(x));
+  let y0i = i32(floor(y));
+  let z0i = i32(floor(z));
+
+  let xd0 = x - f32(x0i);
+  let yd0 = y - f32(y0i);
+  let zd0 = z - f32(z0i);
+  let xd1 = xd0 - 1.0;
+  let yd1 = yd0 - 1.0;
+  let zd1 = zd0 - 1.0;
+
+  let xs = interpQuintic(xd0);
+  let ys = interpQuintic(yd0);
+  let zs = interpQuintic(zd0);
+
+  let x0 = x0i * PRIME_X;
+  let y0 = y0i * PRIME_Y;
+  let z0 = z0i * PRIME_Z;
+  let x1 = x0 + PRIME_X;
+  let y1 = y0 + PRIME_Y;
+  let z1 = z0 + PRIME_Z;
+
+  let xf00 = mix(
+    gradCoordR3(seed, x0, y0, z0, xd0, yd0, zd0),
+    gradCoordR3(seed, x1, y0, z0, xd1, yd0, zd0),
+    xs
+  );
+  let xf10 = mix(
+    gradCoordR3(seed, x0, y1, z0, xd0, yd1, zd0),
+    gradCoordR3(seed, x1, y1, z0, xd1, yd1, zd0),
+    xs
+  );
+  let xf01 = mix(
+    gradCoordR3(seed, x0, y0, z1, xd0, yd0, zd1),
+    gradCoordR3(seed, x1, y0, z1, xd1, yd0, zd1),
+    xs
+  );
+  let xf11 = mix(
+    gradCoordR3(seed, x0, y1, z1, xd0, yd1, zd1),
+    gradCoordR3(seed, x1, y1, z1, xd1, yd1, zd1),
+    xs
+  );
+
+  let yf0 = mix(xf00, xf10, ys);
+  let yf1 = mix(xf01, xf11, ys);
+
+  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() {
+  return `
+${E()}
+const PRIME_X_2: i32 = ${Re};
+const PRIME_Y_2: i32 = ${_e};
+${N()}
+${I()}
+${O()}
+${U()}
+
+fn valuecubic2d(seed: i32, x: f32, y: f32) -> f32 {
+  let fx1 = floor(x);
+  let fy1 = floor(y);
+  let x1i = i32(fx1);
+  let y1i = i32(fy1);
+
+  let xs = x - fx1;
+  let ys = y - fy1;
+
+  let x1 = imul(x1i, PRIME_X);
+  let y1 = imul(y1i, PRIME_Y);
+  let x0 = x1 - PRIME_X;
+  let y0 = y1 - PRIME_Y;
+  let x2 = x1 + PRIME_X;
+  let y2 = y1 + PRIME_Y;
+  let x3 = x1 + PRIME_X_2;
+  let y3 = y1 + PRIME_Y_2;
+
+  return cubicLerp(
+    cubicLerp(valCoordR2(seed, x0, y0), valCoordR2(seed, x1, y0), valCoordR2(seed, x2, y0), valCoordR2(seed, x3, y0), xs),
+    cubicLerp(valCoordR2(seed, x0, y1), valCoordR2(seed, x1, y1), valCoordR2(seed, x2, y1), valCoordR2(seed, x3, y1), xs),
+    cubicLerp(valCoordR2(seed, x0, y2), valCoordR2(seed, x1, y2), valCoordR2(seed, x2, y2), valCoordR2(seed, x3, y2), xs),
+    cubicLerp(valCoordR2(seed, x0, y3), valCoordR2(seed, x1, y3), valCoordR2(seed, x2, y3), valCoordR2(seed, x3, y3), xs),
+    ys
+  ) * (1.0 / (1.5 * 1.5));
+}
+`;
+}
+function Oe() {
+  return `
+${E()}
+const PRIME_X_2: i32 = ${Re};
+const PRIME_Y_2: i32 = ${_e};
+const PRIME_Z_2: i32 = ${Te};
+${N()}
+${S()}
+${q()}
+${U()}
+
+fn valuecubic3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
+  let fx1 = floor(x);
+  let fy1 = floor(y);
+  let fz1 = floor(z);
+  let x1i = i32(fx1);
+  let y1i = i32(fy1);
+  let z1i = i32(fz1);
+
+  let xs = x - fx1;
+  let ys = y - fy1;
+  let zs = z - fz1;
+
+  let x1 = imul(x1i, PRIME_X);
+  let y1 = imul(y1i, PRIME_Y);
+  let z1 = imul(z1i, PRIME_Z);
+  let x0 = x1 - PRIME_X;
+  let y0 = y1 - PRIME_Y;
+  let z0 = z1 - PRIME_Z;
+  let x2 = x1 + PRIME_X;
+  let y2 = y1 + PRIME_Y;
+  let z2 = z1 + PRIME_Z;
+  let x3 = x1 + PRIME_X_2;
+  let y3 = y1 + PRIME_Y_2;
+  let z3 = z1 + PRIME_Z_2;
+
+  return cubicLerp(
+    cubicLerp(
+      cubicLerp(valCoordR3(seed,x0,y0,z0), valCoordR3(seed,x1,y0,z0), valCoordR3(seed,x2,y0,z0), valCoordR3(seed,x3,y0,z0), xs),
+      cubicLerp(valCoordR3(seed,x0,y1,z0), valCoordR3(seed,x1,y1,z0), valCoordR3(seed,x2,y1,z0), valCoordR3(seed,x3,y1,z0), xs),
+      cubicLerp(valCoordR3(seed,x0,y2,z0), valCoordR3(seed,x1,y2,z0), valCoordR3(seed,x2,y2,z0), valCoordR3(seed,x3,y2,z0), xs),
+      cubicLerp(valCoordR3(seed,x0,y3,z0), valCoordR3(seed,x1,y3,z0), valCoordR3(seed,x2,y3,z0), valCoordR3(seed,x3,y3,z0), xs),
+      ys),
+    cubicLerp(
+      cubicLerp(valCoordR3(seed,x0,y0,z1), valCoordR3(seed,x1,y0,z1), valCoordR3(seed,x2,y0,z1), valCoordR3(seed,x3,y0,z1), xs),
+      cubicLerp(valCoordR3(seed,x0,y1,z1), valCoordR3(seed,x1,y1,z1), valCoordR3(seed,x2,y1,z1), valCoordR3(seed,x3,y1,z1), xs),
+      cubicLerp(valCoordR3(seed,x0,y2,z1), valCoordR3(seed,x1,y2,z1), valCoordR3(seed,x2,y2,z1), valCoordR3(seed,x3,y2,z1), xs),
+      cubicLerp(valCoordR3(seed,x0,y3,z1), valCoordR3(seed,x1,y3,z1), valCoordR3(seed,x2,y3,z1), valCoordR3(seed,x3,y3,z1), xs),
+      ys),
+    cubicLerp(
+      cubicLerp(valCoordR3(seed,x0,y0,z2), valCoordR3(seed,x1,y0,z2), valCoordR3(seed,x2,y0,z2), valCoordR3(seed,x3,y0,z2), xs),
+      cubicLerp(valCoordR3(seed,x0,y1,z2), valCoordR3(seed,x1,y1,z2), valCoordR3(seed,x2,y1,z2), valCoordR3(seed,x3,y1,z2), xs),
+      cubicLerp(valCoordR3(seed,x0,y2,z2), valCoordR3(seed,x1,y2,z2), valCoordR3(seed,x2,y2,z2), valCoordR3(seed,x3,y2,z2), xs),
+      cubicLerp(valCoordR3(seed,x0,y3,z2), valCoordR3(seed,x1,y3,z2), valCoordR3(seed,x2,y3,z2), valCoordR3(seed,x3,y3,z2), xs),
+      ys),
+    cubicLerp(
+      cubicLerp(valCoordR3(seed,x0,y0,z3), valCoordR3(seed,x1,y0,z3), valCoordR3(seed,x2,y0,z3), valCoordR3(seed,x3,y0,z3), xs),
+      cubicLerp(valCoordR3(seed,x0,y1,z3), valCoordR3(seed,x1,y1,z3), valCoordR3(seed,x2,y1,z3), valCoordR3(seed,x3,y1,z3), xs),
+      cubicLerp(valCoordR3(seed,x0,y2,z3), valCoordR3(seed,x1,y2,z3), valCoordR3(seed,x2,y2,z3), valCoordR3(seed,x3,y2,z3), xs),
+      cubicLerp(valCoordR3(seed,x0,y3,z3), valCoordR3(seed,x1,y3,z3), valCoordR3(seed,x2,y3,z3), valCoordR3(seed,x3,y3,z3), xs),
+      ys),
+    zs
+  ) * (1.0 / (1.5 * 1.5 * 1.5));
+}
+`;
+}
+function qe() {
+  return `
+fn valuecubic2d(seed: i32, x: f32, y: f32) -> f32 {
+  let fx1 = floor(x);
+  let fy1 = floor(y);
+  let x1i = i32(fx1);
+  let y1i = i32(fy1);
+
+  let xs = x - fx1;
+  let ys = y - fy1;
+
+  let x1 = imul(x1i, PRIME_X);
+  let y1 = imul(y1i, PRIME_Y);
+  let x0 = x1 - PRIME_X;
+  let y0 = y1 - PRIME_Y;
+  let x2 = x1 + PRIME_X;
+  let y2 = y1 + PRIME_Y;
+  let x3 = x1 + PRIME_X_2;
+  let y3 = y1 + PRIME_Y_2;
+
+  return cubicLerp(
+    cubicLerp(valCoordR2(seed, x0, y0), valCoordR2(seed, x1, y0), valCoordR2(seed, x2, y0), valCoordR2(seed, x3, y0), xs),
+    cubicLerp(valCoordR2(seed, x0, y1), valCoordR2(seed, x1, y1), valCoordR2(seed, x2, y1), valCoordR2(seed, x3, y1), xs),
+    cubicLerp(valCoordR2(seed, x0, y2), valCoordR2(seed, x1, y2), valCoordR2(seed, x2, y2), valCoordR2(seed, x3, y2), xs),
+    cubicLerp(valCoordR2(seed, x0, y3), valCoordR2(seed, x1, y3), valCoordR2(seed, x2, y3), valCoordR2(seed, x3, y3), xs),
+    ys
+  ) * (1.0 / (1.5 * 1.5));
+}
+`;
+}
+function Je() {
+  return `
+fn valuecubic3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
+  let fx1 = floor(x);
+  let fy1 = floor(y);
+  let fz1 = floor(z);
+  let x1i = i32(fx1);
+  let y1i = i32(fy1);
+  let z1i = i32(fz1);
+
+  let xs = x - fx1;
+  let ys = y - fy1;
+  let zs = z - fz1;
+
+  let x1 = imul(x1i, PRIME_X);
+  let y1 = imul(y1i, PRIME_Y);
+  let z1 = imul(z1i, PRIME_Z);
+  let x0 = x1 - PRIME_X;
+  let y0 = y1 - PRIME_Y;
+  let z0 = z1 - PRIME_Z;
+  let x2 = x1 + PRIME_X;
+  let y2 = y1 + PRIME_Y;
+  let z2 = z1 + PRIME_Z;
+  let x3 = x1 + PRIME_X_2;
+  let y3 = y1 + PRIME_Y_2;
+  let z3 = z1 + PRIME_Z_2;
+
+  return cubicLerp(
+    cubicLerp(
+      cubicLerp(valCoordR3(seed,x0,y0,z0), valCoordR3(seed,x1,y0,z0), valCoordR3(seed,x2,y0,z0), valCoordR3(seed,x3,y0,z0), xs),
+      cubicLerp(valCoordR3(seed,x0,y1,z0), valCoordR3(seed,x1,y1,z0), valCoordR3(seed,x2,y1,z0), valCoordR3(seed,x3,y1,z0), xs),
+      cubicLerp(valCoordR3(seed,x0,y2,z0), valCoordR3(seed,x1,y2,z0), valCoordR3(seed,x2,y2,z0), valCoordR3(seed,x3,y2,z0), xs),
+      cubicLerp(valCoordR3(seed,x0,y3,z0), valCoordR3(seed,x1,y3,z0), valCoordR3(seed,x2,y3,z0), valCoordR3(seed,x3,y3,z0), xs),
+      ys),
+    cubicLerp(
+      cubicLerp(valCoordR3(seed,x0,y0,z1), valCoordR3(seed,x1,y0,z1), valCoordR3(seed,x2,y0,z1), valCoordR3(seed,x3,y0,z1), xs),
+      cubicLerp(valCoordR3(seed,x0,y1,z1), valCoordR3(seed,x1,y1,z1), valCoordR3(seed,x2,y1,z1), valCoordR3(seed,x3,y1,z1), xs),
+      cubicLerp(valCoordR3(seed,x0,y2,z1), valCoordR3(seed,x1,y2,z1), valCoordR3(seed,x2,y2,z1), valCoordR3(seed,x3,y2,z1), xs),
+      cubicLerp(valCoordR3(seed,x0,y3,z1), valCoordR3(seed,x1,y3,z1), valCoordR3(seed,x2,y3,z1), valCoordR3(seed,x3,y3,z1), xs),
+      ys),
+    cubicLerp(
+      cubicLerp(valCoordR3(seed,x0,y0,z2), valCoordR3(seed,x1,y0,z2), valCoordR3(seed,x2,y0,z2), valCoordR3(seed,x3,y0,z2), xs),
+      cubicLerp(valCoordR3(seed,x0,y1,z2), valCoordR3(seed,x1,y1,z2), valCoordR3(seed,x2,y1,z2), valCoordR3(seed,x3,y1,z2), xs),
+      cubicLerp(valCoordR3(seed,x0,y2,z2), valCoordR3(seed,x1,y2,z2), valCoordR3(seed,x2,y2,z2), valCoordR3(seed,x3,y2,z2), xs),
+      cubicLerp(valCoordR3(seed,x0,y3,z2), valCoordR3(seed,x1,y3,z2), valCoordR3(seed,x2,y3,z2), valCoordR3(seed,x3,y3,z2), xs),
+      ys),
+    cubicLerp(
+      cubicLerp(valCoordR3(seed,x0,y0,z3), valCoordR3(seed,x1,y0,z3), valCoordR3(seed,x2,y0,z3), valCoordR3(seed,x3,y0,z3), xs),
+      cubicLerp(valCoordR3(seed,x0,y1,z3), valCoordR3(seed,x1,y1,z3), valCoordR3(seed,x2,y1,z3), valCoordR3(seed,x3,y1,z3), xs),
+      cubicLerp(valCoordR3(seed,x0,y2,z3), valCoordR3(seed,x1,y2,z3), valCoordR3(seed,x2,y2,z3), valCoordR3(seed,x3,y2,z3), xs),
+      cubicLerp(valCoordR3(seed,x0,y3,z3), valCoordR3(seed,x1,y3,z3), valCoordR3(seed,x2,y3,z3), valCoordR3(seed,x3,y3,z3), xs),
+      ys),
+    zs
+  ) * (1.0 / (1.5 * 1.5 * 1.5));
+}
+`;
+}
+const ee = ["primes", "gradients2D", "imul", "hashR2", "gradCoordR2"], ae = ["primes", "gradients3D", "imul", "hashR3", "gradCoordR3"];
+function ie() {
+  return `
+${E()}
+${W()}
+${N()}
+${I()}
+${V()}
+
+${B()}
+`;
+}
+function re() {
+  return `
+${E()}
+${j()}
+${N()}
+${S()}
+${F()}
+
+${H()}
+`;
+}
+function B() {
+  return `fn opensimplex2_2d(seed: i32, x: f32, y: f32) -> f32 {
+  let G2: f32 = 0.21132486540518713;
+
+  let fi = floor(x);
+  let fj = floor(y);
+  var i = i32(fi);
+  var j = i32(fj);
+  let xi = x - fi;
+  let yi = y - fj;
+
+  let t = (xi + yi) * G2;
+  let x0 = xi - t;
+  let y0 = yi - t;
+
+  i = imul(i, PRIME_X);
+  j = imul(j, PRIME_Y);
+
+  var n0: f32 = 0.0;
+  var n1: f32 = 0.0;
+  var n2: f32 = 0.0;
+
+  let a = 0.5 - x0 * x0 - y0 * y0;
+  if (a > 0.0) {
+    n0 = a * a * (a * a) * gradCoordR2(seed, i, j, x0, y0);
+  }
+
+  let c = 2.0 * (1.0 - 2.0 * G2) * (1.0 / G2 - 2.0) * t +
+          (-2.0 * (1.0 - 2.0 * G2) * (1.0 - 2.0 * G2) + a);
+  if (c > 0.0) {
+    let x2 = x0 + (2.0 * G2 - 1.0);
+    let y2 = y0 + (2.0 * G2 - 1.0);
+    n2 = c * c * (c * c) * gradCoordR2(seed, i + PRIME_X, j + PRIME_Y, x2, y2);
+  }
+
+  if (y0 > x0) {
+    let x1 = x0 + G2;
+    let y1 = y0 + (G2 - 1.0);
+    let b = 0.5 - x1 * x1 - y1 * y1;
+    if (b > 0.0) {
+      n1 = b * b * (b * b) * gradCoordR2(seed, i, j + PRIME_Y, x1, y1);
+    }
+  } else {
+    let x1 = x0 + (G2 - 1.0);
+    let y1 = y0 + G2;
+    let b = 0.5 - x1 * x1 - y1 * y1;
+    if (b > 0.0) {
+      n1 = b * b * (b * b) * gradCoordR2(seed, i + PRIME_X, j, x1, y1);
+    }
+  }
+
+  return (n0 + n1 + n2) * 99.83685446303647;
+}`;
+}
+function H() {
+  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));
+  var j = i32(floor(y + 0.5));
+  var k = i32(floor(z + 0.5));
+  var x0 = x - f32(i);
+  var y0 = y - f32(j);
+  var z0 = z - f32(k);
+
+  var xNSign = i32(-1.0 - x0) | 1;
+  var yNSign = i32(-1.0 - y0) | 1;
+  var zNSign = i32(-1.0 - z0) | 1;
+
+  var ax0 = f32(xNSign) * (-x0);
+  var ay0 = f32(yNSign) * (-y0);
+  var az0 = f32(zNSign) * (-z0);
+
+  i = imul(i, PRIME_X);
+  j = imul(j, PRIME_Y);
+  k = imul(k, PRIME_Z);
+
+  var value: f32 = 0.0;
+  var a = 0.6 - x0 * x0 - (y0 * y0 + z0 * z0);
+
+  for (var l: i32 = 0; l < 2; l++) {
+    if (a > 0.0) {
+      value += a * a * (a * a) * gradCoordR3(seed, i, j, k, x0, y0, z0);
+    }
+
+    if (ax0 >= ay0 && ax0 >= az0) {
+      var b = a + ax0 + ax0;
+      if (b > 1.0) {
+        b -= 1.0;
+        value += b * b * (b * b) * gradCoordR3(seed, i - xNSign * PRIME_X, j, k, x0 + f32(xNSign), y0, z0);
+      }
+    } else if (ay0 > ax0 && ay0 >= az0) {
+      var b = a + ay0 + ay0;
+      if (b > 1.0) {
+        b -= 1.0;
+        value += b * b * (b * b) * gradCoordR3(seed, i, j - yNSign * PRIME_Y, k, x0, y0 + f32(yNSign), z0);
+      }
+    } else {
+      var b = a + az0 + az0;
+      if (b > 1.0) {
+        b -= 1.0;
+        value += b * b * (b * b) * gradCoordR3(seed, i, j, k - zNSign * PRIME_Z, x0, y0, z0 + f32(zNSign));
+      }
+    }
+
+    if (l == 1) { break; }
+
+    ax0 = 0.5 - ax0;
+    ay0 = 0.5 - ay0;
+    az0 = 0.5 - az0;
+
+    x0 = f32(xNSign) * ax0;
+    y0 = f32(yNSign) * ay0;
+    z0 = f32(zNSign) * az0;
+
+    a += 0.75 - ax0 - (ay0 + az0);
+
+    i += (xNSign >> 1u) & PRIME_X;
+    j += (yNSign >> 1u) & PRIME_Y;
+    k += (zNSign >> 1u) & PRIME_Z;
+
+    xNSign = -xNSign;
+    yNSign = -yNSign;
+    zNSign = -zNSign;
+
+    seed = ~seed;
+  }
+
+  return value * 32.69428253173828125;
+}`;
+}
+const ve = A << 1 | 0, ze = G << 1 | 0, Qe = X << 1 | 0;
+function Ue() {
+  return `
+${E()}
+const PRIME_X_2: i32 = ${ve};
+const PRIME_Y_2: i32 = ${ze};
+${W()}
+${N()}
+${I()}
+${V()}
+
+fn opensimplex2s_2d(seed_in: i32, x: f32, y: f32) -> f32 {
+  let seed = seed_in;
+  let G2: f32 = 0.21132486540518713;
+
+  let fi = floor(x);
+  let fj = floor(y);
+  var i = i32(fi);
+  var j = i32(fj);
+  let xi = x - fi;
+  let yi = y - fj;
+
+  i = imul(i, PRIME_X);
+  j = imul(j, PRIME_Y);
+  let i1 = i + PRIME_X;
+  let j1 = j + PRIME_Y;
+
+  let t = (xi + yi) * G2;
+  let x0 = xi - t;
+  let y0 = yi - t;
+
+  let a0 = 2.0 / 3.0 - x0 * x0 - y0 * y0;
+  var value = a0 * a0 * (a0 * a0) * gradCoordR2(seed, i, j, x0, y0);
+
+  let a1 = 2.0 * (1.0 - 2.0 * G2) * (1.0 / G2 - 2.0) * t +
+           (-2.0 * (1.0 - 2.0 * G2) * (1.0 - 2.0 * G2) + a0);
+  let x1 = x0 - (1.0 - 2.0 * G2);
+  let y1 = y0 - (1.0 - 2.0 * G2);
+  value += a1 * a1 * (a1 * a1) * gradCoordR2(seed, i1, j1, x1, y1);
+
+  let xmyi = xi - yi;
+  if (t > G2) {
+    if (xi + xmyi > 1.0) {
+      let x2 = x0 + (3.0 * G2 - 2.0);
+      let y2 = y0 + (3.0 * G2 - 1.0);
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i + PRIME_X_2, j + PRIME_Y, x2, y2);
+      }
+    } else {
+      let x2 = x0 + G2;
+      let y2 = y0 + (G2 - 1.0);
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i, j + PRIME_Y, x2, y2);
+      }
+    }
+
+    if (yi - xmyi > 1.0) {
+      let x3 = x0 + (3.0 * G2 - 1.0);
+      let y3 = y0 + (3.0 * G2 - 2.0);
+      let a3 = 2.0 / 3.0 - x3 * x3 - y3 * y3;
+      if (a3 > 0.0) {
+        value += a3 * a3 * (a3 * a3) * gradCoordR2(seed, i + PRIME_X, j + PRIME_Y_2, x3, y3);
+      }
+    } else {
+      let x3 = x0 + (G2 - 1.0);
+      let y3 = y0 + G2;
+      let a3 = 2.0 / 3.0 - x3 * x3 - y3 * y3;
+      if (a3 > 0.0) {
+        value += a3 * a3 * (a3 * a3) * gradCoordR2(seed, i + PRIME_X, j, x3, y3);
+      }
+    }
+  } else {
+    if (xi + xmyi < 0.0) {
+      let x2 = x0 + (1.0 - G2);
+      let y2 = y0 - G2;
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i - PRIME_X, j, x2, y2);
+      }
+    } else {
+      let x2 = x0 + (G2 - 1.0);
+      let y2 = y0 + G2;
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i + PRIME_X, j, x2, y2);
+      }
+    }
+
+    if (yi < xmyi) {
+      let x2 = x0 - G2;
+      let y2 = y0 - (G2 - 1.0);
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i, j - PRIME_Y, x2, y2);
+      }
+    } else {
+      let x2 = x0 + G2;
+      let y2 = y0 + (G2 - 1.0);
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i, j + PRIME_Y, x2, y2);
+      }
+    }
+  }
+
+  return value * 18.24196194486065;
+}
+`;
+}
+function Ke() {
+  return `
+${E()}
+const PRIME_X_2: i32 = ${ve};
+const PRIME_Y_2: i32 = ${ze};
+const PRIME_Z_2: i32 = ${Qe};
+${j()}
+${N()}
+${S()}
+${F()}
+
+fn opensimplex2s_3d(seed_in: i32, x: f32, y: f32, z: f32) -> f32 {
+  let seed = seed_in;
+  let seed2 = seed + 1293373;
+
+  let fi = floor(x);
+  let fj = floor(y);
+  let fk = floor(z);
+  var i = imul(i32(fi), PRIME_X);
+  var j = imul(i32(fj), PRIME_Y);
+  var k = imul(i32(fk), PRIME_Z);
+
+  let xi = x - fi;
+  let yi = y - fj;
+  let zi = z - fk;
+
+  // i32() truncates toward zero = Math.trunc (NOT floor)
+  let xNMask = i32(-0.5 - xi);
+  let yNMask = i32(-0.5 - yi);
+  let zNMask = i32(-0.5 - zi);
+
+  let x0 = xi + f32(xNMask);
+  let y0 = yi + f32(yNMask);
+  let z0 = zi + f32(zNMask);
+  var a0 = 0.75 - x0 * x0 - y0 * y0 - z0 * z0;
+  var value = a0 * a0 * (a0 * a0) * gradCoordR3(seed,
+    i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z),
+    x0, y0, z0);
+
+  let x1 = xi - 0.5;
+  let y1 = yi - 0.5;
+  let z1 = zi - 0.5;
+  var a1 = 0.75 - x1 * x1 - y1 * y1 - z1 * z1;
+  value += a1 * a1 * (a1 * a1) * gradCoordR3(seed2,
+    i + PRIME_X, j + PRIME_Y, k + PRIME_Z, x1, y1, z1);
+
+  let xAFlipMask0 = f32((xNMask | 1) << 1u) * x1;
+  let yAFlipMask0 = f32((yNMask | 1) << 1u) * y1;
+  let zAFlipMask0 = f32((zNMask | 1) << 1u) * z1;
+  let xAFlipMask1 = f32(-2 - (xNMask << 2u)) * x1 - 1.0;
+  let yAFlipMask1 = f32(-2 - (yNMask << 2u)) * y1 - 1.0;
+  let zAFlipMask1 = f32(-2 - (zNMask << 2u)) * z1 - 1.0;
+
+  var skip5 = false;
+  var a2 = xAFlipMask0 + a0;
+  if (a2 > 0.0) {
+    let x2 = x0 - f32(xNMask | 1);
+    value += a2 * a2 * (a2 * a2) * gradCoordR3(seed,
+      i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z),
+      x2, y0, z0);
+  } else {
+    var a3 = yAFlipMask0 + zAFlipMask0 + a0;
+    if (a3 > 0.0) {
+      let y3 = y0 - f32(yNMask | 1);
+      let z3 = z0 - f32(zNMask | 1);
+      value += a3 * a3 * (a3 * a3) * gradCoordR3(seed,
+        i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (~zNMask & PRIME_Z),
+        x0, y3, z3);
+    }
+    var a4 = xAFlipMask1 + a1;
+    if (a4 > 0.0) {
+      let x4 = f32(xNMask | 1) + x1;
+      value += a4 * a4 * (a4 * a4) * gradCoordR3(seed2,
+        i + (xNMask & PRIME_X_2), j + PRIME_Y, k + PRIME_Z,
+        x4, y1, z1);
+      skip5 = true;
+    }
+  }
+
+  var skip9 = false;
+  var a6 = yAFlipMask0 + a0;
+  if (a6 > 0.0) {
+    let y6 = y0 - f32(yNMask | 1);
+    value += a6 * a6 * (a6 * a6) * gradCoordR3(seed,
+      i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z),
+      x0, y6, z0);
+  } else {
+    var a7 = xAFlipMask0 + zAFlipMask0 + a0;
+    if (a7 > 0.0) {
+      let x7 = x0 - f32(xNMask | 1);
+      let z7 = z0 - f32(zNMask | 1);
+      value += a7 * a7 * (a7 * a7) * gradCoordR3(seed,
+        i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z),
+        x7, y0, z7);
+    }
+    var a8 = yAFlipMask1 + a1;
+    if (a8 > 0.0) {
+      let y8 = f32(yNMask | 1) + y1;
+      value += a8 * a8 * (a8 * a8) * gradCoordR3(seed2,
+        i + PRIME_X, j + (yNMask & PRIME_Y_2), k + PRIME_Z,
+        x1, y8, z1);
+      skip9 = true;
+    }
+  }
+
+  var skipD = false;
+  var aA = zAFlipMask0 + a0;
+  if (aA > 0.0) {
+    let zA = z0 - f32(zNMask | 1);
+    value += aA * aA * (aA * aA) * gradCoordR3(seed,
+      i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z),
+      x0, y0, zA);
+  } else {
+    var aB = xAFlipMask0 + yAFlipMask0 + a0;
+    if (aB > 0.0) {
+      let xB = x0 - f32(xNMask | 1);
+      let yB = y0 - f32(yNMask | 1);
+      value += aB * aB * (aB * aB) * gradCoordR3(seed,
+        i + (~xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z),
+        xB, yB, z0);
+    }
+    var aC = zAFlipMask1 + a1;
+    if (aC > 0.0) {
+      let zC = f32(zNMask | 1) + z1;
+      value += aC * aC * (aC * aC) * gradCoordR3(seed2,
+        i + PRIME_X, j + PRIME_Y, k + (zNMask & PRIME_Z_2),
+        x1, y1, zC);
+      skipD = true;
+    }
+  }
+
+  if (!skip5) {
+    var a5 = yAFlipMask1 + zAFlipMask1 + a1;
+    if (a5 > 0.0) {
+      let y5 = f32(yNMask | 1) + y1;
+      let z5 = f32(zNMask | 1) + z1;
+      value += a5 * a5 * (a5 * a5) * gradCoordR3(seed2,
+        i + PRIME_X, j + (yNMask & PRIME_Y_2), k + (zNMask & PRIME_Z_2),
+        x1, y5, z5);
+    }
+  }
+
+  if (!skip9) {
+    var a9 = xAFlipMask1 + zAFlipMask1 + a1;
+    if (a9 > 0.0) {
+      let x9 = f32(xNMask | 1) + x1;
+      let z9 = f32(zNMask | 1) + z1;
+      value += a9 * a9 * (a9 * a9) * gradCoordR3(seed2,
+        i + (xNMask & PRIME_X_2), j + PRIME_Y, k + (zNMask & PRIME_Z_2),
+        x9, y1, z9);
+    }
+  }
+
+  if (!skipD) {
+    var aD = xAFlipMask1 + yAFlipMask1 + a1;
+    if (aD > 0.0) {
+      let xD = f32(xNMask | 1) + x1;
+      let yD = f32(yNMask | 1) + y1;
+      value += aD * aD * (aD * aD) * gradCoordR3(seed2,
+        i + (xNMask & PRIME_X_2), j + (yNMask & PRIME_Y_2), k + PRIME_Z,
+        xD, yD, z1);
+    }
+  }
+
+  return value * 9.046026385208288;
+}
+`;
+}
+const ea = ["primes", "primesDouble", "gradients2D", "imul", "hashR2", "gradCoordR2"], aa = ["primes", "primesDouble", "gradients3D", "imul", "hashR3", "gradCoordR3"];
+function ia() {
+  return `
+fn opensimplex2s_2d(seed_in: i32, x: f32, y: f32) -> f32 {
+  let seed = seed_in;
+  let G2: f32 = 0.21132486540518713;
+
+  let fi = floor(x);
+  let fj = floor(y);
+  var i = i32(fi);
+  var j = i32(fj);
+  let xi = x - fi;
+  let yi = y - fj;
+
+  i = imul(i, PRIME_X);
+  j = imul(j, PRIME_Y);
+  let i1 = i + PRIME_X;
+  let j1 = j + PRIME_Y;
+
+  let t = (xi + yi) * G2;
+  let x0 = xi - t;
+  let y0 = yi - t;
+
+  let a0 = 2.0 / 3.0 - x0 * x0 - y0 * y0;
+  var value = a0 * a0 * (a0 * a0) * gradCoordR2(seed, i, j, x0, y0);
+
+  let a1 = 2.0 * (1.0 - 2.0 * G2) * (1.0 / G2 - 2.0) * t +
+           (-2.0 * (1.0 - 2.0 * G2) * (1.0 - 2.0 * G2) + a0);
+  let x1 = x0 - (1.0 - 2.0 * G2);
+  let y1 = y0 - (1.0 - 2.0 * G2);
+  value += a1 * a1 * (a1 * a1) * gradCoordR2(seed, i1, j1, x1, y1);
+
+  let xmyi = xi - yi;
+  if (t > G2) {
+    if (xi + xmyi > 1.0) {
+      let x2 = x0 + (3.0 * G2 - 2.0);
+      let y2 = y0 + (3.0 * G2 - 1.0);
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i + PRIME_X_2, j + PRIME_Y, x2, y2);
+      }
+    } else {
+      let x2 = x0 + G2;
+      let y2 = y0 + (G2 - 1.0);
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i, j + PRIME_Y, x2, y2);
+      }
+    }
+
+    if (yi - xmyi > 1.0) {
+      let x3 = x0 + (3.0 * G2 - 1.0);
+      let y3 = y0 + (3.0 * G2 - 2.0);
+      let a3 = 2.0 / 3.0 - x3 * x3 - y3 * y3;
+      if (a3 > 0.0) {
+        value += a3 * a3 * (a3 * a3) * gradCoordR2(seed, i + PRIME_X, j + PRIME_Y_2, x3, y3);
+      }
+    } else {
+      let x3 = x0 + (G2 - 1.0);
+      let y3 = y0 + G2;
+      let a3 = 2.0 / 3.0 - x3 * x3 - y3 * y3;
+      if (a3 > 0.0) {
+        value += a3 * a3 * (a3 * a3) * gradCoordR2(seed, i + PRIME_X, j, x3, y3);
+      }
+    }
+  } else {
+    if (xi + xmyi < 0.0) {
+      let x2 = x0 + (1.0 - G2);
+      let y2 = y0 - G2;
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i - PRIME_X, j, x2, y2);
+      }
+    } else {
+      let x2 = x0 + (G2 - 1.0);
+      let y2 = y0 + G2;
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i + PRIME_X, j, x2, y2);
+      }
+    }
+
+    if (yi < xmyi) {
+      let x2 = x0 - G2;
+      let y2 = y0 - (G2 - 1.0);
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i, j - PRIME_Y, x2, y2);
+      }
+    } else {
+      let x2 = x0 + G2;
+      let y2 = y0 + (G2 - 1.0);
+      let a2 = 2.0 / 3.0 - x2 * x2 - y2 * y2;
+      if (a2 > 0.0) {
+        value += a2 * a2 * (a2 * a2) * gradCoordR2(seed, i, j + PRIME_Y, x2, y2);
+      }
+    }
+  }
+
+  return value * 18.24196194486065;
+}
+`;
+}
+function ra() {
+  return `
+fn opensimplex2s_3d(seed_in: i32, x: f32, y: f32, z: f32) -> f32 {
+  let seed = seed_in;
+  let seed2 = seed + 1293373;
+
+  let fi = floor(x);
+  let fj = floor(y);
+  let fk = floor(z);
+  var i = imul(i32(fi), PRIME_X);
+  var j = imul(i32(fj), PRIME_Y);
+  var k = imul(i32(fk), PRIME_Z);
+
+  let xi = x - fi;
+  let yi = y - fj;
+  let zi = z - fk;
+
+  // i32() truncates toward zero = Math.trunc (NOT floor)
+  let xNMask = i32(-0.5 - xi);
+  let yNMask = i32(-0.5 - yi);
+  let zNMask = i32(-0.5 - zi);
+
+  let x0 = xi + f32(xNMask);
+  let y0 = yi + f32(yNMask);
+  let z0 = zi + f32(zNMask);
+  var a0 = 0.75 - x0 * x0 - y0 * y0 - z0 * z0;
+  var value = a0 * a0 * (a0 * a0) * gradCoordR3(seed,
+    i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z),
+    x0, y0, z0);
+
+  let x1 = xi - 0.5;
+  let y1 = yi - 0.5;
+  let z1 = zi - 0.5;
+  var a1 = 0.75 - x1 * x1 - y1 * y1 - z1 * z1;
+  value += a1 * a1 * (a1 * a1) * gradCoordR3(seed2,
+    i + PRIME_X, j + PRIME_Y, k + PRIME_Z, x1, y1, z1);
+
+  let xAFlipMask0 = f32((xNMask | 1) << 1u) * x1;
+  let yAFlipMask0 = f32((yNMask | 1) << 1u) * y1;
+  let zAFlipMask0 = f32((zNMask | 1) << 1u) * z1;
+  let xAFlipMask1 = f32(-2 - (xNMask << 2u)) * x1 - 1.0;
+  let yAFlipMask1 = f32(-2 - (yNMask << 2u)) * y1 - 1.0;
+  let zAFlipMask1 = f32(-2 - (zNMask << 2u)) * z1 - 1.0;
+
+  var skip5 = false;
+  var a2 = xAFlipMask0 + a0;
+  if (a2 > 0.0) {
+    let x2 = x0 - f32(xNMask | 1);
+    value += a2 * a2 * (a2 * a2) * gradCoordR3(seed,
+      i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z),
+      x2, y0, z0);
+  } else {
+    var a3 = yAFlipMask0 + zAFlipMask0 + a0;
+    if (a3 > 0.0) {
+      let y3 = y0 - f32(yNMask | 1);
+      let z3 = z0 - f32(zNMask | 1);
+      value += a3 * a3 * (a3 * a3) * gradCoordR3(seed,
+        i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (~zNMask & PRIME_Z),
+        x0, y3, z3);
+    }
+    var a4 = xAFlipMask1 + a1;
+    if (a4 > 0.0) {
+      let x4 = f32(xNMask | 1) + x1;
+      value += a4 * a4 * (a4 * a4) * gradCoordR3(seed2,
+        i + (xNMask & PRIME_X_2), j + PRIME_Y, k + PRIME_Z,
+        x4, y1, z1);
+      skip5 = true;
+    }
+  }
+
+  var skip9 = false;
+  var a6 = yAFlipMask0 + a0;
+  if (a6 > 0.0) {
+    let y6 = y0 - f32(yNMask | 1);
+    value += a6 * a6 * (a6 * a6) * gradCoordR3(seed,
+      i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z),
+      x0, y6, z0);
+  } else {
+    var a7 = xAFlipMask0 + zAFlipMask0 + a0;
+    if (a7 > 0.0) {
+      let x7 = x0 - f32(xNMask | 1);
+      let z7 = z0 - f32(zNMask | 1);
+      value += a7 * a7 * (a7 * a7) * gradCoordR3(seed,
+        i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z),
+        x7, y0, z7);
+    }
+    var a8 = yAFlipMask1 + a1;
+    if (a8 > 0.0) {
+      let y8 = f32(yNMask | 1) + y1;
+      value += a8 * a8 * (a8 * a8) * gradCoordR3(seed2,
+        i + PRIME_X, j + (yNMask & PRIME_Y_2), k + PRIME_Z,
+        x1, y8, z1);
+      skip9 = true;
+    }
+  }
+
+  var skipD = false;
+  var aA = zAFlipMask0 + a0;
+  if (aA > 0.0) {
+    let zA = z0 - f32(zNMask | 1);
+    value += aA * aA * (aA * aA) * gradCoordR3(seed,
+      i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z),
+      x0, y0, zA);
+  } else {
+    var aB = xAFlipMask0 + yAFlipMask0 + a0;
+    if (aB > 0.0) {
+      let xB = x0 - f32(xNMask | 1);
+      let yB = y0 - f32(yNMask | 1);
+      value += aB * aB * (aB * aB) * gradCoordR3(seed,
+        i + (~xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z),
+        xB, yB, z0);
+    }
+    var aC = zAFlipMask1 + a1;
+    if (aC > 0.0) {
+      let zC = f32(zNMask | 1) + z1;
+      value += aC * aC * (aC * aC) * gradCoordR3(seed2,
+        i + PRIME_X, j + PRIME_Y, k + (zNMask & PRIME_Z_2),
+        x1, y1, zC);
+      skipD = true;
+    }
+  }
+
+  if (!skip5) {
+    var a5 = yAFlipMask1 + zAFlipMask1 + a1;
+    if (a5 > 0.0) {
+      let y5 = f32(yNMask | 1) + y1;
+      let z5 = f32(zNMask | 1) + z1;
+      value += a5 * a5 * (a5 * a5) * gradCoordR3(seed2,
+        i + PRIME_X, j + (yNMask & PRIME_Y_2), k + (zNMask & PRIME_Z_2),
+        x1, y5, z5);
+    }
+  }
+
+  if (!skip9) {
+    var a9 = xAFlipMask1 + zAFlipMask1 + a1;
+    if (a9 > 0.0) {
+      let x9 = f32(xNMask | 1) + x1;
+      let z9 = f32(zNMask | 1) + z1;
+      value += a9 * a9 * (a9 * a9) * gradCoordR3(seed2,
+        i + (xNMask & PRIME_X_2), j + PRIME_Y, k + (zNMask & PRIME_Z_2),
+        x9, y1, z9);
+    }
+  }
+
+  if (!skipD) {
+    var aD = xAFlipMask1 + yAFlipMask1 + a1;
+    if (aD > 0.0) {
+      let xD = f32(xNMask | 1) + x1;
+      let yD = f32(yNMask | 1) + y1;
+      value += aD * aD * (aD * aD) * gradCoordR3(seed2,
+        i + (xNMask & PRIME_X_2), j + (yNMask & PRIME_Y_2), k + PRIME_Z,
+        xD, yD, z1);
+    }
+  }
+
+  return value * 9.046026385208288;
+}
+`;
+}
+const pe = 0.43701595, me = 0.39614353;
+function he(d) {
+  switch (d) {
+    case M.Euclidean:
+    case M.EuclideanSq:
+      return "return vecX * vecX + vecY * vecY;";
+    case M.Manhattan:
+      return "return abs(vecX) + abs(vecY);";
+    case M.Hybrid:
+      return "return abs(vecX) + abs(vecY) + vecX * vecX + vecY * vecY;";
+  }
+}
+function Ee(d) {
+  switch (d) {
+    case M.Euclidean:
+    case M.EuclideanSq:
+      return "return vecX * vecX + vecY * vecY + vecZ * vecZ;";
+    case M.Manhattan:
+      return "return abs(vecX) + abs(vecY) + abs(vecZ);";
+    case M.Hybrid:
+      return "return abs(vecX) + abs(vecY) + abs(vecZ) + vecX * vecX + vecY * vecY + vecZ * vecZ;";
+  }
+}
+function T(d) {
+  switch (d) {
+    case C.CellValue:
+      return "return f32(closestHash) * (1.0 / 2147483648.0);";
+    case C.Distance:
+      return "return d0 - 1.0;";
+    case C.Distance2:
+      return "return d1 - 1.0;";
+    case C.Distance2Add:
+      return "return (d1 + d0) * 0.5 - 1.0;";
+    case C.Distance2Sub:
+      return "return d1 - d0 - 1.0;";
+    case C.Distance2Mul:
+      return "return d1 * d0 * 0.5 - 1.0;";
+    case C.Distance2Div:
+      return "return d0 / d1 - 1.0;";
+  }
+}
+function sa(d, e, t) {
+  const i = pe * t, r = d === M.Euclidean && e !== C.CellValue ? `
+  distance0 = sqrt(distance0);
+  distance1 = sqrt(distance1);` : "";
+  return `
+${E()}
+${N()}
+${I()}
+${ce()}
+
+const CELL_JITTER_2D: f32 = ${i};
+
+fn cellDist2d(vecX: f32, vecY: f32) -> f32 {
+  ${he(d)}
+}
+
+fn cellReturn2d(d0: f32, d1: f32, closestHash: i32) -> f32 {
+  ${T(e)}
+}
+
+fn cellular2d(seed: i32, x: f32, y: f32) -> f32 {
+  let xr = i32(floor(x + 0.5));
+  let yr = i32(floor(y + 0.5));
+
+  var distance0: f32 = 1e20;
+  var distance1: f32 = 1e20;
+  var closestHash: i32 = 0;
+
+  var xPrimed = imul(xr - 1, PRIME_X);
+  let yPrimedBase = imul(yr - 1, PRIME_Y);
+
+  for (var xi: i32 = xr - 1; xi <= xr + 1; xi++) {
+    var yPrimed = yPrimedBase;
+
+    for (var yi: i32 = yr - 1; yi <= yr + 1; yi++) {
+      let hash = hashR2(seed, xPrimed, yPrimed);
+      let idx = hash & (255 << 1u);
+
+      let vecX = f32(xi) - x + RAND_VECS_2D[idx] * CELL_JITTER_2D;
+      let vecY = f32(yi) - y + RAND_VECS_2D[idx | 1] * CELL_JITTER_2D;
+
+      let newDist = cellDist2d(vecX, vecY);
+
+      distance1 = max(min(distance1, newDist), distance0);
+      if (newDist < distance0) {
+        distance0 = newDist;
+        closestHash = hash;
+      }
+
+      yPrimed += PRIME_Y;
+    }
+    xPrimed += PRIME_X;
+  }
+${r}
+  return cellReturn2d(distance0, distance1, closestHash);
+}
+`;
+}
+function ta(d, e, t) {
+  const i = me * t, r = d === M.Euclidean && e !== C.CellValue ? `
+  distance0 = sqrt(distance0);
+  distance1 = sqrt(distance1);` : "";
+  return `
+${E()}
+${N()}
+${S()}
+${ue()}
+
+const CELL_JITTER_3D: f32 = ${i};
+
+fn cellDist3d(vecX: f32, vecY: f32, vecZ: f32) -> f32 {
+  ${Ee(d)}
+}
+
+fn cellReturn3d(d0: f32, d1: f32, closestHash: i32) -> f32 {
+  ${T(e)}
+}
+
+fn cellular3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
+  let xr = i32(floor(x + 0.5));
+  let yr = i32(floor(y + 0.5));
+  let zr = i32(floor(z + 0.5));
+
+  var distance0: f32 = 1e20;
+  var distance1: f32 = 1e20;
+  var closestHash: i32 = 0;
+
+  var xPrimed = imul(xr - 1, PRIME_X);
+  let yPrimedBase = imul(yr - 1, PRIME_Y);
+  let zPrimedBase = imul(zr - 1, PRIME_Z);
+
+  for (var xi: i32 = xr - 1; xi <= xr + 1; xi++) {
+    var yPrimed = yPrimedBase;
+
+    for (var yi: i32 = yr - 1; yi <= yr + 1; yi++) {
+      var zPrimed = zPrimedBase;
+
+      for (var zi: i32 = zr - 1; zi <= zr + 1; zi++) {
+        let hash = hashR3(seed, xPrimed, yPrimed, zPrimed);
+        let idx = hash & (255 << 2u);
+
+        let vecX = f32(xi) - x + RAND_VECS_3D[idx] * CELL_JITTER_3D;
+        let vecY = f32(yi) - y + RAND_VECS_3D[idx | 1] * CELL_JITTER_3D;
+        let vecZ = f32(zi) - z + RAND_VECS_3D[idx | 2] * CELL_JITTER_3D;
+
+        let newDist = cellDist3d(vecX, vecY, vecZ);
+
+        distance1 = max(min(distance1, newDist), distance0);
+        if (newDist < distance0) {
+          distance0 = newDist;
+          closestHash = hash;
+        }
+
+        zPrimed += PRIME_Z;
+      }
+      yPrimed += PRIME_Y;
+    }
+    xPrimed += PRIME_X;
+  }
+${r}
+  return cellReturn3d(distance0, distance1, closestHash);
+}
+`;
+}
+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 ? `
+  distance0 = sqrt(distance0);
+  distance1 = sqrt(distance1);` : "";
+  return `
+const CELL_JITTER_2D: f32 = ${i};
+
+fn cellDist2d(vecX: f32, vecY: f32) -> f32 {
+  ${he(d)}
+}
+
+fn cellReturn2d(d0: f32, d1: f32, closestHash: i32) -> f32 {
+  ${T(e)}
+}
+
+fn cellular2d(seed: i32, x: f32, y: f32) -> f32 {
+  let xr = i32(floor(x + 0.5));
+  let yr = i32(floor(y + 0.5));
+
+  var distance0: f32 = 1e20;
+  var distance1: f32 = 1e20;
+  var closestHash: i32 = 0;
+
+  var xPrimed = imul(xr - 1, PRIME_X);
+  let yPrimedBase = imul(yr - 1, PRIME_Y);
+
+  for (var xi: i32 = xr - 1; xi <= xr + 1; xi++) {
+    var yPrimed = yPrimedBase;
+
+    for (var yi: i32 = yr - 1; yi <= yr + 1; yi++) {
+      let hash = hashR2(seed, xPrimed, yPrimed);
+      let idx = hash & (255 << 1u);
+
+      let vecX = f32(xi) - x + RAND_VECS_2D[idx] * CELL_JITTER_2D;
+      let vecY = f32(yi) - y + RAND_VECS_2D[idx | 1] * CELL_JITTER_2D;
+
+      let newDist = cellDist2d(vecX, vecY);
+
+      distance1 = max(min(distance1, newDist), distance0);
+      if (newDist < distance0) {
+        distance0 = newDist;
+        closestHash = hash;
+      }
+
+      yPrimed += PRIME_Y;
+    }
+    xPrimed += PRIME_X;
+  }
+${r}
+  return cellReturn2d(distance0, distance1, closestHash);
+}
+`;
+}
+function xa(d, e, t) {
+  const i = me * t, 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)}
+}
+
+fn cellReturn3d(d0: f32, d1: f32, closestHash: i32) -> f32 {
+  ${T(e)}
+}
+
+fn cellular3d(seed: i32, x: f32, y: f32, z: f32) -> f32 {
+  let xr = i32(floor(x + 0.5));
+  let yr = i32(floor(y + 0.5));
+  let zr = i32(floor(z + 0.5));
+
+  var distance0: f32 = 1e20;
+  var distance1: f32 = 1e20;
+  var closestHash: i32 = 0;
+
+  var xPrimed = imul(xr - 1, PRIME_X);
+  let yPrimedBase = imul(yr - 1, PRIME_Y);
+  let zPrimedBase = imul(zr - 1, PRIME_Z);
+
+  for (var xi: i32 = xr - 1; xi <= xr + 1; xi++) {
+    var yPrimed = yPrimedBase;
+
+    for (var yi: i32 = yr - 1; yi <= yr + 1; yi++) {
+      var zPrimed = zPrimedBase;
+
+      for (var zi: i32 = zr - 1; zi <= zr + 1; zi++) {
+        let hash = hashR3(seed, xPrimed, yPrimed, zPrimed);
+        let idx = hash & (255 << 2u);
+
+        let vecX = f32(xi) - x + RAND_VECS_3D[idx] * CELL_JITTER_3D;
+        let vecY = f32(yi) - y + RAND_VECS_3D[idx | 1] * CELL_JITTER_3D;
+        let vecZ = f32(zi) - z + RAND_VECS_3D[idx | 2] * CELL_JITTER_3D;
+
+        let newDist = cellDist3d(vecX, vecY, vecZ);
+
+        distance1 = max(min(distance1, newDist), distance0);
+        if (newDist < distance0) {
+          distance0 = newDist;
+          closestHash = hash;
+        }
+
+        zPrimed += PRIME_Z;
+      }
+      yPrimed += PRIME_Y;
+    }
+    xPrimed += PRIME_X;
+  }
+${r}
+  return cellReturn3d(distance0, distance1, closestHash);
+}
+`;
+}
+function k(d, e, t, i, a, r, s, l) {
+  return `
+${d}
+
+fn noise(x: f32, y: f32) -> f32 {
+  var sum: f32 = 0.0;
+  var amp: f32 = ${l};
+  var px = x;
+  var py = y;
+  var s: i32 = ${t | 0};
+
+  for (var i: i32 = 0; i < ${i}; i++) {
+    let n = ${e}(s, px, py);
+    sum += n * amp;
+    amp *= mix(1.0, min(n + 1.0, 2.0) * 0.5, ${s});
+
+    px *= ${a};
+    py *= ${a};
+    amp *= ${r};
+    s += 1;
+  }
+
+  return sum;
+}
+`;
+}
+function b(d, e, t, i, a, r, s, l) {
+  return `
+${d}
+
+fn noise(x: f32, y: f32, z: f32) -> f32 {
+  var sum: f32 = 0.0;
+  var amp: f32 = ${l};
+  var px = x;
+  var py = y;
+  var pz = z;
+  var s: i32 = ${t | 0};
+
+  for (var i: i32 = 0; i < ${i}; i++) {
+    let n = ${e}(s, px, py, pz);
+    sum += n * amp;
+    amp *= mix(1.0, min(n + 1.0, 2.0) * 0.5, ${s});
+
+    px *= ${a};
+    py *= ${a};
+    pz *= ${a};
+    amp *= ${r};
+    s += 1;
+  }
+
+  return sum;
+}
+`;
+}
+function se(d, e, t, i, a, r, s, l) {
+  return `
+${d}
+
+fn noise(x: f32, y: f32) -> f32 {
+  var sum: f32 = 0.0;
+  var amp: f32 = ${l};
+  var px = x;
+  var py = y;
+  var s: i32 = ${t | 0};
+
+  for (var i: i32 = 0; i < ${i}; i++) {
+    var n = ${e}(s, px, py);
+    n = abs(n);
+    sum += (n * -2.0 + 1.0) * amp;
+    amp *= mix(1.0, 1.0 - n, ${s});
+
+    px *= ${a};
+    py *= ${a};
+    amp *= ${r};
+    s += 1;
+  }
+
+  return sum;
+}
+`;
+}
+function te(d, e, t, i, a, r, s, l) {
+  return `
+${d}
+
+fn noise(x: f32, y: f32, z: f32) -> f32 {
+  var sum: f32 = 0.0;
+  var amp: f32 = ${l};
+  var px = x;
+  var py = y;
+  var pz = z;
+  var s: i32 = ${t | 0};
+
+  for (var i: i32 = 0; i < ${i}; i++) {
+    var n = ${e}(s, px, py, pz);
+    n = abs(n);
+    sum += (n * -2.0 + 1.0) * amp;
+    amp *= mix(1.0, 1.0 - n, ${s});
+
+    px *= ${a};
+    py *= ${a};
+    pz *= ${a};
+    amp *= ${r};
+    s += 1;
+  }
+
+  return sum;
+}
+`;
+}
+function na(d, e, t, i, a, r, s, l, o) {
+  return `
+${d}
+${K()}
+
+fn noise(x: f32, y: f32) -> f32 {
+  var sum: f32 = 0.0;
+  var amp: f32 = ${l};
+  var px = x;
+  var py = y;
+  var s: i32 = ${t | 0};
+
+  for (var i: i32 = 0; i < ${i}; i++) {
+    let n = pingPong((${e}(s, px, py) + 1.0) * ${o});
+    sum += (n - 0.5) * 2.0 * amp;
+    amp *= mix(1.0, n, ${s});
+
+    px *= ${a};
+    py *= ${a};
+    amp *= ${r};
+    s += 1;
+  }
+
+  return sum;
+}
+`;
+}
+function ya(d, e, t, i, a, r, s, l, o) {
+  return `
+${d}
+${K()}
+
+fn noise(x: f32, y: f32, z: f32) -> f32 {
+  var sum: f32 = 0.0;
+  var amp: f32 = ${l};
+  var px = x;
+  var py = y;
+  var pz = z;
+  var s: i32 = ${t | 0};
+
+  for (var i: i32 = 0; i < ${i}; i++) {
+    let n = pingPong((${e}(s, px, py, pz) + 1.0) * ${o});
+    sum += (n - 0.5) * 2.0 * amp;
+    amp *= mix(1.0, n, ${s});
+
+    px *= ${a};
+    py *= ${a};
+    pz *= ${a};
+    amp *= ${r};
+    s += 1;
+  }
+
+  return sum;
+}
+`;
+}
+const fa = {
+  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};`,
+  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 = {
+  primesDouble: ["primes"],
+  hashR2: ["primes"],
+  hashR3: ["primes"],
+  valCoordR2: ["hashR2", "primes"],
+  valCoordR3: ["hashR3", "primes"],
+  gradCoordR2: ["hashR2", "primes", "gradients2D"],
+  gradCoordR3: ["hashR3", "primes", "gradients3D"]
+};
+function Me(...d) {
+  const e = /* @__PURE__ */ new Set();
+  function t(a) {
+    if (e.has(a)) return;
+    const r = ca[a];
+    if (r)
+      for (const s of r) t(s);
+    e.add(a);
+  }
+  for (const a of d)
+    for (const r of a) t(r);
+  const i = [];
+  for (const a of e)
+    i.push(fa[a]());
+  return i.join(`
+`);
+}
+const le = [
+  "primes",
+  "imul",
+  "hashR2",
+  "randVecs2D",
+  "interpHermite"
+], de = [
+  "primes",
+  "imul",
+  "hashR3",
+  "randVecs3D",
+  "interpHermite"
+];
+function oe() {
+  return `
+fn basicgrid_warp2d(seed: i32, x: f32, y: f32) -> vec2<f32> {
+  let x0i = i32(floor(x));
+  let y0i = i32(floor(y));
+
+  let xs = interpHermite(x - f32(x0i));
+  let ys = interpHermite(y - f32(y0i));
+
+  let x0 = imul(x0i, PRIME_X);
+  let y0 = imul(y0i, PRIME_Y);
+  let x1 = x0 + PRIME_X;
+  let y1 = y0 + PRIME_Y;
+
+  var hash0 = hashR2(seed, x0, y0) & (255 << 1u);
+  var hash1 = hashR2(seed, x1, y0) & (255 << 1u);
+
+  let lx0x = mix(RAND_VECS_2D[hash0], RAND_VECS_2D[hash1], xs);
+  let ly0x = mix(RAND_VECS_2D[hash0 | 1], RAND_VECS_2D[hash1 | 1], xs);
+
+  hash0 = hashR2(seed, x0, y1) & (255 << 1u);
+  hash1 = hashR2(seed, x1, y1) & (255 << 1u);
+
+  let lx1x = mix(RAND_VECS_2D[hash0], RAND_VECS_2D[hash1], xs);
+  let ly1x = mix(RAND_VECS_2D[hash0 | 1], RAND_VECS_2D[hash1 | 1], xs);
+
+  return vec2<f32>(
+    mix(lx0x, lx1x, ys),
+    mix(ly0x, ly1x, ys)
+  );
+}`;
+}
+function xe() {
+  return `
+fn basicgrid_warp3d(seed: i32, x: f32, y: f32, z: f32) -> vec3<f32> {
+  let x0i = i32(floor(x));
+  let y0i = i32(floor(y));
+  let z0i = i32(floor(z));
+
+  let xs = interpHermite(x - f32(x0i));
+  let ys = interpHermite(y - f32(y0i));
+  let zs = interpHermite(z - f32(z0i));
+
+  let x0 = imul(x0i, PRIME_X);
+  let y0 = imul(y0i, PRIME_Y);
+  let z0 = imul(z0i, PRIME_Z);
+  let x1 = x0 + PRIME_X;
+  let y1 = y0 + PRIME_Y;
+  let z1 = z0 + PRIME_Z;
+
+  // First layer (z0)
+  var hash0 = hashR3(seed, x0, y0, z0) & (255 << 2u);
+  var hash1 = hashR3(seed, x1, y0, z0) & (255 << 2u);
+
+  var lx0x = mix(RAND_VECS_3D[hash0], RAND_VECS_3D[hash1], xs);
+  var ly0x = mix(RAND_VECS_3D[hash0 | 1], RAND_VECS_3D[hash1 | 1], xs);
+  var lz0x = mix(RAND_VECS_3D[hash0 | 2], RAND_VECS_3D[hash1 | 2], xs);
+
+  hash0 = hashR3(seed, x0, y1, z0) & (255 << 2u);
+  hash1 = hashR3(seed, x1, y1, z0) & (255 << 2u);
+
+  var lx1x = mix(RAND_VECS_3D[hash0], RAND_VECS_3D[hash1], xs);
+  var ly1x = mix(RAND_VECS_3D[hash0 | 1], RAND_VECS_3D[hash1 | 1], xs);
+  var lz1x = mix(RAND_VECS_3D[hash0 | 2], RAND_VECS_3D[hash1 | 2], xs);
+
+  let lx0y = mix(lx0x, lx1x, ys);
+  let ly0y = mix(ly0x, ly1x, ys);
+  let lz0y = mix(lz0x, lz1x, ys);
+
+  // Second layer (z1)
+  hash0 = hashR3(seed, x0, y0, z1) & (255 << 2u);
+  hash1 = hashR3(seed, x1, y0, z1) & (255 << 2u);
+
+  lx0x = mix(RAND_VECS_3D[hash0], RAND_VECS_3D[hash1], xs);
+  ly0x = mix(RAND_VECS_3D[hash0 | 1], RAND_VECS_3D[hash1 | 1], xs);
+  lz0x = mix(RAND_VECS_3D[hash0 | 2], RAND_VECS_3D[hash1 | 2], xs);
+
+  hash0 = hashR3(seed, x0, y1, z1) & (255 << 2u);
+  hash1 = hashR3(seed, x1, y1, z1) & (255 << 2u);
+
+  lx1x = mix(RAND_VECS_3D[hash0], RAND_VECS_3D[hash1], xs);
+  ly1x = mix(RAND_VECS_3D[hash0 | 1], RAND_VECS_3D[hash1 | 1], xs);
+  lz1x = mix(RAND_VECS_3D[hash0 | 2], RAND_VECS_3D[hash1 | 2], xs);
+
+  return vec3<f32>(
+    mix(lx0y, mix(lx0x, lx1x, ys), zs),
+    mix(ly0y, mix(ly0x, ly1x, ys), zs),
+    mix(lz0y, mix(lz0x, lz1x, ys), zs)
+  );
+}`;
+}
+const Pe = 1.7320508075688772, ua = 0.5 * (Pe - 1), P = (3 - Pe) / 6, Ra = [
+  "primes",
+  "imul",
+  "hashR2",
+  "randVecs2D"
+], _a = [
+  "primes",
+  "imul",
+  "hashR2",
+  "randVecs2D",
+  "gradients2D"
+], va = [
+  "primes",
+  "imul",
+  "hashR3",
+  "randVecs3D"
+], za = [
+  "primes",
+  "imul",
+  "hashR3",
+  "randVecs3D",
+  "gradients3D"
+];
+function ne(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); }
+  let aaaa = a_in * a_in * (a_in * a_in);
+  var xo: f32;
+  var yo: f32;${e ? `
+  let rh = hashR2(seed, ip, jp) & (255 << 1u);
+  xo = RAND_VECS_2D[rh];
+  yo = RAND_VECS_2D[rh | 1];` : `
+  let rh = hashR2(seed, ip, jp);
+  let idx1 = rh & (127 << 1u);
+  let idx2 = (rh >> 7u) & (255 << 1u);
+  let xg = GRADIENTS_2D[idx1];
+  let yg = GRADIENTS_2D[idx1 | 1];
+  let val = dx * xg + dy * yg;
+  xo = val * RAND_VECS_2D[idx2];
+  yo = val * RAND_VECS_2D[idx2 | 1];`}
+  return vec3<f32>(aaaa * xo, aaaa * yo, 0.0);
+}
+
+fn os2_warp2d(seed: i32, cx: f32, cy: f32) -> vec2<f32> {
+  let t0 = (cx + cy) * ${ua};
+  let x = (cx + t0) * ${d};
+  let y = (cy + t0) * ${d};
+
+  let i = i32(floor(x));
+  let j = i32(floor(y));
+  let xi = x - f32(i);
+  let yi = y - f32(j);
+
+  let t = (xi + yi) * ${P};
+  let x0 = xi - t;
+  let y0 = yi - t;
+
+  let iPrimed = imul(i, PRIME_X);
+  let jPrimed = imul(j, PRIME_Y);
+
+  let a0 = 0.5 - x0 * x0 - y0 * y0;
+
+  // First contribution
+  let c0 = os2_warp2d_contrib(seed, iPrimed, jPrimed, x0, y0, a0);
+
+  // Second contribution (center)
+  let c_val = 2.0 * (1.0 - 2.0 * ${P}) * (1.0 / ${P} - 2.0) * t + (-2.0 * (1.0 - 2.0 * ${P}) * (1.0 - 2.0 * ${P}) + a0);
+  let x2 = x0 + (2.0 * ${P} - 1.0);
+  let y2 = y0 + (2.0 * ${P} - 1.0);
+  let c1 = os2_warp2d_contrib(seed, iPrimed + PRIME_X, jPrimed + PRIME_Y, x2, y2, c_val);
+
+  // Third contribution (depends on simplex half)
+  var c2 = vec3<f32>(0.0, 0.0, 0.0);
+  if (y0 > x0) {
+    let x1 = x0 + ${P};
+    let y1 = y0 + (${P} - 1.0);
+    let b = 0.5 - x1 * x1 - y1 * y1;
+    c2 = os2_warp2d_contrib(seed, iPrimed, jPrimed + PRIME_Y, x1, y1, b);
+  } else {
+    let x1 = x0 + (${P} - 1.0);
+    let y1 = y0 + ${P};
+    let b = 0.5 - x1 * x1 - y1 * y1;
+    c2 = os2_warp2d_contrib(seed, iPrimed + PRIME_X, jPrimed, x1, y1, b);
+  }
+
+  return vec2<f32>(
+    c0.x + c1.x + c2.x,
+    c0.y + c1.y + c2.y
+  );
+}`;
+}
+function ye(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); }
+  let aaaa = a_in * a_in * (a_in * a_in);
+  var xo: f32;
+  var yo: f32;
+  var zo: f32;${d ? `
+    let rh = hashR3(s, ip, jp, kp) & (255 << 2u);
+    xo = RAND_VECS_3D[rh];
+    yo = RAND_VECS_3D[rh | 1];
+    zo = RAND_VECS_3D[rh | 2];` : `
+    let rh = hashR3(s, ip, jp, kp);
+    let idx1 = rh & (63 << 2u);
+    let idx2 = (rh >> 6u) & (255 << 2u);
+    let xg = GRADIENTS_3D[idx1];
+    let yg = GRADIENTS_3D[idx1 | 1];
+    let zg = GRADIENTS_3D[idx1 | 2];
+    let val = dx * xg + dy * yg + dz * zg;
+    xo = val * RAND_VECS_3D[idx2];
+    yo = val * RAND_VECS_3D[idx2 | 1];
+    zo = val * RAND_VECS_3D[idx2 | 2];`}
+  return vec3<f32>(aaaa * xo, aaaa * yo, aaaa * zo);
+}
+
+fn os2_warp3d(seed_in: i32, x_in: f32, y_in: f32, z_in: f32) -> vec3<f32> {
+  var seed = seed_in;
+  var i = i32(round(x_in));
+  var j = i32(round(y_in));
+  var k = i32(round(z_in));
+  var x0 = x_in - f32(i);
+  var y0 = y_in - f32(j);
+  var z0 = z_in - f32(k);
+
+  var xNSign = i32((-x0 - 1.0)) | 1;
+  var yNSign = i32((-y0 - 1.0)) | 1;
+  var zNSign = i32((-z0 - 1.0)) | 1;
+
+  var ax0 = f32(xNSign) * -x0;
+  var ay0 = f32(yNSign) * -y0;
+  var az0 = f32(zNSign) * -z0;
+
+  i = imul(i, PRIME_X);
+  j = imul(j, PRIME_Y);
+  k = imul(k, PRIME_Z);
+
+  var vx: f32 = 0.0;
+  var vy: f32 = 0.0;
+  var vz: f32 = 0.0;
+
+  var a = 0.6 - x0 * x0 - (y0 * y0 + z0 * z0);
+
+  for (var l: i32 = 0; l < 2; l++) {
+    // First contribution
+    let c0 = os2_warp3d_contrib(seed, i, j, k, x0, y0, z0, a);
+    vx += c0.x;
+    vy += c0.y;
+    vz += c0.z;
+
+    // Additional contribution based on largest axis
+    var b = a;
+    var i1 = i;
+    var j1 = j;
+    var k1 = k;
+    var x1 = x0;
+    var y1 = y0;
+    var z1 = z0;
+
+    if (ax0 >= ay0 && ax0 >= az0) {
+      x1 += f32(xNSign);
+      b = b + ax0 + ax0;
+      i1 -= xNSign * PRIME_X;
+    } else if (ay0 > ax0 && ay0 >= az0) {
+      y1 += f32(yNSign);
+      b = b + ay0 + ay0;
+      j1 -= yNSign * PRIME_Y;
+    } else {
+      z1 += f32(zNSign);
+      b = b + az0 + az0;
+      k1 -= zNSign * PRIME_Z;
+    }
+
+    if (b > 1.0) {
+      let bv = b - 1.0;
+      let c1 = os2_warp3d_contrib(seed, i1, j1, k1, x1, y1, z1, bv);
+      vx += c1.x;
+      vy += c1.y;
+      vz += c1.z;
+    }
+
+    if (l == 0) {
+      ax0 = 0.5 - ax0;
+      ay0 = 0.5 - ay0;
+      az0 = 0.5 - az0;
+
+      x0 = f32(xNSign) * ax0;
+      y0 = f32(yNSign) * ay0;
+      z0 = f32(zNSign) * az0;
+
+      a += 0.75 - ax0 - (ay0 + az0);
+
+      i += (xNSign >> 1u) & PRIME_X;
+      j += (yNSign >> 1u) & PRIME_Y;
+      k += (zNSign >> 1u) & PRIME_Z;
+
+      xNSign = -xNSign;
+      yNSign = -yNSign;
+      zNSign = -zNSign;
+
+      seed += 1293373;
+    }
+  }
+
+  return vec3<f32>(vx, vy, vz);
+}`;
+}
+class Ea extends fe {
+  buildTSL2D() {
+    const { domainWarpType: e } = this.config;
+    return e === h.None ? this.buildNoWarp2D() : this.buildWithWarp2D();
+  }
+  /**
+   * Original path: no domain warp
+   */
+  buildNoWarp2D() {
+    const { seed: e, fractalType: t } = this.config, i = this.getBaseNoiseWGSL2D();
+    let a, r;
+    i.needsSkew ? (a = `${i.wgsl}
+
+fn ${i.fnName}_skewed(seed: i32, x: f32, y: f32) -> f32 {
+  let F2: f32 = 0.36602540378443864;
+  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}
+
+fn ${l}(x: f32, y: f32) -> f32 {
+  return ${r}(${e | 0}, x, y);
+}`;
+    else {
+      const x = this.calculateFractalBounding();
+      switch (t) {
+        case _.FBm:
+          s = k(
+            a,
+            r,
+            e,
+            this.config.fractalOctaves,
+            this.config.fractalLacunarity,
+            this.config.fractalGain,
+            this.config.fractalWeightedStrength,
+            x
+          );
+          break;
+        case _.Ridged:
+          s = se(
+            a,
+            r,
+            e,
+            this.config.fractalOctaves,
+            this.config.fractalLacunarity,
+            this.config.fractalGain,
+            this.config.fractalWeightedStrength,
+            x
+          );
+          break;
+        case _.PingPong:
+          s = na(
+            a,
+            r,
+            e,
+            this.config.fractalOctaves,
+            this.config.fractalLacunarity,
+            this.config.fractalGain,
+            this.config.fractalWeightedStrength,
+            x,
+            this.config.fractalPingPongStrength
+          );
+          break;
+        default:
+          s = k(
+            a,
+            r,
+            e,
+            this.config.fractalOctaves,
+            this.config.fractalLacunarity,
+            this.config.fractalGain,
+            this.config.fractalWeightedStrength,
+            x
+          );
+      }
+      l = "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});
+}
+${s}`;
+    return L(o);
+  }
+  /**
+   * Warp-enabled path: single wgslFn with deduplicated helpers
+   */
+  buildWithWarp2D() {
+    const {
+      seed: e,
+      fractalType: t,
+      frequency: i,
+      domainWarpFrequency: a,
+      domainWarpFractalType: r,
+      domainWarpFractalOctaves: s,
+      domainWarpFractalLacunarity: l,
+      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);
+    let v = y.fnName, u = y.core;
+    y.needsSkew && (u += `
+
+fn ${y.fnName}_skewed(seed: i32, x: f32, y: f32) -> f32 {
+  let F2: f32 = 0.36602540378443864;
+  let t = (x + y) * F2;
+  return ${y.fnName}(seed, x + t, y + t);
+}`, v = `${y.fnName}_skewed`);
+    const D = this.buildNoiseFractal2DCore(
+      u,
+      v,
+      e,
+      t
+    ), $ = `fn noise_entry(x_in: f32, y_in: f32) -> f32 {
+  var x = x_in;
+  var y = y_in;
+${this.buildWarpDispatch2D(
+      e,
+      a,
+      r,
+      s,
+      l,
+      o,
+      z,
+      n,
+      c.fnName
+    )}
+  return ${D.fnName}(x * ${i}, y * ${i});
+}
+${R}
+${c.core}
+${D.wgsl}`;
+    return L($);
+  }
+  buildWarpDispatch2D(e, t, i, a, r, s, l, o, x) {
+    if (i === w.None) {
+      const y = l * o;
+      return `  // Domain warp
+  {
+    let warp_d = ${x}(${e | 0}, x, y);
+    x += warp_d.x * ${y};
+    y += warp_d.y * ${y};
+  }`;
+    }
+    const z = i === w.Progressive;
+    let n = `  // Fractal domain warp
+`;
+    if (z) {
+      let y = l;
+      for (let c = 0; c < a; c++) {
+        const p = e + c | 0, R = y * o;
+        n += `  {
+    let wd${c} = ${x}(${p}, x, y);
+    x += wd${c}.x * ${R};
+    y += wd${c}.y * ${R};
+  }
+`, y *= s;
+      }
+    } else {
+      n += `  var dx: f32 = 0.0;
+  var dy: f32 = 0.0;
+`;
+      let y = l;
+      for (let c = 0; c < a; c++) {
+        const p = e + c | 0, R = y * o;
+        n += `  {
+    let wd${c} = ${x}(${p}, x_in, y_in);
+    dx += wd${c}.x * ${R};
+    dy += wd${c}.y * ${R};
+  }
+`, y *= s;
+      }
+      n += `  x += dx;
+  y += dy;
+`;
+    }
+    return n;
+  }
+  buildNoiseFractal2DCore(e, t, i, a) {
+    if (a === _.None) {
+      const y = `${t}_entry_core`;
+      return { wgsl: `${e}
+
+fn ${y}(x: f32, y: f32) -> f32 {
+  return ${t}(${i | 0}, x, y);
+}`, fnName: y };
+    }
+    const r = this.calculateFractalBounding(), {
+      fractalOctaves: s,
+      fractalLacunarity: l,
+      fractalGain: o,
+      fractalWeightedStrength: x,
+      fractalPingPongStrength: z
+    } = this.config;
+    let n;
+    switch (a) {
+      case _.FBm:
+        n = k(
+          e,
+          t,
+          i,
+          s,
+          l,
+          o,
+          x,
+          r
+        );
+        break;
+      case _.Ridged:
+        n = se(
+          e,
+          t,
+          i,
+          s,
+          l,
+          o,
+          x,
+          r
+        );
+        break;
+      case _.PingPong:
+        n = `${e}
+
+fn noise(x: f32, y: f32) -> f32 {
+  var sum: f32 = 0.0;
+  var amp: f32 = ${r};
+  var px = x;
+  var py = y;
+  var s: i32 = ${i | 0};
+
+  for (var i: i32 = 0; i < ${s}; i++) {
+    let n = pingPong((${t}(s, px, py) + 1.0) * ${z});
+    sum += (n - 0.5) * 2.0 * amp;
+    amp *= mix(1.0, n, ${x});
+
+    px *= ${l};
+    py *= ${l};
+    amp *= ${o};
+    s += 1;
+  }
+
+  return sum;
+}`;
+        break;
+      default:
+        n = k(
+          e,
+          t,
+          i,
+          s,
+          l,
+          o,
+          x,
+          r
+        );
+    }
+    return { wgsl: n, fnName: "noise" };
+  }
+  getWarpWGSL2D() {
+    switch (this.config.domainWarpType) {
+      case h.BasicGrid:
+        return {
+          core: oe(),
+          fnName: "basicgrid_warp2d",
+          helpers: le
+        };
+      case h.OpenSimplex2:
+        return {
+          core: ne(
+            this.config.domainWarpFrequency,
+            !1
+          ),
+          fnName: "os2_warp2d",
+          helpers: _a
+        };
+      case h.OpenSimplex2Reduced:
+        return {
+          core: ne(
+            this.config.domainWarpFrequency,
+            !0
+          ),
+          fnName: "os2_warp2d",
+          helpers: Ra
+        };
+      default:
+        return {
+          core: oe(),
+          fnName: "basicgrid_warp2d",
+          helpers: le
+        };
+    }
+  }
+  getBaseNoiseWGSLCore2D() {
+    switch (this.config.noiseType) {
+      case f.Value:
+        return {
+          core: Ae(),
+          fnName: "value2d",
+          helpers: Le,
+          needsSkew: !1
+        };
+      case f.Perlin:
+        return {
+          core: Ve(),
+          fnName: "perlin2d",
+          helpers: Xe,
+          needsSkew: !1
+        };
+      case f.ValueCubic:
+        return {
+          core: qe(),
+          fnName: "valuecubic2d",
+          helpers: Ze,
+          needsSkew: !1
+        };
+      case f.OpenSimplex2:
+        return {
+          core: B(),
+          fnName: "opensimplex2_2d",
+          helpers: ee,
+          needsSkew: !0
+        };
+      case f.OpenSimplex2S:
+        return {
+          core: ia(),
+          fnName: "opensimplex2s_2d",
+          helpers: ea,
+          needsSkew: !0
+        };
+      case f.Cellular:
+        return {
+          core: oa(
+            this.config.cellularDistanceFunction,
+            this.config.cellularReturnType,
+            this.config.cellularJitter
+          ),
+          fnName: "cellular2d",
+          helpers: la,
+          needsSkew: !1
+        };
+      default:
+        return {
+          core: B(),
+          fnName: "opensimplex2_2d",
+          helpers: ee,
+          needsSkew: !0
+        };
+    }
+  }
+  getBaseNoiseWGSL2D() {
+    switch (this.config.noiseType) {
+      case f.Value:
+        return {
+          wgsl: ke(),
+          fnName: "value2d",
+          needsSkew: !1
+        };
+      case f.Perlin:
+        return {
+          wgsl: We(),
+          fnName: "perlin2d",
+          needsSkew: !1
+        };
+      case f.ValueCubic:
+        return {
+          wgsl: He(),
+          fnName: "valuecubic2d",
+          needsSkew: !1
+        };
+      case f.OpenSimplex2:
+        return {
+          wgsl: ie(),
+          fnName: "opensimplex2_2d",
+          needsSkew: !0
+        };
+      case f.OpenSimplex2S:
+        return {
+          wgsl: Ue(),
+          fnName: "opensimplex2s_2d",
+          needsSkew: !0
+        };
+      case f.Cellular:
+        return {
+          wgsl: sa(
+            this.config.cellularDistanceFunction,
+            this.config.cellularReturnType,
+            this.config.cellularJitter
+          ),
+          fnName: "cellular2d",
+          needsSkew: !1
+        };
+      default:
+        return {
+          wgsl: ie(),
+          fnName: "opensimplex2_2d",
+          needsSkew: !0
+        };
+    }
+  }
+}
+function Z(d) {
+  switch (d) {
+    case m.ImproveXYPlanes:
+      return `{
+  let xy = x + y;
+  let s2 = xy * -0.211324865405187;
+  let zt = z * 0.577350269189626;
+  x = x + s2 - zt;
+  y = y + s2 - zt;
+  z = zt + xy * 0.577350269189626;
+}`;
+    case m.ImproveXZPlanes:
+      return `{
+  let xz = x + z;
+  let s2 = xz * -0.211324865405187;
+  let yt = y * 0.577350269189626;
+  x = x + s2 - yt;
+  z = z + s2 - yt;
+  y = yt + xz * 0.577350269189626;
+}`;
+    case m.DefaultOpenSimplex2:
+      return `{
+  let r = (x + y + z) * (2.0 / 3.0);
+  x = r - x;
+  y = r - y;
+  z = r - z;
+}`;
+    default:
+      return "";
+  }
+}
+class Ma extends fe {
+  buildTSL3D() {
+    const {
+      seed: e,
+      noiseType: t,
+      fractalType: i,
+      frequency: a,
+      rotationType3D: r,
+      domainWarpType: s
+    } = this.config;
+    let l, o;
+    switch (r) {
+      case m.ImproveXYPlanes:
+        l = m.ImproveXYPlanes, o = m.ImproveXYPlanes;
+        break;
+      case m.ImproveXZPlanes:
+        l = m.ImproveXZPlanes, o = m.ImproveXZPlanes;
+        break;
+      default:
+        switch (t) {
+          case f.OpenSimplex2:
+          case f.OpenSimplex2S:
+            l = m.DefaultOpenSimplex2;
+            break;
+          default:
+            l = m.None;
+        }
+        switch (s) {
+          case h.OpenSimplex2:
+          case h.OpenSimplex2Reduced:
+            o = m.DefaultOpenSimplex2;
+            break;
+          default:
+            o = m.None;
+        }
+    }
+    return s === h.None ? this.buildNoWarp3D(
+      e,
+      t,
+      i,
+      a,
+      l
+    ) : this.buildWithWarp3D(
+      e,
+      t,
+      i,
+      a,
+      l,
+      o
+    );
+  }
+  /**
+   * Original path: no domain warp, unchanged from before
+   */
+  buildNoWarp3D(e, t, i, a, r) {
+    const s = this.getBaseNoiseWGSL3D(), l = Z(r);
+    let o, x;
+    if (i === _.None)
+      o = s.wgsl, x = s.fnName, o += `
+
+fn noise_core(x: f32, y: f32, z: f32) -> f32 {
+  return ${x}(${e | 0}, x, y, z);
+}`, x = "noise_core";
+    else {
+      const n = this.calculateFractalBounding();
+      switch (i) {
+        case _.FBm:
+          o = b(
+            s.wgsl,
+            s.fnName,
+            e,
+            this.config.fractalOctaves,
+            this.config.fractalLacunarity,
+            this.config.fractalGain,
+            this.config.fractalWeightedStrength,
+            n
+          );
+          break;
+        case _.Ridged:
+          o = te(
+            s.wgsl,
+            s.fnName,
+            e,
+            this.config.fractalOctaves,
+            this.config.fractalLacunarity,
+            this.config.fractalGain,
+            this.config.fractalWeightedStrength,
+            n
+          );
+          break;
+        case _.PingPong:
+          o = ya(
+            s.wgsl,
+            s.fnName,
+            e,
+            this.config.fractalOctaves,
+            this.config.fractalLacunarity,
+            this.config.fractalGain,
+            this.config.fractalWeightedStrength,
+            n,
+            this.config.fractalPingPongStrength
+          );
+          break;
+        default:
+          o = b(
+            s.wgsl,
+            s.fnName,
+            e,
+            this.config.fractalOctaves,
+            this.config.fractalLacunarity,
+            this.config.fractalGain,
+            this.config.fractalWeightedStrength,
+            n
+          );
+      }
+      x = "noise";
+    }
+    const z = `fn noise_entry(x_in: f32, y_in: f32, z_in: f32) -> f32 {
+  var x = x_in * ${a};
+  var y = y_in * ${a};
+  var z = z_in * ${a};
+  ${l}
+  return ${x}(x, y, z);
+}
+${o}`;
+    return L(z);
+  }
+  /**
+   * Warp-enabled path: single wgslFn with deduplicated helpers
+   */
+  buildWithWarp3D(e, t, i, a, r, s) {
+    const {
+      domainWarpType: l,
+      domainWarpFrequency: o,
+      domainWarpFractalType: x,
+      domainWarpFractalOctaves: z,
+      domainWarpFractalLacunarity: n,
+      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(
+      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 {
+  var x = x_in;
+  var y = y_in;
+  var z = z_in;
+${this.buildWarpDispatch3D(
+      e,
+      l,
+      o,
+      x,
+      z,
+      n,
+      y,
+      p,
+      R,
+      Ce,
+      u.fnName
+    )}
+  x *= ${a};
+  y *= ${a};
+  z *= ${a};
+  ${ge}
+  return ${$.fnName}(x, y, z);
+}
+${g}
+${u.core}
+${$.wgsl}`;
+    return L(De);
+  }
+  /**
+   * 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) {
+    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;
+      return `  // Domain warp
+  {
+    var wx = x;
+    var wy = y;
+    var wz = z;
+    ${y}
+    wx *= ${i};
+    wy *= ${i};
+    wz *= ${i};
+    let warp_d = ${n}(${e | 0}, wx, wy, wz);
+    x += warp_d.x * ${R};
+    y += warp_d.y * ${R};
+    z += warp_d.z * ${R};
+  }`;
+    }
+    const c = a === w.Progressive;
+    let p = `  // Fractal domain warp
+`;
+    if (c) {
+      let R = o, v = i;
+      for (let u = 0; u < r; u++) {
+        const D = e + u | 0, g = R * x;
+        p += `  {
+    var wx = x;
+    var wy = y;
+    var wz = z;
+    ${y}
+    wx *= ${v};
+    wy *= ${v};
+    wz *= ${v};
+    let wd${u} = ${n}(${D}, wx, wy, wz);
+    x += wd${u}.x * ${g};
+    y += wd${u}.y * ${g};
+    z += wd${u}.z * ${g};
+  }
+`, R *= l, v *= s;
+      }
+    } else {
+      p += `  var dx: f32 = 0.0;
+  var dy: f32 = 0.0;
+  var dz: f32 = 0.0;
+`;
+      let R = o, v = i;
+      for (let u = 0; u < r; u++) {
+        const D = e + u | 0, g = R * x;
+        p += `  {
+    var wx = x_in;
+    var wy = y_in;
+    var wz = z_in;
+    ${y}
+    wx *= ${v};
+    wy *= ${v};
+    wz *= ${v};
+    let wd${u} = ${n}(${D}, wx, wy, wz);
+    dx += wd${u}.x * ${g};
+    dy += wd${u}.y * ${g};
+    dz += wd${u}.z * ${g};
+  }
+`, R *= l, v *= s;
+      }
+      p += `  x += dx;
+  y += dy;
+  z += dz;
+`;
+    }
+    return p;
+  }
+  /**
+   * Build noise + fractal WGSL from core-only noise (no helpers)
+   */
+  buildNoiseFractal3DCore(e, t, 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);
+}`, fnName: "noise_core" };
+    const r = this.calculateFractalBounding(), {
+      fractalOctaves: s,
+      fractalLacunarity: l,
+      fractalGain: o,
+      fractalWeightedStrength: x,
+      fractalPingPongStrength: z
+    } = this.config;
+    let n;
+    switch (a) {
+      case _.FBm:
+        n = b(
+          e,
+          t,
+          i,
+          s,
+          l,
+          o,
+          x,
+          r
+        );
+        break;
+      case _.Ridged:
+        n = te(
+          e,
+          t,
+          i,
+          s,
+          l,
+          o,
+          x,
+          r
+        );
+        break;
+      case _.PingPong:
+        n = `${e}
+
+fn noise(x: f32, y: f32, z: f32) -> f32 {
+  var sum: f32 = 0.0;
+  var amp: f32 = ${r};
+  var px = x;
+  var py = y;
+  var pz = z;
+  var s: i32 = ${i | 0};
+
+  for (var i: i32 = 0; i < ${s}; i++) {
+    let n = pingPong((${t}(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};
+    amp *= ${o};
+    s += 1;
+  }
+
+  return sum;
+}`;
+        break;
+      default:
+        n = b(
+          e,
+          t,
+          i,
+          s,
+          l,
+          o,
+          x,
+          r
+        );
+    }
+    return { wgsl: n, fnName: "noise" };
+  }
+  /**
+   * Get warp WGSL core function and its helper requirements
+   */
+  getWarpWGSL3D() {
+    switch (this.config.domainWarpType) {
+      case h.BasicGrid:
+        return {
+          core: xe(),
+          fnName: "basicgrid_warp3d",
+          helpers: de
+        };
+      case h.OpenSimplex2:
+        return {
+          core: ye(!1),
+          fnName: "os2_warp3d",
+          helpers: za
+        };
+      case h.OpenSimplex2Reduced:
+        return {
+          core: ye(!0),
+          fnName: "os2_warp3d",
+          helpers: va
+        };
+      default:
+        return {
+          core: xe(),
+          fnName: "basicgrid_warp3d",
+          helpers: de
+        };
+    }
+  }
+  /**
+   * Get noise WGSL core function (no helpers) and its helper requirements
+   */
+  getBaseNoiseWGSLCore3D() {
+    switch (this.config.noiseType) {
+      case f.Value:
+        return {
+          core: Ge(),
+          fnName: "value3d",
+          helpers: we
+        };
+      case f.Perlin:
+        return {
+          core: Fe(),
+          fnName: "perlin3d",
+          helpers: Ye
+        };
+      case f.ValueCubic:
+        return {
+          core: Je(),
+          fnName: "valuecubic3d",
+          helpers: Be
+        };
+      case f.OpenSimplex2:
+        return {
+          core: H(),
+          fnName: "opensimplex2_3d",
+          helpers: ae
+        };
+      case f.OpenSimplex2S:
+        return {
+          core: ra(),
+          fnName: "opensimplex2s_3d",
+          helpers: aa
+        };
+      case f.Cellular:
+        return {
+          core: xa(
+            this.config.cellularDistanceFunction,
+            this.config.cellularReturnType,
+            this.config.cellularJitter
+          ),
+          fnName: "cellular3d",
+          helpers: da
+        };
+      default:
+        return {
+          core: H(),
+          fnName: "opensimplex2_3d",
+          helpers: ae
+        };
+    }
+  }
+  /**
+   * Get amplitude multiplier for 3D domain warp (type-specific)
+   */
+  getWarpAmplitudeMultiplier3D() {
+    switch (this.config.domainWarpType) {
+      case h.OpenSimplex2:
+        return 32.69428253173828;
+      case h.OpenSimplex2Reduced:
+        return 7.71604938271605;
+      case h.BasicGrid:
+      default:
+        return 1;
+    }
+  }
+  getBaseNoiseWGSL3D() {
+    switch (this.config.noiseType) {
+      case f.Value:
+        return { wgsl: be(), fnName: "value3d" };
+      case f.Perlin:
+        return { wgsl: je(), fnName: "perlin3d" };
+      case f.ValueCubic:
+        return {
+          wgsl: Oe(),
+          fnName: "valuecubic3d"
+        };
+      case f.OpenSimplex2:
+        return {
+          wgsl: re(),
+          fnName: "opensimplex2_3d"
+        };
+      case f.OpenSimplex2S:
+        return {
+          wgsl: Ke(),
+          fnName: "opensimplex2s_3d"
+        };
+      case f.Cellular:
+        return {
+          wgsl: ta(
+            this.config.cellularDistanceFunction,
+            this.config.cellularReturnType,
+            this.config.cellularJitter
+          ),
+          fnName: "cellular3d"
+        };
+      default:
+        return {
+          wgsl: re(),
+          fnName: "opensimplex2_3d"
+        };
+    }
+  }
+}
+export {
+  M as CellularDistanceFunction,
+  C as CellularReturnType,
+  w as DomainWarpFractalType,
+  h as DomainWarpType,
+  _ as FractalType,
+  f as NoiseType,
+  ga as RotationType3D,
+  Ea as TSLNoiseBuilder2D,
+  Ma as TSLNoiseBuilder3D,
+  m as TransformType3D
+};