@esengine/procgen 1.0.0

package/dist/index.js

@@ -0,0 +1,1792 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/noise/PerlinNoise.ts
+var _PerlinNoise = class _PerlinNoise {
+  /**
+   * @zh 创建 Perlin 噪声生成器
+   * @en Create Perlin noise generator
+   *
+   * @param seed - @zh 随机种子 @en Random seed
+   */
+  constructor(seed = 0) {
+    __publicField(this, "_perm");
+    __publicField(this, "_gradP");
+    this._perm = new Uint8Array(512);
+    this._gradP = new Float32Array(512 * 3);
+    this._seed(seed);
+  }
+  _seed(seed) {
+    const p = new Uint8Array(256);
+    for (let i = 0; i < 256; i++) {
+      p[i] = i;
+    }
+    let n = seed;
+    for (let i = 255; i > 0; i--) {
+      n = n * 16807 % 2147483647;
+      const j = n % (i + 1);
+      [p[i], p[j]] = [
+        p[j],
+        p[i]
+      ];
+    }
+    for (let i = 0; i < 512; i++) {
+      this._perm[i] = p[i & 255];
+    }
+    const grad3 = [
+      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
+    ];
+    for (let i = 0; i < 512; i++) {
+      const gi = this._perm[i] % 12 * 3;
+      this._gradP[i * 3] = grad3[gi];
+      this._gradP[i * 3 + 1] = grad3[gi + 1];
+      this._gradP[i * 3 + 2] = grad3[gi + 2];
+    }
+  }
+  _fade(t) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+  }
+  _lerp(a, b, t) {
+    return a + t * (b - a);
+  }
+  _dot2(gi, x, y) {
+    return this._gradP[gi * 3] * x + this._gradP[gi * 3 + 1] * y;
+  }
+  _dot3(gi, x, y, z) {
+    return this._gradP[gi * 3] * x + this._gradP[gi * 3 + 1] * y + this._gradP[gi * 3 + 2] * z;
+  }
+  /**
+   * @zh 2D Perlin 噪声
+   * @en 2D Perlin noise
+   *
+   * @param x - @zh X 坐标 @en X coordinate
+   * @param y - @zh Y 坐标 @en Y coordinate
+   * @returns @zh 噪声值 [-1, 1] @en Noise value [-1, 1]
+   */
+  noise2D(x, y) {
+    const X = Math.floor(x) & 255;
+    const Y = Math.floor(y) & 255;
+    x -= Math.floor(x);
+    y -= Math.floor(y);
+    const u = this._fade(x);
+    const v = this._fade(y);
+    const A = this._perm[X] + Y;
+    const B = this._perm[X + 1] + Y;
+    return this._lerp(this._lerp(this._dot2(this._perm[A], x, y), this._dot2(this._perm[B], x - 1, y), u), this._lerp(this._dot2(this._perm[A + 1], x, y - 1), this._dot2(this._perm[B + 1], x - 1, y - 1), u), v);
+  }
+  /**
+   * @zh 3D Perlin 噪声
+   * @en 3D Perlin noise
+   *
+   * @param x - @zh X 坐标 @en X coordinate
+   * @param y - @zh Y 坐标 @en Y coordinate
+   * @param z - @zh Z 坐标 @en Z coordinate
+   * @returns @zh 噪声值 [-1, 1] @en Noise value [-1, 1]
+   */
+  noise3D(x, y, z) {
+    const X = Math.floor(x) & 255;
+    const Y = Math.floor(y) & 255;
+    const Z = Math.floor(z) & 255;
+    x -= Math.floor(x);
+    y -= Math.floor(y);
+    z -= Math.floor(z);
+    const u = this._fade(x);
+    const v = this._fade(y);
+    const w = this._fade(z);
+    const A = this._perm[X] + Y;
+    const AA = this._perm[A] + Z;
+    const AB = this._perm[A + 1] + Z;
+    const B = this._perm[X + 1] + Y;
+    const BA = this._perm[B] + Z;
+    const BB = this._perm[B + 1] + Z;
+    return this._lerp(this._lerp(this._lerp(this._dot3(this._perm[AA], x, y, z), this._dot3(this._perm[BA], x - 1, y, z), u), this._lerp(this._dot3(this._perm[AB], x, y - 1, z), this._dot3(this._perm[BB], x - 1, y - 1, z), u), v), this._lerp(this._lerp(this._dot3(this._perm[AA + 1], x, y, z - 1), this._dot3(this._perm[BA + 1], x - 1, y, z - 1), u), this._lerp(this._dot3(this._perm[AB + 1], x, y - 1, z - 1), this._dot3(this._perm[BB + 1], x - 1, y - 1, z - 1), u), v), w);
+  }
+};
+__name(_PerlinNoise, "PerlinNoise");
+var PerlinNoise = _PerlinNoise;
+function createPerlinNoise(seed = 0) {
+  return new PerlinNoise(seed);
+}
+__name(createPerlinNoise, "createPerlinNoise");
+
+// src/noise/SimplexNoise.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 _SimplexNoise = class _SimplexNoise {
+  /**
+   * @zh 创建 Simplex 噪声生成器
+   * @en Create Simplex noise generator
+   *
+   * @param seed - @zh 随机种子 @en Random seed
+   */
+  constructor(seed = 0) {
+    __publicField(this, "_perm");
+    __publicField(this, "_permMod12");
+    this._perm = new Uint8Array(512);
+    this._permMod12 = new Uint8Array(512);
+    this._seed(seed);
+  }
+  _seed(seed) {
+    const p = new Uint8Array(256);
+    for (let i = 0; i < 256; i++) {
+      p[i] = i;
+    }
+    let n = seed;
+    for (let i = 255; i > 0; i--) {
+      n = n * 16807 % 2147483647;
+      const j = n % (i + 1);
+      [p[i], p[j]] = [
+        p[j],
+        p[i]
+      ];
+    }
+    for (let i = 0; i < 512; i++) {
+      this._perm[i] = p[i & 255];
+      this._permMod12[i] = this._perm[i] % 12;
+    }
+  }
+  /**
+   * @zh 2D Simplex 噪声
+   * @en 2D Simplex noise
+   *
+   * @param x - @zh X 坐标 @en X coordinate
+   * @param y - @zh Y 坐标 @en Y coordinate
+   * @returns @zh 噪声值 [-1, 1] @en Noise value [-1, 1]
+   */
+  noise2D(x, y) {
+    const grad3 = _SimplexNoise._grad3;
+    let n0 = 0, n1 = 0, n2 = 0;
+    const s = (x + y) * F2;
+    const i = Math.floor(x + s);
+    const j = Math.floor(y + s);
+    const t = (i + j) * G2;
+    const X0 = i - t;
+    const Y0 = j - t;
+    const x0 = x - X0;
+    const y0 = y - Y0;
+    let i1, j1;
+    if (x0 > y0) {
+      i1 = 1;
+      j1 = 0;
+    } else {
+      i1 = 0;
+      j1 = 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;
+    const gi0 = this._permMod12[ii + this._perm[jj]] * 3;
+    const gi1 = this._permMod12[ii + i1 + this._perm[jj + j1]] * 3;
+    const gi2 = this._permMod12[ii + 1 + this._perm[jj + 1]] * 3;
+    let t0 = 0.5 - x0 * x0 - y0 * y0;
+    if (t0 >= 0) {
+      t0 *= t0;
+      n0 = t0 * t0 * (grad3[gi0] * x0 + grad3[gi0 + 1] * y0);
+    }
+    let t1 = 0.5 - x1 * x1 - y1 * y1;
+    if (t1 >= 0) {
+      t1 *= t1;
+      n1 = t1 * t1 * (grad3[gi1] * x1 + grad3[gi1 + 1] * y1);
+    }
+    let t2 = 0.5 - x2 * x2 - y2 * y2;
+    if (t2 >= 0) {
+      t2 *= t2;
+      n2 = t2 * t2 * (grad3[gi2] * x2 + grad3[gi2 + 1] * y2);
+    }
+    return 70 * (n0 + n1 + n2);
+  }
+  /**
+   * @zh 3D Simplex 噪声
+   * @en 3D Simplex noise
+   *
+   * @param x - @zh X 坐标 @en X coordinate
+   * @param y - @zh Y 坐标 @en Y coordinate
+   * @param z - @zh Z 坐标 @en Z coordinate
+   * @returns @zh 噪声值 [-1, 1] @en Noise value [-1, 1]
+   */
+  noise3D(x, y, z) {
+    const grad3 = _SimplexNoise._grad3;
+    let n0 = 0, n1 = 0, n2 = 0, n3 = 0;
+    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 = i - t;
+    const Y0 = j - t;
+    const Z0 = k - t;
+    const x0 = x - X0;
+    const y0 = y - Y0;
+    const z0 = z - Z0;
+    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;
+    const gi0 = this._permMod12[ii + this._perm[jj + this._perm[kk]]] * 3;
+    const gi1 = this._permMod12[ii + i1 + this._perm[jj + j1 + this._perm[kk + k1]]] * 3;
+    const gi2 = this._permMod12[ii + i2 + this._perm[jj + j2 + this._perm[kk + k2]]] * 3;
+    const gi3 = this._permMod12[ii + 1 + this._perm[jj + 1 + this._perm[kk + 1]]] * 3;
+    let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
+    if (t0 >= 0) {
+      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) {
+      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) {
+      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) {
+      t3 *= t3;
+      n3 = t3 * t3 * (grad3[gi3] * x3 + grad3[gi3 + 1] * y3 + grad3[gi3 + 2] * z3);
+    }
+    return 32 * (n0 + n1 + n2 + n3);
+  }
+};
+__name(_SimplexNoise, "SimplexNoise");
+__publicField(_SimplexNoise, "_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 SimplexNoise = _SimplexNoise;
+function createSimplexNoise(seed = 0) {
+  return new SimplexNoise(seed);
+}
+__name(createSimplexNoise, "createSimplexNoise");
+
+// src/noise/WorleyNoise.ts
+var _WorleyNoise = class _WorleyNoise {
+  /**
+   * @zh 创建 Worley 噪声生成器
+   * @en Create Worley noise generator
+   *
+   * @param seed - @zh 随机种子 @en Random seed
+   * @param distanceFunc - @zh 距离函数 @en Distance function
+   */
+  constructor(seed = 0, distanceFunc = "euclidean") {
+    __publicField(this, "_seed");
+    __publicField(this, "_distanceFunc");
+    this._seed = seed;
+    this._distanceFunc = distanceFunc;
+  }
+  _hash(x, y, z = 0) {
+    let h = this._seed;
+    h ^= x * 374761393;
+    h ^= y * 668265263;
+    h ^= z * 1274126177;
+    h = Math.imul(h ^ h >>> 13, 1274126177);
+    return h;
+  }
+  _randomPoint(cellX, cellY, index) {
+    const h1 = this._hash(cellX, cellY, index);
+    const h2 = this._hash(cellX, cellY, index + 1e3);
+    return {
+      x: cellX + (h1 & 65535) / 65536,
+      y: cellY + (h2 & 65535) / 65536
+    };
+  }
+  _randomPoint3D(cellX, cellY, cellZ, index) {
+    const h1 = this._hash(cellX, cellY, cellZ * 1e3 + index);
+    const h2 = this._hash(cellX, cellY, cellZ * 1e3 + index + 1e3);
+    const h3 = this._hash(cellX, cellY, cellZ * 1e3 + index + 2e3);
+    return {
+      x: cellX + (h1 & 65535) / 65536,
+      y: cellY + (h2 & 65535) / 65536,
+      z: cellZ + (h3 & 65535) / 65536
+    };
+  }
+  _distance2D(x1, y1, x2, y2) {
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    switch (this._distanceFunc) {
+      case "manhattan":
+        return Math.abs(dx) + Math.abs(dy);
+      case "chebyshev":
+        return Math.max(Math.abs(dx), Math.abs(dy));
+      case "euclidean":
+      default:
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+  }
+  _distance3D(x1, y1, z1, x2, y2, z2) {
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const dz = z2 - z1;
+    switch (this._distanceFunc) {
+      case "manhattan":
+        return Math.abs(dx) + Math.abs(dy) + Math.abs(dz);
+      case "chebyshev":
+        return Math.max(Math.abs(dx), Math.abs(dy), Math.abs(dz));
+      case "euclidean":
+      default:
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+  }
+  /**
+   * @zh 2D Worley 噪声
+   * @en 2D Worley noise
+   *
+   * @param x - @zh X 坐标 @en X coordinate
+   * @param y - @zh Y 坐标 @en Y coordinate
+   * @param pointsPerCell - @zh 每个单元格的点数 @en Points per cell
+   * @returns @zh 到最近点的距离 [0, ~1.4] @en Distance to nearest point [0, ~1.4]
+   */
+  noise2D(x, y, pointsPerCell = 1) {
+    const cellX = Math.floor(x);
+    const cellY = Math.floor(y);
+    let minDist = Infinity;
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        const cx = cellX + dx;
+        const cy = cellY + dy;
+        for (let i = 0; i < pointsPerCell; i++) {
+          const point = this._randomPoint(cx, cy, i);
+          const dist = this._distance2D(x, y, point.x, point.y);
+          minDist = Math.min(minDist, dist);
+        }
+      }
+    }
+    return minDist;
+  }
+  /**
+   * @zh 3D Worley 噪声
+   * @en 3D Worley noise
+   *
+   * @param x - @zh X 坐标 @en X coordinate
+   * @param y - @zh Y 坐标 @en Y coordinate
+   * @param z - @zh Z 坐标 @en Z coordinate
+   * @param pointsPerCell - @zh 每个单元格的点数 @en Points per cell
+   * @returns @zh 到最近点的距离 @en Distance to nearest point
+   */
+  noise3D(x, y, z, pointsPerCell = 1) {
+    const cellX = Math.floor(x);
+    const cellY = Math.floor(y);
+    const cellZ = Math.floor(z);
+    let minDist = Infinity;
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        for (let dz = -1; dz <= 1; dz++) {
+          const cx = cellX + dx;
+          const cy = cellY + dy;
+          const cz = cellZ + dz;
+          for (let i = 0; i < pointsPerCell; i++) {
+            const point = this._randomPoint3D(cx, cy, cz, i);
+            const dist = this._distance3D(x, y, z, point.x, point.y, point.z);
+            minDist = Math.min(minDist, dist);
+          }
+        }
+      }
+    }
+    return minDist;
+  }
+  /**
+   * @zh 获取到第 N 近点的距离（用于更复杂的纹理）
+   * @en Get distance to Nth nearest point (for more complex textures)
+   *
+   * @param x - @zh X 坐标 @en X coordinate
+   * @param y - @zh Y 坐标 @en Y coordinate
+   * @param n - @zh 第 N 近 (1 = 最近) @en Nth nearest (1 = nearest)
+   * @returns @zh 距离值 @en Distance value
+   */
+  nthNearest2D(x, y, n = 1) {
+    const cellX = Math.floor(x);
+    const cellY = Math.floor(y);
+    const distances = [];
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        const cx = cellX + dx;
+        const cy = cellY + dy;
+        const point = this._randomPoint(cx, cy, 0);
+        distances.push(this._distance2D(x, y, point.x, point.y));
+      }
+    }
+    distances.sort((a, b) => a - b);
+    return distances[Math.min(n - 1, distances.length - 1)];
+  }
+};
+__name(_WorleyNoise, "WorleyNoise");
+var WorleyNoise = _WorleyNoise;
+function createWorleyNoise(seed = 0, distanceFunc = "euclidean") {
+  return new WorleyNoise(seed, distanceFunc);
+}
+__name(createWorleyNoise, "createWorleyNoise");
+
+// src/noise/FBM.ts
+var DEFAULT_CONFIG = {
+  octaves: 6,
+  lacunarity: 2,
+  persistence: 0.5,
+  frequency: 1,
+  amplitude: 1
+};
+var _FBM = class _FBM {
+  /**
+   * @zh 创建 FBM 噪声生成器
+   * @en Create FBM noise generator
+   *
+   * @param noise - @zh 基础噪声函数 @en Base noise function
+   * @param config - @zh 配置 @en Configuration
+   */
+  constructor(noise, config) {
+    __publicField(this, "_noise");
+    __publicField(this, "_config");
+    this._noise = noise;
+    this._config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+  }
+  /**
+   * @zh 2D FBM 噪声
+   * @en 2D FBM noise
+   *
+   * @param x - @zh X 坐标 @en X coordinate
+   * @param y - @zh Y 坐标 @en Y coordinate
+   * @returns @zh 噪声值 @en Noise value
+   */
+  noise2D(x, y) {
+    let value = 0;
+    let frequency = this._config.frequency;
+    let amplitude = this._config.amplitude;
+    let maxValue = 0;
+    for (let i = 0; i < this._config.octaves; i++) {
+      value += this._noise.noise2D(x * frequency, y * frequency) * amplitude;
+      maxValue += amplitude;
+      amplitude *= this._config.persistence;
+      frequency *= this._config.lacunarity;
+    }
+    return value / maxValue;
+  }
+  /**
+   * @zh 3D FBM 噪声
+   * @en 3D FBM noise
+   *
+   * @param x - @zh X 坐标 @en X coordinate
+   * @param y - @zh Y 坐标 @en Y coordinate
+   * @param z - @zh Z 坐标 @en Z coordinate
+   * @returns @zh 噪声值 @en Noise value
+   */
+  noise3D(x, y, z) {
+    if (!this._noise.noise3D) {
+      throw new Error("Base noise does not support 3D");
+    }
+    let value = 0;
+    let frequency = this._config.frequency;
+    let amplitude = this._config.amplitude;
+    let maxValue = 0;
+    for (let i = 0; i < this._config.octaves; i++) {
+      value += this._noise.noise3D(x * frequency, y * frequency, z * frequency) * amplitude;
+      maxValue += amplitude;
+      amplitude *= this._config.persistence;
+      frequency *= this._config.lacunarity;
+    }
+    return value / maxValue;
+  }
+  /**
+   * @zh Ridged FBM（脊状，适合山脉）
+   * @en Ridged FBM (suitable for mountains)
+   */
+  ridged2D(x, y) {
+    let value = 0;
+    let frequency = this._config.frequency;
+    let amplitude = this._config.amplitude;
+    let weight = 1;
+    for (let i = 0; i < this._config.octaves; i++) {
+      let signal = this._noise.noise2D(x * frequency, y * frequency);
+      signal = 1 - Math.abs(signal);
+      signal *= signal;
+      signal *= weight;
+      weight = Math.max(0, Math.min(1, signal * 2));
+      value += signal * amplitude;
+      frequency *= this._config.lacunarity;
+      amplitude *= this._config.persistence;
+    }
+    return value;
+  }
+  /**
+   * @zh Turbulence（湍流，使用绝对值）
+   * @en Turbulence (using absolute value)
+   */
+  turbulence2D(x, y) {
+    let value = 0;
+    let frequency = this._config.frequency;
+    let amplitude = this._config.amplitude;
+    let maxValue = 0;
+    for (let i = 0; i < this._config.octaves; i++) {
+      value += Math.abs(this._noise.noise2D(x * frequency, y * frequency)) * amplitude;
+      maxValue += amplitude;
+      amplitude *= this._config.persistence;
+      frequency *= this._config.lacunarity;
+    }
+    return value / maxValue;
+  }
+  /**
+   * @zh Billowed（膨胀，适合云朵）
+   * @en Billowed (suitable for clouds)
+   */
+  billowed2D(x, y) {
+    let value = 0;
+    let frequency = this._config.frequency;
+    let amplitude = this._config.amplitude;
+    let maxValue = 0;
+    for (let i = 0; i < this._config.octaves; i++) {
+      const n = this._noise.noise2D(x * frequency, y * frequency);
+      value += (Math.abs(n) * 2 - 1) * amplitude;
+      maxValue += amplitude;
+      amplitude *= this._config.persistence;
+      frequency *= this._config.lacunarity;
+    }
+    return value / maxValue;
+  }
+};
+__name(_FBM, "FBM");
+var FBM = _FBM;
+function createFBM(noise, config) {
+  return new FBM(noise, config);
+}
+__name(createFBM, "createFBM");
+
+// src/random/SeededRandom.ts
+var _SeededRandom = class _SeededRandom {
+  /**
+   * @zh 创建种子随机数生成器
+   * @en Create seeded random number generator
+   *
+   * @param seed - @zh 随机种子 @en Random seed
+   */
+  constructor(seed = Date.now()) {
+    __publicField(this, "_s0");
+    __publicField(this, "_s1");
+    __publicField(this, "_initialS0");
+    __publicField(this, "_initialS1");
+    let h = seed | 0;
+    h = Math.imul(h ^ h >>> 16, 2246822507);
+    h = Math.imul(h ^ h >>> 13, 3266489909);
+    h ^= h >>> 16;
+    this._s0 = h >>> 0;
+    this._s1 = h * 2654435769 >>> 0;
+    if (this._s0 === 0) this._s0 = 1;
+    if (this._s1 === 0) this._s1 = 1;
+    this._initialS0 = this._s0;
+    this._initialS1 = this._s1;
+    for (let i = 0; i < 10; i++) {
+      this.next();
+    }
+  }
+  /**
+   * @zh 重置到初始状态
+   * @en Reset to initial state
+   */
+  reset() {
+    this._s0 = this._initialS0;
+    this._s1 = this._initialS1;
+    for (let i = 0; i < 10; i++) {
+      this.next();
+    }
+  }
+  /**
+   * @zh 生成下一个随机数 [0, 1)
+   * @en Generate next random number [0, 1)
+   */
+  next() {
+    let s1 = this._s0;
+    const s0 = this._s1;
+    this._s0 = s0;
+    s1 ^= s1 << 23;
+    s1 ^= s1 >>> 17;
+    s1 ^= s0;
+    s1 ^= s0 >>> 26;
+    this._s1 = s1;
+    return (this._s0 + this._s1 >>> 0) / 4294967296;
+  }
+  /**
+   * @zh 生成整数 [min, max]
+   * @en Generate integer [min, max]
+   */
+  nextInt(min, max) {
+    return Math.floor(this.next() * (max - min + 1)) + min;
+  }
+  /**
+   * @zh 生成浮点数 [min, max)
+   * @en Generate float [min, max)
+   */
+  nextFloat(min, max) {
+    return this.next() * (max - min) + min;
+  }
+  /**
+   * @zh 生成布尔值
+   * @en Generate boolean
+   *
+   * @param probability - @zh 为 true 的概率 [0, 1] @en Probability of true [0, 1]
+   */
+  nextBool(probability = 0.5) {
+    return this.next() < probability;
+  }
+  /**
+   * @zh 生成正态分布随机数 (Box-Muller 变换)
+   * @en Generate normally distributed random number (Box-Muller transform)
+   *
+   * @param mean - @zh 均值 @en Mean
+   * @param stdDev - @zh 标准差 @en Standard deviation
+   */
+  nextGaussian(mean = 0, stdDev = 1) {
+    const u1 = this.next();
+    const u2 = this.next();
+    const z0 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+    return z0 * stdDev + mean;
+  }
+  /**
+   * @zh 生成指数分布随机数
+   * @en Generate exponentially distributed random number
+   *
+   * @param lambda - @zh 率参数 @en Rate parameter
+   */
+  nextExponential(lambda = 1) {
+    return -Math.log(1 - this.next()) / lambda;
+  }
+  /**
+   * @zh 在圆内生成均匀分布的随机点
+   * @en Generate uniformly distributed random point in circle
+   *
+   * @param radius - @zh 半径 @en Radius
+   */
+  nextPointInCircle(radius = 1) {
+    const r = Math.sqrt(this.next()) * radius;
+    const theta = this.next() * 2 * Math.PI;
+    return {
+      x: r * Math.cos(theta),
+      y: r * Math.sin(theta)
+    };
+  }
+  /**
+   * @zh 在圆环上生成随机点
+   * @en Generate random point on circle
+   *
+   * @param radius - @zh 半径 @en Radius
+   */
+  nextPointOnCircle(radius = 1) {
+    const theta = this.next() * 2 * Math.PI;
+    return {
+      x: radius * Math.cos(theta),
+      y: radius * Math.sin(theta)
+    };
+  }
+  /**
+   * @zh 在球内生成均匀分布的随机点
+   * @en Generate uniformly distributed random point in sphere
+   *
+   * @param radius - @zh 半径 @en Radius
+   */
+  nextPointInSphere(radius = 1) {
+    const r = Math.cbrt(this.next()) * radius;
+    const theta = this.next() * 2 * Math.PI;
+    const phi = Math.acos(2 * this.next() - 1);
+    return {
+      x: r * Math.sin(phi) * Math.cos(theta),
+      y: r * Math.sin(phi) * Math.sin(theta),
+      z: r * Math.cos(phi)
+    };
+  }
+  /**
+   * @zh 生成随机方向向量
+   * @en Generate random direction vector
+   */
+  nextDirection2D() {
+    const theta = this.next() * 2 * Math.PI;
+    return {
+      x: Math.cos(theta),
+      y: Math.sin(theta)
+    };
+  }
+};
+__name(_SeededRandom, "SeededRandom");
+var SeededRandom = _SeededRandom;
+function createSeededRandom(seed) {
+  return new SeededRandom(seed);
+}
+__name(createSeededRandom, "createSeededRandom");
+
+// src/random/WeightedRandom.ts
+var _WeightedRandom = class _WeightedRandom {
+  /**
+   * @zh 创建加权随机选择器
+   * @en Create weighted random selector
+   *
+   * @param items - @zh 加权项数组 @en Array of weighted items
+   */
+  constructor(items) {
+    __publicField(this, "_items");
+    __publicField(this, "_cumulativeWeights");
+    __publicField(this, "_totalWeight");
+    if (items.length === 0) {
+      throw new Error("Items array cannot be empty");
+    }
+    this._items = [
+      ...items
+    ];
+    this._cumulativeWeights = [];
+    let total = 0;
+    for (const item of this._items) {
+      if (item.weight <= 0) {
+        throw new Error("Weights must be positive");
+      }
+      total += item.weight;
+      this._cumulativeWeights.push(total);
+    }
+    this._totalWeight = total;
+  }
+  /**
+   * @zh 随机选择一个项目
+   * @en Randomly select an item
+   *
+   * @param rng - @zh 随机数生成器 @en Random number generator
+   */
+  pick(rng) {
+    const r = rng.next() * this._totalWeight;
+    let left = 0;
+    let right = this._cumulativeWeights.length - 1;
+    while (left < right) {
+      const mid = left + right >>> 1;
+      if (this._cumulativeWeights[mid] < r) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
+    }
+    return this._items[left].value;
+  }
+  /**
+   * @zh 使用 Math.random 选择
+   * @en Pick using Math.random
+   */
+  pickRandom() {
+    return this.pick({
+      next: /* @__PURE__ */ __name(() => Math.random(), "next")
+    });
+  }
+  /**
+   * @zh 获取项目的选中概率
+   * @en Get selection probability of an item
+   */
+  getProbability(index) {
+    if (index < 0 || index >= this._items.length) {
+      throw new Error("Index out of bounds");
+    }
+    return this._items[index].weight / this._totalWeight;
+  }
+  /**
+   * @zh 获取所有项目数量
+   * @en Get total item count
+   */
+  get size() {
+    return this._items.length;
+  }
+  /**
+   * @zh 获取总权重
+   * @en Get total weight
+   */
+  get totalWeight() {
+    return this._totalWeight;
+  }
+};
+__name(_WeightedRandom, "WeightedRandom");
+var WeightedRandom = _WeightedRandom;
+function weightedPick(items, rng) {
+  if (items.length === 0) {
+    throw new Error("Items array cannot be empty");
+  }
+  let totalWeight = 0;
+  for (const item of items) {
+    totalWeight += item.weight;
+  }
+  let r = rng.next() * totalWeight;
+  for (const item of items) {
+    r -= item.weight;
+    if (r <= 0) {
+      return item.value;
+    }
+  }
+  return items[items.length - 1].value;
+}
+__name(weightedPick, "weightedPick");
+function weightedPickFromMap(weights, rng) {
+  const items = [];
+  for (const key in weights) {
+    items.push({
+      value: key,
+      weight: weights[key]
+    });
+  }
+  return weightedPick(items, rng);
+}
+__name(weightedPickFromMap, "weightedPickFromMap");
+function createWeightedRandom(items) {
+  return new WeightedRandom(items);
+}
+__name(createWeightedRandom, "createWeightedRandom");
+
+// src/random/Shuffle.ts
+function shuffle(array, rng) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(rng.next() * (i + 1));
+    [array[i], array[j]] = [
+      array[j],
+      array[i]
+    ];
+  }
+  return array;
+}
+__name(shuffle, "shuffle");
+function shuffleCopy(array, rng) {
+  return shuffle([
+    ...array
+  ], rng);
+}
+__name(shuffleCopy, "shuffleCopy");
+function pickOne(array, rng) {
+  if (array.length === 0) {
+    throw new Error("Cannot pick from empty array");
+  }
+  return array[Math.floor(rng.next() * array.length)];
+}
+__name(pickOne, "pickOne");
+function sample(array, count, rng) {
+  if (count > array.length) {
+    throw new Error("Sample count exceeds array length");
+  }
+  if (count === array.length) {
+    return shuffleCopy(array, rng);
+  }
+  if (count < array.length / 2) {
+    const result = [];
+    const indices = /* @__PURE__ */ new Set();
+    while (result.length < count) {
+      const index = Math.floor(rng.next() * array.length);
+      if (!indices.has(index)) {
+        indices.add(index);
+        result.push(array[index]);
+      }
+    }
+    return result;
+  }
+  return shuffleCopy(array, rng).slice(0, count);
+}
+__name(sample, "sample");
+function sampleWithReplacement(array, count, rng) {
+  if (array.length === 0) {
+    throw new Error("Cannot sample from empty array");
+  }
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(pickOne(array, rng));
+  }
+  return result;
+}
+__name(sampleWithReplacement, "sampleWithReplacement");
+function randomIntegers(min, max, count, rng) {
+  const range = max - min + 1;
+  if (count > range) {
+    throw new Error("Count exceeds range");
+  }
+  const numbers = [];
+  for (let i = min; i <= max; i++) {
+    numbers.push(i);
+  }
+  return sample(numbers, count, rng);
+}
+__name(randomIntegers, "randomIntegers");
+function weightedSample(items, weights, count, rng) {
+  if (items.length !== weights.length) {
+    throw new Error("Items and weights must have same length");
+  }
+  if (count > items.length) {
+    throw new Error("Sample count exceeds array length");
+  }
+  const result = [];
+  const remaining = [
+    ...items
+  ];
+  const remainingWeights = [
+    ...weights
+  ];
+  for (let i = 0; i < count; i++) {
+    let totalWeight = 0;
+    for (const w of remainingWeights) {
+      totalWeight += w;
+    }
+    let r = rng.next() * totalWeight;
+    let selectedIndex = 0;
+    for (let j = 0; j < remainingWeights.length; j++) {
+      r -= remainingWeights[j];
+      if (r <= 0) {
+        selectedIndex = j;
+        break;
+      }
+    }
+    result.push(remaining[selectedIndex]);
+    remaining.splice(selectedIndex, 1);
+    remainingWeights.splice(selectedIndex, 1);
+  }
+  return result;
+}
+__name(weightedSample, "weightedSample");
+
+// src/nodes/ProcGenNodes.ts
+var noiseCache = /* @__PURE__ */ new Map();
+function getPerlinNoise(seed) {
+  const key = `perlin_${seed}`;
+  if (!noiseCache.has(key)) {
+    noiseCache.set(key, new PerlinNoise(seed));
+  }
+  return noiseCache.get(key);
+}
+__name(getPerlinNoise, "getPerlinNoise");
+function getSimplexNoise(seed) {
+  const key = `simplex_${seed}`;
+  if (!noiseCache.has(key)) {
+    noiseCache.set(key, new SimplexNoise(seed));
+  }
+  return noiseCache.get(key);
+}
+__name(getSimplexNoise, "getSimplexNoise");
+function getWorleyNoise(seed) {
+  const key = `worley_${seed}`;
+  if (!noiseCache.has(key)) {
+    noiseCache.set(key, new WorleyNoise(seed));
+  }
+  return noiseCache.get(key);
+}
+__name(getWorleyNoise, "getWorleyNoise");
+var SampleNoise2DTemplate = {
+  type: "SampleNoise2D",
+  title: "Sample Noise 2D",
+  category: "math",
+  description: "Sample 2D noise at coordinates / \u5728\u5750\u6807\u5904\u91C7\u6837 2D \u566A\u58F0",
+  keywords: [
+    "noise",
+    "perlin",
+    "simplex",
+    "random",
+    "procedural"
+  ],
+  menuPath: [
+    "Procedural",
+    "Noise",
+    "Sample Noise 2D"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "x",
+      displayName: "X",
+      type: "float"
+    },
+    {
+      name: "y",
+      displayName: "Y",
+      type: "float"
+    },
+    {
+      name: "seed",
+      displayName: "Seed",
+      type: "int"
+    },
+    {
+      name: "noiseType",
+      displayName: "Type",
+      type: "string"
+    }
+  ],
+  outputs: [
+    {
+      name: "value",
+      displayName: "Value",
+      type: "float"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _SampleNoise2DExecutor = class _SampleNoise2DExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const x = ctx.evaluateInput(node.id, "x", 0);
+    const y = ctx.evaluateInput(node.id, "y", 0);
+    const seed = ctx.evaluateInput(node.id, "seed", 0);
+    const noiseType = ctx.evaluateInput(node.id, "noiseType", "perlin");
+    let value = 0;
+    switch (noiseType.toLowerCase()) {
+      case "simplex":
+        value = getSimplexNoise(seed).noise2D(x, y);
+        break;
+      case "worley":
+        value = getWorleyNoise(seed).noise2D(x, y);
+        break;
+      case "perlin":
+      default:
+        value = getPerlinNoise(seed).noise2D(x, y);
+        break;
+    }
+    return {
+      outputs: {
+        value
+      }
+    };
+  }
+};
+__name(_SampleNoise2DExecutor, "SampleNoise2DExecutor");
+var SampleNoise2DExecutor = _SampleNoise2DExecutor;
+var SampleFBMTemplate = {
+  type: "SampleFBM",
+  title: "Sample FBM",
+  category: "math",
+  description: "Sample Fractal Brownian Motion noise / \u91C7\u6837\u5206\u5F62\u5E03\u6717\u8FD0\u52A8\u566A\u58F0",
+  keywords: [
+    "noise",
+    "fbm",
+    "fractal",
+    "octave",
+    "terrain"
+  ],
+  menuPath: [
+    "Procedural",
+    "Noise",
+    "Sample FBM"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "x",
+      displayName: "X",
+      type: "float"
+    },
+    {
+      name: "y",
+      displayName: "Y",
+      type: "float"
+    },
+    {
+      name: "seed",
+      displayName: "Seed",
+      type: "int"
+    },
+    {
+      name: "octaves",
+      displayName: "Octaves",
+      type: "int"
+    },
+    {
+      name: "frequency",
+      displayName: "Frequency",
+      type: "float"
+    },
+    {
+      name: "persistence",
+      displayName: "Persistence",
+      type: "float"
+    }
+  ],
+  outputs: [
+    {
+      name: "value",
+      displayName: "Value",
+      type: "float"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _SampleFBMExecutor = class _SampleFBMExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const x = ctx.evaluateInput(node.id, "x", 0);
+    const y = ctx.evaluateInput(node.id, "y", 0);
+    const seed = ctx.evaluateInput(node.id, "seed", 0);
+    const octaves = ctx.evaluateInput(node.id, "octaves", 6);
+    const frequency = ctx.evaluateInput(node.id, "frequency", 1);
+    const persistence = ctx.evaluateInput(node.id, "persistence", 0.5);
+    const noise = getPerlinNoise(seed);
+    const fbm = new FBM(noise, {
+      octaves,
+      frequency,
+      persistence
+    });
+    const value = fbm.noise2D(x, y);
+    return {
+      outputs: {
+        value
+      }
+    };
+  }
+};
+__name(_SampleFBMExecutor, "SampleFBMExecutor");
+var SampleFBMExecutor = _SampleFBMExecutor;
+var SeededRandomTemplate = {
+  type: "SeededRandom",
+  title: "Seeded Random",
+  category: "math",
+  description: "Generate deterministic random number / \u751F\u6210\u786E\u5B9A\u6027\u968F\u673A\u6570",
+  keywords: [
+    "random",
+    "seed",
+    "deterministic",
+    "procedural"
+  ],
+  menuPath: [
+    "Procedural",
+    "Random",
+    "Seeded Random"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "seed",
+      displayName: "Seed",
+      type: "int"
+    },
+    {
+      name: "index",
+      displayName: "Index",
+      type: "int"
+    }
+  ],
+  outputs: [
+    {
+      name: "value",
+      displayName: "Value",
+      type: "float"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _SeededRandomExecutor = class _SeededRandomExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const seed = ctx.evaluateInput(node.id, "seed", 0);
+    const index = ctx.evaluateInput(node.id, "index", 0);
+    const rng = new SeededRandom(seed + index * 12345);
+    const value = rng.next();
+    return {
+      outputs: {
+        value
+      }
+    };
+  }
+};
+__name(_SeededRandomExecutor, "SeededRandomExecutor");
+var SeededRandomExecutor = _SeededRandomExecutor;
+var SeededRandomIntTemplate = {
+  type: "SeededRandomInt",
+  title: "Seeded Random Int",
+  category: "math",
+  description: "Generate deterministic random integer / \u751F\u6210\u786E\u5B9A\u6027\u968F\u673A\u6574\u6570",
+  keywords: [
+    "random",
+    "seed",
+    "integer",
+    "deterministic"
+  ],
+  menuPath: [
+    "Procedural",
+    "Random",
+    "Seeded Random Int"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "seed",
+      displayName: "Seed",
+      type: "int"
+    },
+    {
+      name: "index",
+      displayName: "Index",
+      type: "int"
+    },
+    {
+      name: "min",
+      displayName: "Min",
+      type: "int"
+    },
+    {
+      name: "max",
+      displayName: "Max",
+      type: "int"
+    }
+  ],
+  outputs: [
+    {
+      name: "value",
+      displayName: "Value",
+      type: "int"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _SeededRandomIntExecutor = class _SeededRandomIntExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const seed = ctx.evaluateInput(node.id, "seed", 0);
+    const index = ctx.evaluateInput(node.id, "index", 0);
+    const min = ctx.evaluateInput(node.id, "min", 0);
+    const max = ctx.evaluateInput(node.id, "max", 100);
+    const rng = new SeededRandom(seed + index * 12345);
+    const value = rng.nextInt(min, max);
+    return {
+      outputs: {
+        value
+      }
+    };
+  }
+};
+__name(_SeededRandomIntExecutor, "SeededRandomIntExecutor");
+var SeededRandomIntExecutor = _SeededRandomIntExecutor;
+var WeightedPickTemplate = {
+  type: "WeightedPick",
+  title: "Weighted Pick",
+  category: "math",
+  description: "Pick from weighted options / \u4ECE\u52A0\u6743\u9009\u9879\u4E2D\u9009\u62E9",
+  keywords: [
+    "random",
+    "weight",
+    "pick",
+    "select",
+    "loot"
+  ],
+  menuPath: [
+    "Procedural",
+    "Random",
+    "Weighted Pick"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "seed",
+      displayName: "Seed",
+      type: "int"
+    },
+    {
+      name: "index",
+      displayName: "Index",
+      type: "int"
+    },
+    {
+      name: "items",
+      displayName: "Items",
+      type: "array"
+    },
+    {
+      name: "weights",
+      displayName: "Weights",
+      type: "array"
+    }
+  ],
+  outputs: [
+    {
+      name: "value",
+      displayName: "Value",
+      type: "any"
+    },
+    {
+      name: "selectedIndex",
+      displayName: "Index",
+      type: "int"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _WeightedPickExecutor = class _WeightedPickExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const seed = ctx.evaluateInput(node.id, "seed", 0);
+    const index = ctx.evaluateInput(node.id, "index", 0);
+    const items = ctx.evaluateInput(node.id, "items", []);
+    const weights = ctx.evaluateInput(node.id, "weights", []);
+    if (items.length === 0) {
+      return {
+        outputs: {
+          value: null,
+          selectedIndex: -1
+        }
+      };
+    }
+    const rng = new SeededRandom(seed + index * 12345);
+    const weightedItems = items.map((item, i) => ({
+      value: {
+        value: item,
+        index: i
+      },
+      weight: weights[i] ?? 1
+    }));
+    const result = weightedPick(weightedItems, rng);
+    return {
+      outputs: {
+        value: result.value,
+        selectedIndex: result.index
+      }
+    };
+  }
+};
+__name(_WeightedPickExecutor, "WeightedPickExecutor");
+var WeightedPickExecutor = _WeightedPickExecutor;
+var ShuffleArrayTemplate = {
+  type: "ShuffleArray",
+  title: "Shuffle Array",
+  category: "math",
+  description: "Shuffle array with seed / \u4F7F\u7528\u79CD\u5B50\u6D17\u724C\u6570\u7EC4",
+  keywords: [
+    "random",
+    "shuffle",
+    "array",
+    "order"
+  ],
+  menuPath: [
+    "Procedural",
+    "Random",
+    "Shuffle Array"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "seed",
+      displayName: "Seed",
+      type: "int"
+    },
+    {
+      name: "array",
+      displayName: "Array",
+      type: "array"
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      displayName: "Result",
+      type: "array"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _ShuffleArrayExecutor = class _ShuffleArrayExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const seed = ctx.evaluateInput(node.id, "seed", 0);
+    const array = ctx.evaluateInput(node.id, "array", []);
+    const rng = new SeededRandom(seed);
+    const result = shuffle([
+      ...array
+    ], rng);
+    return {
+      outputs: {
+        result
+      }
+    };
+  }
+};
+__name(_ShuffleArrayExecutor, "ShuffleArrayExecutor");
+var ShuffleArrayExecutor = _ShuffleArrayExecutor;
+var PickRandomTemplate = {
+  type: "PickRandom",
+  title: "Pick Random",
+  category: "math",
+  description: "Pick random element from array / \u4ECE\u6570\u7EC4\u4E2D\u968F\u673A\u9009\u62E9\u5143\u7D20",
+  keywords: [
+    "random",
+    "pick",
+    "array",
+    "select"
+  ],
+  menuPath: [
+    "Procedural",
+    "Random",
+    "Pick Random"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "seed",
+      displayName: "Seed",
+      type: "int"
+    },
+    {
+      name: "index",
+      displayName: "Index",
+      type: "int"
+    },
+    {
+      name: "array",
+      displayName: "Array",
+      type: "array"
+    }
+  ],
+  outputs: [
+    {
+      name: "value",
+      displayName: "Value",
+      type: "any"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _PickRandomExecutor = class _PickRandomExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const seed = ctx.evaluateInput(node.id, "seed", 0);
+    const index = ctx.evaluateInput(node.id, "index", 0);
+    const array = ctx.evaluateInput(node.id, "array", []);
+    if (array.length === 0) {
+      return {
+        outputs: {
+          value: null
+        }
+      };
+    }
+    const rng = new SeededRandom(seed + index * 12345);
+    const value = pickOne(array, rng);
+    return {
+      outputs: {
+        value
+      }
+    };
+  }
+};
+__name(_PickRandomExecutor, "PickRandomExecutor");
+var PickRandomExecutor = _PickRandomExecutor;
+var SampleArrayTemplate = {
+  type: "SampleArray",
+  title: "Sample Array",
+  category: "math",
+  description: "Sample N unique elements from array / \u4ECE\u6570\u7EC4\u4E2D\u91C7\u6837 N \u4E2A\u4E0D\u91CD\u590D\u5143\u7D20",
+  keywords: [
+    "random",
+    "sample",
+    "array",
+    "unique"
+  ],
+  menuPath: [
+    "Procedural",
+    "Random",
+    "Sample Array"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "seed",
+      displayName: "Seed",
+      type: "int"
+    },
+    {
+      name: "array",
+      displayName: "Array",
+      type: "array"
+    },
+    {
+      name: "count",
+      displayName: "Count",
+      type: "int"
+    }
+  ],
+  outputs: [
+    {
+      name: "result",
+      displayName: "Result",
+      type: "array"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _SampleArrayExecutor = class _SampleArrayExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const seed = ctx.evaluateInput(node.id, "seed", 0);
+    const array = ctx.evaluateInput(node.id, "array", []);
+    const count = ctx.evaluateInput(node.id, "count", 1);
+    if (array.length === 0 || count <= 0) {
+      return {
+        outputs: {
+          result: []
+        }
+      };
+    }
+    const rng = new SeededRandom(seed);
+    const actualCount = Math.min(count, array.length);
+    const result = sample(array, actualCount, rng);
+    return {
+      outputs: {
+        result
+      }
+    };
+  }
+};
+__name(_SampleArrayExecutor, "SampleArrayExecutor");
+var SampleArrayExecutor = _SampleArrayExecutor;
+var RandomPointInCircleTemplate = {
+  type: "RandomPointInCircle",
+  title: "Random Point In Circle",
+  category: "math",
+  description: "Generate random point inside circle / \u5728\u5706\u5185\u751F\u6210\u968F\u673A\u70B9",
+  keywords: [
+    "random",
+    "point",
+    "circle",
+    "position"
+  ],
+  menuPath: [
+    "Procedural",
+    "Random",
+    "Random Point In Circle"
+  ],
+  isPure: true,
+  inputs: [
+    {
+      name: "seed",
+      displayName: "Seed",
+      type: "int"
+    },
+    {
+      name: "index",
+      displayName: "Index",
+      type: "int"
+    },
+    {
+      name: "centerX",
+      displayName: "Center X",
+      type: "float"
+    },
+    {
+      name: "centerY",
+      displayName: "Center Y",
+      type: "float"
+    },
+    {
+      name: "radius",
+      displayName: "Radius",
+      type: "float"
+    }
+  ],
+  outputs: [
+    {
+      name: "x",
+      displayName: "X",
+      type: "float"
+    },
+    {
+      name: "y",
+      displayName: "Y",
+      type: "float"
+    }
+  ],
+  color: "#9c27b0"
+};
+var _RandomPointInCircleExecutor = class _RandomPointInCircleExecutor {
+  execute(node, context) {
+    const ctx = context;
+    const seed = ctx.evaluateInput(node.id, "seed", 0);
+    const index = ctx.evaluateInput(node.id, "index", 0);
+    const centerX = ctx.evaluateInput(node.id, "centerX", 0);
+    const centerY = ctx.evaluateInput(node.id, "centerY", 0);
+    const radius = ctx.evaluateInput(node.id, "radius", 1);
+    const rng = new SeededRandom(seed + index * 12345);
+    const point = rng.nextPointInCircle(radius);
+    return {
+      outputs: {
+        x: centerX + point.x,
+        y: centerY + point.y
+      }
+    };
+  }
+};
+__name(_RandomPointInCircleExecutor, "RandomPointInCircleExecutor");
+var RandomPointInCircleExecutor = _RandomPointInCircleExecutor;
+var ProcGenNodeDefinitions = {
+  templates: [
+    SampleNoise2DTemplate,
+    SampleFBMTemplate,
+    SeededRandomTemplate,
+    SeededRandomIntTemplate,
+    WeightedPickTemplate,
+    ShuffleArrayTemplate,
+    PickRandomTemplate,
+    SampleArrayTemplate,
+    RandomPointInCircleTemplate
+  ],
+  executors: /* @__PURE__ */ new Map([
+    [
+      "SampleNoise2D",
+      new SampleNoise2DExecutor()
+    ],
+    [
+      "SampleFBM",
+      new SampleFBMExecutor()
+    ],
+    [
+      "SeededRandom",
+      new SeededRandomExecutor()
+    ],
+    [
+      "SeededRandomInt",
+      new SeededRandomIntExecutor()
+    ],
+    [
+      "WeightedPick",
+      new WeightedPickExecutor()
+    ],
+    [
+      "ShuffleArray",
+      new ShuffleArrayExecutor()
+    ],
+    [
+      "PickRandom",
+      new PickRandomExecutor()
+    ],
+    [
+      "SampleArray",
+      new SampleArrayExecutor()
+    ],
+    [
+      "RandomPointInCircle",
+      new RandomPointInCircleExecutor()
+    ]
+  ])
+};
+
+export { FBM, PerlinNoise, PickRandomExecutor, PickRandomTemplate, ProcGenNodeDefinitions, RandomPointInCircleExecutor, RandomPointInCircleTemplate, SampleArrayExecutor, SampleArrayTemplate, SampleFBMExecutor, SampleFBMTemplate, SampleNoise2DExecutor, SampleNoise2DTemplate, SeededRandom, SeededRandomExecutor, SeededRandomIntExecutor, SeededRandomIntTemplate, SeededRandomTemplate, ShuffleArrayExecutor, ShuffleArrayTemplate, SimplexNoise, WeightedPickExecutor, WeightedPickTemplate, WeightedRandom, WorleyNoise, createFBM, createPerlinNoise, createSeededRandom, createSimplexNoise, createWeightedRandom, createWorleyNoise, pickOne, randomIntegers, sample, sampleWithReplacement, shuffle, shuffleCopy, weightedPick, weightedPickFromMap, weightedSample };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map