@ansh-ui/core 0.2.0

package/dist/chunk-DXJ63QAR.cjs

@@ -0,0 +1,723 @@
+'use strict';
+
+var chunkFNR35HTL_cjs = require('./chunk-FNR35HTL.cjs');
+var chunkILKUL7GD_cjs = require('./chunk-ILKUL7GD.cjs');
+
+// src/noise/tables.ts
+var GRAD3 = new Float32Array([
+  1,
+  1,
+  0,
+  -1,
+  1,
+  0,
+  1,
+  -1,
+  0,
+  -1,
+  -1,
+  0,
+  1,
+  0,
+  1,
+  -1,
+  0,
+  1,
+  1,
+  0,
+  -1,
+  -1,
+  0,
+  -1,
+  0,
+  1,
+  1,
+  0,
+  -1,
+  1,
+  0,
+  1,
+  -1,
+  0,
+  -1,
+  -1
+]);
+var GRAD4 = new Float32Array([
+  0,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  -1,
+  0,
+  1,
+  -1,
+  1,
+  0,
+  1,
+  -1,
+  -1,
+  0,
+  -1,
+  1,
+  1,
+  0,
+  -1,
+  1,
+  -1,
+  0,
+  -1,
+  -1,
+  1,
+  0,
+  -1,
+  -1,
+  -1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  0,
+  1,
+  -1,
+  1,
+  0,
+  -1,
+  1,
+  1,
+  0,
+  -1,
+  -1,
+  -1,
+  0,
+  1,
+  1,
+  -1,
+  0,
+  1,
+  -1,
+  -1,
+  0,
+  -1,
+  1,
+  -1,
+  0,
+  -1,
+  -1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  0,
+  -1,
+  1,
+  -1,
+  0,
+  1,
+  1,
+  -1,
+  0,
+  -1,
+  -1,
+  1,
+  0,
+  1,
+  -1,
+  1,
+  0,
+  -1,
+  -1,
+  -1,
+  0,
+  1,
+  -1,
+  -1,
+  0,
+  -1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  -1,
+  0,
+  1,
+  -1,
+  1,
+  0,
+  1,
+  -1,
+  -1,
+  0,
+  -1,
+  1,
+  1,
+  0,
+  -1,
+  1,
+  -1,
+  0,
+  -1,
+  -1,
+  1,
+  0,
+  -1,
+  -1,
+  -1,
+  0
+]);
+var tableCache = /* @__PURE__ */ new Map();
+var MAX_CACHED_TABLES = 32;
+function createNoiseTables(seed = 0) {
+  const key = seed >>> 0;
+  const cached = tableCache.get(key);
+  if (cached) return cached;
+  const rng = chunkFNR35HTL_cjs.createRng(key);
+  const source = new Uint8Array(256);
+  for (let i = 0; i < 256; i++) source[i] = i;
+  for (let i = 255; i > 0; i--) {
+    const j = Math.floor(rng.next() * (i + 1));
+    const tmp = source[i];
+    source[i] = source[j];
+    source[j] = tmp;
+  }
+  const perm = new Uint8Array(512);
+  const permMod12 = new Uint8Array(512);
+  const permMod32 = new Uint8Array(512);
+  for (let i = 0; i < 512; i++) {
+    const value = source[i & 255];
+    perm[i] = value;
+    permMod12[i] = value % 12;
+    permMod32[i] = value % 32;
+  }
+  const tables = { perm, permMod12, permMod32 };
+  if (tableCache.size >= MAX_CACHED_TABLES) {
+    const oldest = tableCache.keys().next();
+    if (!oldest.done) tableCache.delete(oldest.value);
+  }
+  tableCache.set(key, tables);
+  return tables;
+}
+function clearNoiseTableCache() {
+  tableCache.clear();
+}
+
+// src/noise/perlin.ts
+function fade(t) {
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function lerp(a, b, t) {
+  return a + t * (b - a);
+}
+function grad2(hash, x, y) {
+  switch (hash & 7) {
+    case 0:
+      return x + y;
+    case 1:
+      return -x + y;
+    case 2:
+      return x - y;
+    case 3:
+      return -x - y;
+    case 4:
+      return x;
+    case 5:
+      return -x;
+    case 6:
+      return y;
+    default:
+      return -y;
+  }
+}
+function grad3(hash, x, y, z) {
+  const h = hash & 15;
+  const u = h < 8 ? x : y;
+  const v = h < 4 ? y : h === 12 || h === 14 ? x : z;
+  return (h & 1 ? -u : u) + (h & 2 ? -v : v);
+}
+function createPerlinNoise(seed = 0) {
+  const { perm } = createNoiseTables(seed);
+  function noise2D(x, y) {
+    const xi = Math.floor(x) & 255;
+    const yi = Math.floor(y) & 255;
+    const xf = x - Math.floor(x);
+    const yf = y - Math.floor(y);
+    const u = fade(xf);
+    const v = fade(yf);
+    const aa = perm[perm[xi] + yi];
+    const ab = perm[perm[xi] + yi + 1];
+    const ba = perm[perm[xi + 1] + yi];
+    const bb = perm[perm[xi + 1] + yi + 1];
+    const x1 = lerp(grad2(aa, xf, yf), grad2(ba, xf - 1, yf), u);
+    const x2 = lerp(grad2(ab, xf, yf - 1), grad2(bb, xf - 1, yf - 1), u);
+    return lerp(x1, x2, v) * 0.7071067811865475;
+  }
+  function noise3D(x, y, z) {
+    const xi = Math.floor(x) & 255;
+    const yi = Math.floor(y) & 255;
+    const zi = Math.floor(z) & 255;
+    const xf = x - Math.floor(x);
+    const yf = y - Math.floor(y);
+    const zf = z - Math.floor(z);
+    const u = fade(xf);
+    const v = fade(yf);
+    const w = fade(zf);
+    const a = perm[xi] + yi;
+    const aa = perm[a] + zi;
+    const ab = perm[a + 1] + zi;
+    const b = perm[xi + 1] + yi;
+    const ba = perm[b] + zi;
+    const bb = perm[b + 1] + zi;
+    const x1 = lerp(grad3(perm[aa], xf, yf, zf), grad3(perm[ba], xf - 1, yf, zf), u);
+    const x2 = lerp(grad3(perm[ab], xf, yf - 1, zf), grad3(perm[bb], xf - 1, yf - 1, zf), u);
+    const y1 = lerp(x1, x2, v);
+    const x3 = lerp(grad3(perm[aa + 1], xf, yf, zf - 1), grad3(perm[ba + 1], xf - 1, yf, zf - 1), u);
+    const x4 = lerp(
+      grad3(perm[ab + 1], xf, yf - 1, zf - 1),
+      grad3(perm[bb + 1], xf - 1, yf - 1, zf - 1),
+      u
+    );
+    const y2 = lerp(x3, x4, v);
+    return lerp(y1, y2, w);
+  }
+  return { noise2D, noise3D };
+}
+function createValueNoise(seed = 0) {
+  const { perm } = createNoiseTables(seed);
+  const valueAt = (x, y) => perm[perm[x & 255] + (y & 255)] / 255 * 2 - 1;
+  return {
+    noise2D(x, y) {
+      const xi = Math.floor(x);
+      const yi = Math.floor(y);
+      const u = fade(x - xi);
+      const v = fade(y - yi);
+      const x1 = lerp(valueAt(xi, yi), valueAt(xi + 1, yi), u);
+      const x2 = lerp(valueAt(xi, yi + 1), valueAt(xi + 1, yi + 1), u);
+      return lerp(x1, x2, v);
+    }
+  };
+}
+
+// src/noise/simplex.ts
+var F2 = 0.5 * (Math.sqrt(3) - 1);
+var G2 = (3 - Math.sqrt(3)) / 6;
+var F3 = 1 / 3;
+var G3 = 1 / 6;
+var F4 = (Math.sqrt(5) - 1) / 4;
+var G4 = (5 - Math.sqrt(5)) / 20;
+function createSimplexNoise(seed = 0) {
+  const { perm, permMod12, permMod32 } = createNoiseTables(seed);
+  function noise2D(x, y) {
+    const s = (x + y) * F2;
+    const i = Math.floor(x + s);
+    const j = Math.floor(y + s);
+    const t = (i + j) * G2;
+    const x0 = x - (i - t);
+    const y0 = y - (j - t);
+    const i1 = x0 > y0 ? 1 : 0;
+    const j1 = x0 > y0 ? 0 : 1;
+    const x1 = x0 - i1 + G2;
+    const y1 = y0 - j1 + G2;
+    const x2 = x0 - 1 + 2 * G2;
+    const y2 = y0 - 1 + 2 * G2;
+    const ii = i & 255;
+    const jj = j & 255;
+    let n0 = 0;
+    let n1 = 0;
+    let n2 = 0;
+    let t0 = 0.5 - x0 * x0 - y0 * y0;
+    if (t0 >= 0) {
+      const gi0 = permMod12[ii + perm[jj]] * 3;
+      t0 *= t0;
+      n0 = t0 * t0 * (GRAD3[gi0] * x0 + GRAD3[gi0 + 1] * y0);
+    }
+    let t1 = 0.5 - x1 * x1 - y1 * y1;
+    if (t1 >= 0) {
+      const gi1 = permMod12[ii + i1 + perm[jj + j1]] * 3;
+      t1 *= t1;
+      n1 = t1 * t1 * (GRAD3[gi1] * x1 + GRAD3[gi1 + 1] * y1);
+    }
+    let t2 = 0.5 - x2 * x2 - y2 * y2;
+    if (t2 >= 0) {
+      const gi2 = permMod12[ii + 1 + perm[jj + 1]] * 3;
+      t2 *= t2;
+      n2 = t2 * t2 * (GRAD3[gi2] * x2 + GRAD3[gi2 + 1] * y2);
+    }
+    return 70 * (n0 + n1 + n2);
+  }
+  function noise3D(x, y, z) {
+    const s = (x + y + z) * F3;
+    const i = Math.floor(x + s);
+    const j = Math.floor(y + s);
+    const k = Math.floor(z + s);
+    const t = (i + j + k) * G3;
+    const x0 = x - (i - t);
+    const y0 = y - (j - t);
+    const z0 = z - (k - t);
+    let i1, j1, k1;
+    let i2, j2, k2;
+    if (x0 >= y0) {
+      if (y0 >= z0) {
+        i1 = 1;
+        j1 = 0;
+        k1 = 0;
+        i2 = 1;
+        j2 = 1;
+        k2 = 0;
+      } else if (x0 >= z0) {
+        i1 = 1;
+        j1 = 0;
+        k1 = 0;
+        i2 = 1;
+        j2 = 0;
+        k2 = 1;
+      } else {
+        i1 = 0;
+        j1 = 0;
+        k1 = 1;
+        i2 = 1;
+        j2 = 0;
+        k2 = 1;
+      }
+    } else {
+      if (y0 < z0) {
+        i1 = 0;
+        j1 = 0;
+        k1 = 1;
+        i2 = 0;
+        j2 = 1;
+        k2 = 1;
+      } else if (x0 < z0) {
+        i1 = 0;
+        j1 = 1;
+        k1 = 0;
+        i2 = 0;
+        j2 = 1;
+        k2 = 1;
+      } else {
+        i1 = 0;
+        j1 = 1;
+        k1 = 0;
+        i2 = 1;
+        j2 = 1;
+        k2 = 0;
+      }
+    }
+    const x1 = x0 - i1 + G3;
+    const y1 = y0 - j1 + G3;
+    const z1 = z0 - k1 + G3;
+    const x2 = x0 - i2 + 2 * G3;
+    const y2 = y0 - j2 + 2 * G3;
+    const z2 = z0 - k2 + 2 * G3;
+    const x3 = x0 - 1 + 3 * G3;
+    const y3 = y0 - 1 + 3 * G3;
+    const z3 = z0 - 1 + 3 * G3;
+    const ii = i & 255;
+    const jj = j & 255;
+    const kk = k & 255;
+    let n0 = 0;
+    let n1 = 0;
+    let n2 = 0;
+    let n3 = 0;
+    let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
+    if (t0 >= 0) {
+      const gi0 = permMod12[ii + perm[jj + perm[kk]]] * 3;
+      t0 *= t0;
+      n0 = t0 * t0 * (GRAD3[gi0] * x0 + GRAD3[gi0 + 1] * y0 + GRAD3[gi0 + 2] * z0);
+    }
+    let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
+    if (t1 >= 0) {
+      const gi1 = permMod12[ii + i1 + perm[jj + j1 + perm[kk + k1]]] * 3;
+      t1 *= t1;
+      n1 = t1 * t1 * (GRAD3[gi1] * x1 + GRAD3[gi1 + 1] * y1 + GRAD3[gi1 + 2] * z1);
+    }
+    let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
+    if (t2 >= 0) {
+      const gi2 = permMod12[ii + i2 + perm[jj + j2 + perm[kk + k2]]] * 3;
+      t2 *= t2;
+      n2 = t2 * t2 * (GRAD3[gi2] * x2 + GRAD3[gi2 + 1] * y2 + GRAD3[gi2 + 2] * z2);
+    }
+    let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
+    if (t3 >= 0) {
+      const gi3 = permMod12[ii + 1 + perm[jj + 1 + perm[kk + 1]]] * 3;
+      t3 *= t3;
+      n3 = t3 * t3 * (GRAD3[gi3] * x3 + GRAD3[gi3 + 1] * y3 + GRAD3[gi3 + 2] * z3);
+    }
+    return 32 * (n0 + n1 + n2 + n3);
+  }
+  function noise4D(x, y, z, w) {
+    const s = (x + y + z + w) * F4;
+    const i = Math.floor(x + s);
+    const j = Math.floor(y + s);
+    const k = Math.floor(z + s);
+    const l = Math.floor(w + s);
+    const t = (i + j + k + l) * G4;
+    const x0 = x - (i - t);
+    const y0 = y - (j - t);
+    const z0 = z - (k - t);
+    const w0 = w - (l - t);
+    let rankx = 0;
+    let ranky = 0;
+    let rankz = 0;
+    let rankw = 0;
+    if (x0 > y0) rankx++;
+    else ranky++;
+    if (x0 > z0) rankx++;
+    else rankz++;
+    if (x0 > w0) rankx++;
+    else rankw++;
+    if (y0 > z0) ranky++;
+    else rankz++;
+    if (y0 > w0) ranky++;
+    else rankw++;
+    if (z0 > w0) rankz++;
+    else rankw++;
+    const i1 = rankx >= 3 ? 1 : 0;
+    const j1 = ranky >= 3 ? 1 : 0;
+    const k1 = rankz >= 3 ? 1 : 0;
+    const l1 = rankw >= 3 ? 1 : 0;
+    const i2 = rankx >= 2 ? 1 : 0;
+    const j2 = ranky >= 2 ? 1 : 0;
+    const k2 = rankz >= 2 ? 1 : 0;
+    const l2 = rankw >= 2 ? 1 : 0;
+    const i3 = rankx >= 1 ? 1 : 0;
+    const j3 = ranky >= 1 ? 1 : 0;
+    const k3 = rankz >= 1 ? 1 : 0;
+    const l3 = rankw >= 1 ? 1 : 0;
+    const x1 = x0 - i1 + G4;
+    const y1 = y0 - j1 + G4;
+    const z1 = z0 - k1 + G4;
+    const w1 = w0 - l1 + G4;
+    const x2 = x0 - i2 + 2 * G4;
+    const y2 = y0 - j2 + 2 * G4;
+    const z2 = z0 - k2 + 2 * G4;
+    const w2 = w0 - l2 + 2 * G4;
+    const x3 = x0 - i3 + 3 * G4;
+    const y3 = y0 - j3 + 3 * G4;
+    const z3 = z0 - k3 + 3 * G4;
+    const w3 = w0 - l3 + 3 * G4;
+    const x4 = x0 - 1 + 4 * G4;
+    const y4 = y0 - 1 + 4 * G4;
+    const z4 = z0 - 1 + 4 * G4;
+    const w4 = w0 - 1 + 4 * G4;
+    const ii = i & 255;
+    const jj = j & 255;
+    const kk = k & 255;
+    const ll = l & 255;
+    let n = 0;
+    let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
+    if (t0 >= 0) {
+      const gi = permMod32[ii + perm[jj + perm[kk + perm[ll]]]] * 4;
+      t0 *= t0;
+      n += t0 * t0 * (GRAD4[gi] * x0 + GRAD4[gi + 1] * y0 + GRAD4[gi + 2] * z0 + GRAD4[gi + 3] * w0);
+    }
+    let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
+    if (t1 >= 0) {
+      const gi = permMod32[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]] * 4;
+      t1 *= t1;
+      n += t1 * t1 * (GRAD4[gi] * x1 + GRAD4[gi + 1] * y1 + GRAD4[gi + 2] * z1 + GRAD4[gi + 3] * w1);
+    }
+    let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
+    if (t2 >= 0) {
+      const gi = permMod32[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]] * 4;
+      t2 *= t2;
+      n += t2 * t2 * (GRAD4[gi] * x2 + GRAD4[gi + 1] * y2 + GRAD4[gi + 2] * z2 + GRAD4[gi + 3] * w2);
+    }
+    let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
+    if (t3 >= 0) {
+      const gi = permMod32[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]] * 4;
+      t3 *= t3;
+      n += t3 * t3 * (GRAD4[gi] * x3 + GRAD4[gi + 1] * y3 + GRAD4[gi + 2] * z3 + GRAD4[gi + 3] * w3);
+    }
+    let t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
+    if (t4 >= 0) {
+      const gi = permMod32[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] * 4;
+      t4 *= t4;
+      n += t4 * t4 * (GRAD4[gi] * x4 + GRAD4[gi + 1] * y4 + GRAD4[gi + 2] * z4 + GRAD4[gi + 3] * w4);
+    }
+    return 27 * n;
+  }
+  return { noise2D, noise3D, noise4D };
+}
+
+// src/noise/fractal.ts
+var FRACTAL_DEFAULTS = {
+  octaves: 4,
+  lacunarity: 2,
+  gain: 0.5,
+  frequency: 1,
+  amplitude: 1,
+  normalize: true
+};
+function resolve(options) {
+  return {
+    octaves: Math.max(1, Math.floor(options?.octaves ?? FRACTAL_DEFAULTS.octaves)),
+    lacunarity: options?.lacunarity ?? FRACTAL_DEFAULTS.lacunarity,
+    gain: options?.gain ?? FRACTAL_DEFAULTS.gain,
+    frequency: options?.frequency ?? FRACTAL_DEFAULTS.frequency,
+    amplitude: options?.amplitude ?? FRACTAL_DEFAULTS.amplitude,
+    normalize: options?.normalize ?? FRACTAL_DEFAULTS.normalize
+  };
+}
+function fbm2D(noise, options) {
+  const { octaves, lacunarity, gain, frequency, amplitude, normalize } = resolve(options);
+  return (x, y) => {
+    let sum = 0;
+    let amp = amplitude;
+    let freq = frequency;
+    let total = 0;
+    for (let i = 0; i < octaves; i++) {
+      sum += noise(x * freq, y * freq) * amp;
+      total += amp;
+      amp *= gain;
+      freq *= lacunarity;
+    }
+    return normalize && total > 0 ? sum / total : sum;
+  };
+}
+function fbm3D(noise, options) {
+  const { octaves, lacunarity, gain, frequency, amplitude, normalize } = resolve(options);
+  return (x, y, z) => {
+    let sum = 0;
+    let amp = amplitude;
+    let freq = frequency;
+    let total = 0;
+    for (let i = 0; i < octaves; i++) {
+      sum += noise(x * freq, y * freq, z * freq) * amp;
+      total += amp;
+      amp *= gain;
+      freq *= lacunarity;
+    }
+    return normalize && total > 0 ? sum / total : sum;
+  };
+}
+function ridged2D(noise, options) {
+  const { octaves, lacunarity, gain, frequency, amplitude } = resolve(options);
+  return (x, y) => {
+    let sum = 0;
+    let amp = amplitude;
+    let freq = frequency;
+    let total = 0;
+    for (let i = 0; i < octaves; i++) {
+      const n = 1 - Math.abs(noise(x * freq, y * freq));
+      sum += n * n * amp;
+      total += amp;
+      amp *= gain;
+      freq *= lacunarity;
+    }
+    return total > 0 ? chunkILKUL7GD_cjs.clamp(sum / total, 0, 1) : 0;
+  };
+}
+function turbulence2D(noise, options) {
+  const { octaves, lacunarity, gain, frequency, amplitude } = resolve(options);
+  return (x, y) => {
+    let sum = 0;
+    let amp = amplitude;
+    let freq = frequency;
+    let total = 0;
+    for (let i = 0; i < octaves; i++) {
+      sum += Math.abs(noise(x * freq, y * freq)) * amp;
+      total += amp;
+      amp *= gain;
+      freq *= lacunarity;
+    }
+    return total > 0 ? chunkILKUL7GD_cjs.clamp(sum / total, 0, 1) : 0;
+  };
+}
+function warp2D(noise, strength = 1, offset = 5.2) {
+  return (x, y) => {
+    const qx = noise(x, y);
+    const qy = noise(x + offset, y + offset * 0.7);
+    return noise(x + strength * qx, y + strength * qy);
+  };
+}
+function curl2D(noise, epsilon = 1e-4) {
+  const inv = 1 / (2 * epsilon);
+  return (x, y) => {
+    const dNdy = (noise(x, y + epsilon) - noise(x, y - epsilon)) * inv;
+    const dNdx = (noise(x + epsilon, y) - noise(x - epsilon, y)) * inv;
+    return { x: dNdy, y: -dNdx };
+  };
+}
+function curl2DAnimated(noise, epsilon = 1e-4) {
+  const inv = 1 / (2 * epsilon);
+  return (x, y, t) => {
+    const dNdy = (noise(x, y + epsilon, t) - noise(x, y - epsilon, t)) * inv;
+    const dNdx = (noise(x + epsilon, y, t) - noise(x - epsilon, y, t)) * inv;
+    return { x: dNdy, y: -dNdx };
+  };
+}
+function tileable2D(noise4D, width, height) {
+  const TAU = Math.PI * 2;
+  const rx = width / TAU;
+  const ry = height / TAU;
+  return (x, y) => {
+    const u = x / Math.max(1e-6, width) * TAU;
+    const v = y / Math.max(1e-6, height) * TAU;
+    return noise4D(Math.cos(u) * rx, Math.sin(u) * rx, Math.cos(v) * ry, Math.sin(v) * ry);
+  };
+}
+
+// src/noise/index.ts
+function createNoise(seed = 0) {
+  const numericSeed = typeof seed === "string" ? hashSeed(seed) : seed;
+  const simplex = createSimplexNoise(numericSeed);
+  const perlin = createPerlinNoise(numericSeed);
+  const value = createValueNoise(numericSeed);
+  return {
+    seed: numericSeed,
+    /** Raw single-octave sources. */
+    simplex2D: simplex.noise2D,
+    simplex3D: simplex.noise3D,
+    simplex4D: simplex.noise4D,
+    perlin2D: perlin.noise2D,
+    perlin3D: perlin.noise3D,
+    value2D: value.noise2D,
+    /** Fractal compositions over simplex. */
+    fbm2D: (options) => fbm2D(simplex.noise2D, options),
+    fbm3D: (options) => fbm3D(simplex.noise3D, options),
+    ridged2D: (options) => ridged2D(simplex.noise2D, options),
+    turbulence2D: (options) => turbulence2D(simplex.noise2D, options),
+    /** Domain-warped fBm — the organic, marbled look. */
+    warped2D: (strength = 1, options) => warp2D(fbm2D(simplex.noise2D, options), strength),
+    /** Divergence-free flow field for particle advection. */
+    curl: (options) => curl2D(fbm2D(simplex.noise2D, options)),
+    curlAnimated: (options) => curl2DAnimated(fbm3D(simplex.noise3D, options)),
+    /** Seamlessly tiling field over the given extent. */
+    tileable: (width, height) => tileable2D(simplex.noise4D, width, height)
+  };
+}
+function hashSeed(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+exports.FRACTAL_DEFAULTS = FRACTAL_DEFAULTS;
+exports.GRAD3 = GRAD3;
+exports.GRAD4 = GRAD4;
+exports.clearNoiseTableCache = clearNoiseTableCache;
+exports.createNoise = createNoise;
+exports.createNoiseTables = createNoiseTables;
+exports.createPerlinNoise = createPerlinNoise;
+exports.createSimplexNoise = createSimplexNoise;
+exports.createValueNoise = createValueNoise;
+exports.curl2D = curl2D;
+exports.curl2DAnimated = curl2DAnimated;
+exports.fbm2D = fbm2D;
+exports.fbm3D = fbm3D;
+exports.ridged2D = ridged2D;
+exports.tileable2D = tileable2D;
+exports.turbulence2D = turbulence2D;
+exports.warp2D = warp2D;
+//# sourceMappingURL=chunk-DXJ63QAR.cjs.map
+//# sourceMappingURL=chunk-DXJ63QAR.cjs.map