@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/core/noise.js

@@ -0,0 +1,247 @@
+/**
+ * Seeded coherent noise (ws/core-2): value, Perlin (gradient) and simplex noise in 2D and 3D,
+ * plus fractal Brownian motion over any of them.
+ *
+ * `createNoise(seed)` shuffles a 256-entry permutation table with `createRandom(seed)` (the same
+ * seed hash as `Random`) and fills a 256-entry lattice value table in [-1, 1]. Every function
+ * returns a value in [-1, 1] (gradient and simplex noise are scaled to that span and clamped),
+ * is continuous in its inputs, and allocates nothing. The functions are plain closures, so
+ * `noise.perlin2` can be passed around unbound (`fbm(noise.perlin2, x, y)`).
+ */
+import { createRandom } from './random.js';
+/** Unit gradients at eight angles for 2D Perlin. */
+const G2X = new Float64Array(8);
+const G2Y = new Float64Array(8);
+for (let i = 0; i < 8; i++) {
+    G2X[i] = Math.cos((i * Math.PI) / 4);
+    G2Y[i] = Math.sin((i * Math.PI) / 4);
+}
+/** The twelve cube-edge gradients of improved Perlin and 3D simplex. */
+const G3 = [
+    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,
+];
+/** Twelve directions for 2D simplex (the 3D set projected, as in Gustavson). */
+const S2 = [1, 1, -1, 1, 1, -1, -1, -1, 1, 0, -1, 0, 0, 1, 0, -1];
+// 2D Perlin with unit gradients peaks at sqrt(2)/2; 3D with the edge set at about 1.
+const PERLIN2_SCALE = Math.SQRT2;
+const PERLIN3_SCALE = 1;
+const SIMPLEX2_SCALE = 70;
+const SIMPLEX3_SCALE = 32;
+const F2 = 0.5 * (Math.sqrt(3) - 1);
+const G2 = (3 - Math.sqrt(3)) / 6;
+const F3 = 1 / 3;
+const G3C = 1 / 6;
+const DEFAULT_FBM = { octaves: 4, lacunarity: 2, gain: 0.5 };
+function fade(t) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function clamp1(v) {
+    return Math.max(-1, Math.min(1, v));
+}
+/** Seeded noise; see the module comment. Builds two small tables (allocates once). */
+export function createNoise(seed) {
+    const random = createRandom(seed);
+    const perm = new Uint8Array(512);
+    for (let i = 0; i < 256; i++)
+        perm[i] = i;
+    random.shuffle(perm.subarray(0, 256));
+    for (let i = 0; i < 256; i++)
+        perm[i + 256] = perm[i];
+    const values = new Float64Array(256);
+    for (let i = 0; i < 256; i++)
+        values[i] = random.next() * 2 - 1;
+    const h2 = (x, y) => perm[perm[x & 255] + (y & 255)];
+    const h3 = (x, y, z) => perm[perm[perm[x & 255] + (y & 255)] + (z & 255)];
+    const value2 = (x, y) => {
+        const x0 = Math.floor(x);
+        const y0 = Math.floor(y);
+        const u = fade(x - x0);
+        const v = fade(y - y0);
+        const a = values[h2(x0, y0)];
+        const b = values[h2(x0 + 1, y0)];
+        const c = values[h2(x0, y0 + 1)];
+        const d = values[h2(x0 + 1, y0 + 1)];
+        return lerp(lerp(a, b, u), lerp(c, d, u), v);
+    };
+    const value3 = (x, y, z) => {
+        const x0 = Math.floor(x);
+        const y0 = Math.floor(y);
+        const z0 = Math.floor(z);
+        const u = fade(x - x0);
+        const v = fade(y - y0);
+        const w = fade(z - z0);
+        const c000 = values[h3(x0, y0, z0)];
+        const c100 = values[h3(x0 + 1, y0, z0)];
+        const c010 = values[h3(x0, y0 + 1, z0)];
+        const c110 = values[h3(x0 + 1, y0 + 1, z0)];
+        const c001 = values[h3(x0, y0, z0 + 1)];
+        const c101 = values[h3(x0 + 1, y0, z0 + 1)];
+        const c011 = values[h3(x0, y0 + 1, z0 + 1)];
+        const c111 = values[h3(x0 + 1, y0 + 1, z0 + 1)];
+        return lerp(lerp(lerp(c000, c100, u), lerp(c010, c110, u), v), lerp(lerp(c001, c101, u), lerp(c011, c111, u), v), w);
+    };
+    const grad2 = (h, x, y) => G2X[h & 7] * x + G2Y[h & 7] * y;
+    const grad3 = (h, x, y, z) => {
+        const g = (h % 12) * 3;
+        return G3[g] * x + G3[g + 1] * y + G3[g + 2] * z;
+    };
+    const perlin2 = (x, y) => {
+        const x0 = Math.floor(x);
+        const y0 = Math.floor(y);
+        const fx = x - x0;
+        const fy = y - y0;
+        const u = fade(fx);
+        const v = fade(fy);
+        const n00 = grad2(h2(x0, y0), fx, fy);
+        const n10 = grad2(h2(x0 + 1, y0), fx - 1, fy);
+        const n01 = grad2(h2(x0, y0 + 1), fx, fy - 1);
+        const n11 = grad2(h2(x0 + 1, y0 + 1), fx - 1, fy - 1);
+        return clamp1(PERLIN2_SCALE * lerp(lerp(n00, n10, u), lerp(n01, n11, u), v));
+    };
+    const perlin3 = (x, y, z) => {
+        const x0 = Math.floor(x);
+        const y0 = Math.floor(y);
+        const z0 = Math.floor(z);
+        const fx = x - x0;
+        const fy = y - y0;
+        const fz = z - z0;
+        const u = fade(fx);
+        const v = fade(fy);
+        const w = fade(fz);
+        const n000 = grad3(h3(x0, y0, z0), fx, fy, fz);
+        const n100 = grad3(h3(x0 + 1, y0, z0), fx - 1, fy, fz);
+        const n010 = grad3(h3(x0, y0 + 1, z0), fx, fy - 1, fz);
+        const n110 = grad3(h3(x0 + 1, y0 + 1, z0), fx - 1, fy - 1, fz);
+        const n001 = grad3(h3(x0, y0, z0 + 1), fx, fy, fz - 1);
+        const n101 = grad3(h3(x0 + 1, y0, z0 + 1), fx - 1, fy, fz - 1);
+        const n011 = grad3(h3(x0, y0 + 1, z0 + 1), fx, fy - 1, fz - 1);
+        const n111 = grad3(h3(x0 + 1, y0 + 1, z0 + 1), fx - 1, fy - 1, fz - 1);
+        return clamp1(PERLIN3_SCALE *
+            lerp(lerp(lerp(n000, n100, u), lerp(n010, n110, u), v), lerp(lerp(n001, n101, u), lerp(n011, n111, u), v), w));
+    };
+    const corner2 = (h, x, y) => {
+        let t = 0.5 - x * x - y * y;
+        if (t < 0)
+            return 0;
+        t *= t;
+        const g = (h & 7) * 2;
+        return t * t * (S2[g] * x + S2[g + 1] * y);
+    };
+    const simplex2 = (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 = 1 - i1;
+        const x1 = x0 - i1 + G2;
+        const y1 = y0 - j1 + G2;
+        const x2 = x0 - 1 + 2 * G2;
+        const y2 = y0 - 1 + 2 * G2;
+        const n = corner2(h2(i, j), x0, y0) +
+            corner2(h2(i + i1, j + j1), x1, y1) +
+            corner2(h2(i + 1, j + 1), x2, y2);
+        return clamp1(SIMPLEX2_SCALE * n);
+    };
+    const corner3 = (h, x, y, z) => {
+        let t = 0.6 - x * x - y * y - z * z;
+        if (t < 0)
+            return 0;
+        t *= t;
+        return t * t * grad3(h, x, y, z);
+    };
+    const simplex3 = (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) * G3C;
+        const x0 = x - (i - t);
+        const y0 = y - (j - t);
+        const z0 = z - (k - t);
+        let i1;
+        let j1;
+        let k1;
+        let i2;
+        let j2;
+        let 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 n = corner3(h3(i, j, k), x0, y0, z0) +
+            corner3(h3(i + i1, j + j1, k + k1), x0 - i1 + G3C, y0 - j1 + G3C, z0 - k1 + G3C) +
+            corner3(h3(i + i2, j + j2, k + k2), x0 - i2 + 2 * G3C, y0 - j2 + 2 * G3C, z0 - k2 + 2 * G3C) +
+            corner3(h3(i + 1, j + 1, k + 1), x0 - 1 + 3 * G3C, y0 - 1 + 3 * G3C, z0 - 1 + 3 * G3C);
+        return clamp1(SIMPLEX3_SCALE * n);
+    };
+    const fbm = (fn, x, y, z = 0, opts = DEFAULT_FBM) => {
+        const octaves = Math.max(1, Math.floor(opts.octaves ?? DEFAULT_FBM.octaves));
+        const lacunarity = opts.lacunarity ?? DEFAULT_FBM.lacunarity;
+        const gain = opts.gain ?? DEFAULT_FBM.gain;
+        let freq = 1;
+        let amp = 1;
+        let sum = 0;
+        let norm = 0;
+        for (let o = 0; o < octaves; o++) {
+            sum += amp * fn(x * freq, y * freq, z * freq);
+            norm += amp;
+            freq *= lacunarity;
+            amp *= gain;
+        }
+        return norm > 0 ? sum / norm : 0;
+    };
+    return { value2, value3, perlin2, perlin3, simplex2, simplex3, fbm };
+}

package/dist/core/pool.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A typed object pool (ws/core-2): reuse effect records, projectiles, labels or scratch objects
+ * instead of allocating per event.
+ *
+ * - `acquire()` takes the most recently released free item (LIFO), or creates one while `size`
+ *   is below `max`. Past `max` it returns `undefined`: that is how a game caps its effects (drop
+ *   the spawn, or recycle its own oldest), never by growing without bound.
+ * - `release(item)` calls `reset(item)` and returns the item to the free list; releasing an item
+ *   that is not live (twice, or foreign) does nothing and returns false.
+ * - `forEach(fn)` visits the live items only, newest index last, iterating backwards so `fn` may
+ *   release the item it is given. Release swaps the last live item into the freed place, so the
+ *   visit order is not acquisition order.
+ *
+ * Nothing allocates after the pool has grown to its peak (items are created by `create`, the
+ * lists keep their capacity).
+ */
+export interface PoolOptions<T> {
+    /** Make a new item. */
+    create: () => T;
+    /** Return an item to its idle state; called on `release` and `drain`. */
+    reset?: (item: T) => void;
+    /** Items created up front. Default 0. */
+    initial?: number;
+    /** Most items the pool will ever create. Default unbounded. */
+    max?: number;
+}
+export interface Pool<T> {
+    /** Items created so far (live plus free). */
+    readonly size: number;
+    /** Items acquired and not yet released. */
+    readonly live: number;
+    /** A free item, a new one while under `max`, or `undefined` at the cap. */
+    acquire(): T | undefined;
+    /** Reset `item` and make it free again; false when it was not live. */
+    release(item: T): boolean;
+    /** Visit live items (backwards; `fn` may release its item). No allocation. */
+    forEach(fn: (item: T, index: number) => void): void;
+    /** Release every live item. */
+    drain(): void;
+}
+/** A pool of `T` (an object type: items are tracked by identity); see the module comment. */
+export declare function createPool<T extends object>(opts: PoolOptions<T>): Pool<T>;

package/dist/core/pool.js

@@ -0,0 +1,85 @@
+/**
+ * A typed object pool (ws/core-2): reuse effect records, projectiles, labels or scratch objects
+ * instead of allocating per event.
+ *
+ * - `acquire()` takes the most recently released free item (LIFO), or creates one while `size`
+ *   is below `max`. Past `max` it returns `undefined`: that is how a game caps its effects (drop
+ *   the spawn, or recycle its own oldest), never by growing without bound.
+ * - `release(item)` calls `reset(item)` and returns the item to the free list; releasing an item
+ *   that is not live (twice, or foreign) does nothing and returns false.
+ * - `forEach(fn)` visits the live items only, newest index last, iterating backwards so `fn` may
+ *   release the item it is given. Release swaps the last live item into the freed place, so the
+ *   visit order is not acquisition order.
+ *
+ * Nothing allocates after the pool has grown to its peak (items are created by `create`, the
+ * lists keep their capacity).
+ */
+class PoolImpl {
+    freeItems = [];
+    liveItems = [];
+    /** item → index in `liveItems`, or -1 when free. */
+    index = new Map();
+    create;
+    reset;
+    max;
+    constructor(opts) {
+        this.create = opts.create;
+        this.reset = opts.reset;
+        this.max = opts.max ?? Number.POSITIVE_INFINITY;
+        const initial = Math.min(opts.initial ?? 0, this.max);
+        for (let i = 0; i < initial; i++) {
+            const item = this.create();
+            this.index.set(item, -1);
+            this.freeItems.push(item);
+        }
+    }
+    get size() {
+        return this.index.size;
+    }
+    get live() {
+        return this.liveItems.length;
+    }
+    acquire() {
+        let item = this.freeItems.pop();
+        if (item === undefined) {
+            if (this.index.size >= this.max)
+                return undefined;
+            item = this.create();
+        }
+        this.index.set(item, this.liveItems.length);
+        this.liveItems.push(item);
+        return item;
+    }
+    release(item) {
+        const i = this.index.get(item);
+        if (i === undefined || i < 0)
+            return false;
+        const live = this.liveItems;
+        const last = live.pop();
+        if (last !== item) {
+            live[i] = last;
+            this.index.set(last, i);
+        }
+        this.index.set(item, -1);
+        this.reset?.(item);
+        this.freeItems.push(item);
+        return true;
+    }
+    forEach(fn) {
+        const live = this.liveItems;
+        for (let i = live.length - 1; i >= 0; i--) {
+            if (i >= live.length)
+                continue;
+            fn(live[i], i);
+        }
+    }
+    drain() {
+        const live = this.liveItems;
+        while (live.length > 0)
+            this.release(live[live.length - 1]);
+    }
+}
+/** A pool of `T` (an object type: items are tracked by identity); see the module comment. */
+export function createPool(opts) {
+    return new PoolImpl(opts);
+}

package/dist/core/random.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Seeded random numbers with named streams (ws/core-2).
+ *
+ * Generator: xoshiro128** (Blackman and Vigna), 128 bits of state in a `Uint32Array(4)`, period
+ * 2^128 − 1, 32-bit output. A seed is turned into a 32-bit key (a number seed that is an integer
+ * is taken `>>> 0`; any other number, and every string, is hashed with 32-bit FNV-1a over its
+ * UTF-8 bytes: offset basis 0x811c9dc5, prime 0x01000193), and the key is expanded into the four
+ * state words with splitmix32. The same seed gives the same sequence on every engine.
+ *
+ * `fork(name)` derives a child key from the stream's own key and the name (FNV-1a of the name
+ * started from the parent key), never from the parent's current state, so how often one stream is
+ * used never changes another. Every draw, and `seedKey` itself, allocates nothing; `fork` and the
+ * `state` getter do.
+ */
+export type Seed = number | string;
+/** Anything indexable by number that a vector helper can write into (`Float32Array`, `number[]`). */
+export interface NumberSink {
+    [index: number]: number;
+}
+export interface Random {
+    /** The 32-bit key this stream was seeded from (a fork's key is derived from its parent's). */
+    readonly key: number;
+    /** A float in [0, 1). */
+    next(): number;
+    /** An integer in [min, max], both ends included; unbiased (rejection sampling). */
+    int(min: number, max: number): number;
+    /** A float in [min, max). */
+    float(min: number, max: number): number;
+    /** True with probability `p` (default 0.5). */
+    bool(p?: number): boolean;
+    /** A uniformly chosen element. Throws a `RangeError` on an empty array. */
+    pick<T>(array: ArrayLike<T>): T;
+    /** An index chosen with probability `weights[i] / sum`; -1 when the sum is not positive. */
+    weighted(weights: ArrayLike<number>): number;
+    /** Fisher–Yates in place; returns `array`. */
+    shuffle<T, A extends {
+        [index: number]: T;
+        length: number;
+    }>(array: A): A;
+    /** A normal sample (Box–Muller; two uniforms per call, nothing cached, so `state` is complete). */
+    gaussian(mean?: number, sd?: number): number;
+    /** A uniformly distributed unit vector into `out[0..1]`; returns `out`. */
+    unitVec2<T extends NumberSink>(out: T): T;
+    /** A uniformly distributed unit vector on the sphere into `out[0..2]`; returns `out`. */
+    unitVec3<T extends NumberSink>(out: T): T;
+    /** A child stream keyed by this stream's key and `name`; independent of draws on this one. */
+    fork(name: string): Random;
+    /** The four state words. Reading copies; writing copies in (an all-zero state is rejected). */
+    state: Uint32Array;
+}
+/**
+ * The 32-bit key of a seed: the key `createRandom(seed)` is seeded from (`random.key`) and the
+ * one `hash2`/`hash3` mix their coordinates into. An integer number seed is taken `>>> 0`; any
+ * other number, and every string, is hashed with 32-bit FNV-1a over its UTF-8 bytes. A game uses
+ * it to derive its own stable hashes from the same seed the engine does, for example
+ * `seedKey('level-3') ^ chunkId`. Pure and allocation-free; the value never changes between
+ * engine versions (the FNV-1a reference values are tested).
+ */
+export declare function seedKey(seed: Seed): number;
+/** A seeded stream; see the module comment for the generator, the seed hash and `fork`. */
+export declare function createRandom(seed: Seed): Random;

package/dist/core/random.js

@@ -0,0 +1,199 @@
+/**
+ * Seeded random numbers with named streams (ws/core-2).
+ *
+ * Generator: xoshiro128** (Blackman and Vigna), 128 bits of state in a `Uint32Array(4)`, period
+ * 2^128 − 1, 32-bit output. A seed is turned into a 32-bit key (a number seed that is an integer
+ * is taken `>>> 0`; any other number, and every string, is hashed with 32-bit FNV-1a over its
+ * UTF-8 bytes: offset basis 0x811c9dc5, prime 0x01000193), and the key is expanded into the four
+ * state words with splitmix32. The same seed gives the same sequence on every engine.
+ *
+ * `fork(name)` derives a child key from the stream's own key and the name (FNV-1a of the name
+ * started from the parent key), never from the parent's current state, so how often one stream is
+ * used never changes another. Every draw, and `seedKey` itself, allocates nothing; `fork` and the
+ * `state` getter do.
+ */
+const FNV_OFFSET = 0x811c9dc5;
+const FNV_PRIME = 0x01000193;
+const INV_2_32 = 1 / 4294967296;
+/** 32-bit FNV-1a over the UTF-8 bytes of `s`, starting from `basis`. No allocation. */
+function fnv1a(s, basis = FNV_OFFSET) {
+    let h = basis >>> 0;
+    for (let i = 0; i < s.length; i++) {
+        let c = s.charCodeAt(i);
+        if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) {
+            const d = s.charCodeAt(i + 1);
+            if (d >= 0xdc00 && d <= 0xdfff) {
+                c = 0x10000 + ((c - 0xd800) << 10) + (d - 0xdc00);
+                i++;
+            }
+        }
+        if (c < 0x80)
+            h = Math.imul(h ^ c, FNV_PRIME);
+        else if (c < 0x800) {
+            h = Math.imul(h ^ (0xc0 | (c >> 6)), FNV_PRIME);
+            h = Math.imul(h ^ (0x80 | (c & 63)), FNV_PRIME);
+        }
+        else if (c < 0x10000) {
+            h = Math.imul(h ^ (0xe0 | (c >> 12)), FNV_PRIME);
+            h = Math.imul(h ^ (0x80 | ((c >> 6) & 63)), FNV_PRIME);
+            h = Math.imul(h ^ (0x80 | (c & 63)), FNV_PRIME);
+        }
+        else {
+            h = Math.imul(h ^ (0xf0 | (c >> 18)), FNV_PRIME);
+            h = Math.imul(h ^ (0x80 | ((c >> 12) & 63)), FNV_PRIME);
+            h = Math.imul(h ^ (0x80 | ((c >> 6) & 63)), FNV_PRIME);
+            h = Math.imul(h ^ (0x80 | (c & 63)), FNV_PRIME);
+        }
+    }
+    return h >>> 0;
+}
+/**
+ * The 32-bit key of a seed: the key `createRandom(seed)` is seeded from (`random.key`) and the
+ * one `hash2`/`hash3` mix their coordinates into. An integer number seed is taken `>>> 0`; any
+ * other number, and every string, is hashed with 32-bit FNV-1a over its UTF-8 bytes. A game uses
+ * it to derive its own stable hashes from the same seed the engine does, for example
+ * `seedKey('level-3') ^ chunkId`. Pure and allocation-free; the value never changes between
+ * engine versions (the FNV-1a reference values are tested).
+ */
+export function seedKey(seed) {
+    if (typeof seed === 'number' && Number.isInteger(seed))
+        return seed >>> 0;
+    return fnv1a(String(seed));
+}
+/** Expand a 32-bit key into four xoshiro words with splitmix32 (never all zero). */
+function expand(key, out) {
+    let s = key | 0;
+    for (let i = 0; i < 4; i++) {
+        s = (s + 0x9e3779b9) | 0;
+        let z = s;
+        z = Math.imul(z ^ (z >>> 16), 0x85ebca6b);
+        z = Math.imul(z ^ (z >>> 13), 0xc2b2ae35);
+        out[i] = (z ^ (z >>> 16)) >>> 0;
+    }
+    if ((out[0] | out[1] | out[2] | out[3]) === 0)
+        out[0] = 1;
+}
+class XoshiroRandom {
+    key;
+    s = new Uint32Array(4);
+    constructor(key) {
+        this.key = key;
+        expand(key, this.s);
+    }
+    /** The next 32-bit output (xoshiro128**). */
+    u32() {
+        const s = this.s;
+        const s0 = s[0];
+        const s1 = s[1];
+        const s2 = s[2];
+        const s3 = s[3];
+        const m = Math.imul(s1, 5);
+        const result = Math.imul((m << 7) | (m >>> 25), 9) >>> 0;
+        const t = s1 << 9;
+        const n2 = s2 ^ s0;
+        const n3 = s3 ^ s1;
+        s[1] = s1 ^ n2;
+        s[0] = s0 ^ n3;
+        s[2] = n2 ^ t;
+        s[3] = (n3 << 11) | (n3 >>> 21);
+        return result;
+    }
+    next() {
+        return this.u32() * INV_2_32;
+    }
+    int(min, max) {
+        const lo = Math.ceil(Math.min(min, max));
+        const hi = Math.floor(Math.max(min, max));
+        const n = hi - lo + 1;
+        if (n <= 1)
+            return lo;
+        if (n > 4294967296)
+            return lo + Math.floor(this.next() * n);
+        // Reject the top sliver of 2^32 that does not divide evenly by n.
+        const limit = 4294967296 - (4294967296 % n);
+        let u = this.u32();
+        while (u >= limit)
+            u = this.u32();
+        return lo + (u % n);
+    }
+    float(min, max) {
+        return min + this.next() * (max - min);
+    }
+    bool(p = 0.5) {
+        return this.next() < p;
+    }
+    pick(array) {
+        if (array.length === 0)
+            throw new RangeError('Random.pick: empty array');
+        return array[this.int(0, array.length - 1)];
+    }
+    weighted(weights) {
+        let sum = 0;
+        for (let i = 0; i < weights.length; i++) {
+            const w = weights[i];
+            if (w > 0)
+                sum += w;
+        }
+        if (!(sum > 0))
+            return -1;
+        let r = this.next() * sum;
+        let last = -1;
+        for (let i = 0; i < weights.length; i++) {
+            const w = weights[i];
+            if (!(w > 0))
+                continue;
+            last = i;
+            if (r < w)
+                return i;
+            r -= w;
+        }
+        return last;
+    }
+    shuffle(array) {
+        for (let i = array.length - 1; i > 0; i--) {
+            const j = this.int(0, i);
+            const tmp = array[i];
+            array[i] = array[j];
+            array[j] = tmp;
+        }
+        return array;
+    }
+    gaussian(mean = 0, sd = 1) {
+        const u1 = 1 - this.next(); // (0, 1]: log stays finite
+        const u2 = this.next();
+        return mean + sd * Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+    }
+    unitVec2(out) {
+        const a = this.next() * 2 * Math.PI;
+        out[0] = Math.cos(a);
+        out[1] = Math.sin(a);
+        return out;
+    }
+    unitVec3(out) {
+        const z = this.next() * 2 - 1;
+        const a = this.next() * 2 * Math.PI;
+        const r = Math.sqrt(1 - z * z);
+        out[0] = r * Math.cos(a);
+        out[1] = r * Math.sin(a);
+        out[2] = z;
+        return out;
+    }
+    fork(name) {
+        return new XoshiroRandom(fnv1a(name, this.key ^ 0x9e3779b9));
+    }
+    get state() {
+        return this.s.slice();
+    }
+    set state(words) {
+        if (words.length !== 4)
+            throw new RangeError('Random.state: expected 4 words');
+        if ((words[0] | words[1] | words[2] | words[3]) === 0) {
+            throw new RangeError('Random.state: an all-zero state is invalid for xoshiro128**');
+        }
+        this.s.set(words);
+    }
+}
+/** A seeded stream; see the module comment for the generator, the seed hash and `fork`. */
+export function createRandom(seed) {
+    return new XoshiroRandom(seedKey(seed));
+}