math 0.0.0 → 0.1.0

package/dist/noise/worley3d.js

@@ -0,0 +1,61 @@
+import { createPermutation } from './permutation.js';
+
+/**
+ * Creates a 3D Worley noise generator with the given seed.
+ *
+ * @param seed The seed value for the noise generator
+ * @returns A generator to pass to {@link sample}
+ */
+function create(seed) {
+    return createPermutation(seed);
+}
+/**
+ * Samples 3D Worley (cellular) noise: the Euclidean distance to the nearest of a
+ * set of feature points, one scattered per unit cell. Values are roughly in
+ * [0, 1] (0 right at a feature point). Threshold a 3D field for cave networks,
+ * ore pockets, or volumetric cell structures.
+ *
+ * @param generator A generator created with {@link create}
+ * @param x X coordinate
+ * @param y Y coordinate
+ * @param z Z coordinate
+ * @returns The distance to the nearest feature point (F1)
+ */
+function sample({ perm }, x, y, z) {
+    const ix = Math.floor(x);
+    const iy = Math.floor(y);
+    const iz = Math.floor(z);
+    let f1 = Infinity; // squared nearest distance
+    // check the point's cell and its 26 neighbours. The hash is nested
+    // perm[x + perm[y + perm[z]]], so the z and y stages are shared by every
+    // cell in a slice / row and are computed once per slice / row.
+    for (let gz = -1; gz <= 1; gz++) {
+        const cz = iz + gz;
+        const pz = perm[cz & 255];
+        const qz = perm[(cz + 13) & 255];
+        const sz = perm[(cz + 97) & 255];
+        for (let gy = -1; gy <= 1; gy++) {
+            const cy = iy + gy;
+            const py = perm[(cy & 255) + pz];
+            const qy = perm[((cy + 37) & 255) + qz];
+            const sy = perm[((cy + 53) & 255) + sz];
+            for (let gx = -1; gx <= 1; gx++) {
+                const cx = ix + gx;
+                // a hashed feature-point offset in [0, 1) per axis, decorrelated
+                const rx = perm[(cx & 255) + py] / 256;
+                const ry = perm[((cx + 71) & 255) + qy] / 256;
+                const rz = perm[((cx + 23) & 255) + sy] / 256;
+                const dx = cx + rx - x;
+                const dy = cy + ry - y;
+                const dz = cz + rz - z;
+                const d2 = dx * dx + dy * dy + dz * dz;
+                if (d2 < f1)
+                    f1 = d2;
+            }
+        }
+    }
+    return Math.sqrt(f1);
+}
+
+export { create, sample };
+//# sourceMappingURL=worley3d.js.map

package/dist/noise/worley3d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worley3d.js","sources":["../../src/noise/worley3d.ts"],"sourcesContent":["import { createPermutation, type Permutation } from './permutation';\n\n/** A seeded 3D Worley (cellular) noise generator. Create one with {@link create}. */\nexport type Worley3DGenerator = Permutation;\n\n/**\n * Creates a 3D Worley noise generator with the given seed.\n *\n * @param seed The seed value for the noise generator\n * @returns A generator to pass to {@link sample}\n */\nexport function create(seed: number): Worley3DGenerator {\n    return createPermutation(seed);\n}\n\n/**\n * Samples 3D Worley (cellular) noise: the Euclidean distance to the nearest of a\n * set of feature points, one scattered per unit cell. Values are roughly in\n * [0, 1] (0 right at a feature point). Threshold a 3D field for cave networks,\n * ore pockets, or volumetric cell structures.\n *\n * @param generator A generator created with {@link create}\n * @param x X coordinate\n * @param y Y coordinate\n * @param z Z coordinate\n * @returns The distance to the nearest feature point (F1)\n */\nexport function sample({ perm }: Worley3DGenerator, x: number, y: number, z: number): number {\n    const ix = Math.floor(x);\n    const iy = Math.floor(y);\n    const iz = Math.floor(z);\n    let f1 = Infinity; // squared nearest distance\n\n    // check the point's cell and its 26 neighbours. The hash is nested\n    // perm[x + perm[y + perm[z]]], so the z and y stages are shared by every\n    // cell in a slice / row and are computed once per slice / row.\n    for (let gz = -1; gz <= 1; gz++) {\n        const cz = iz + gz;\n        const pz = perm[cz & 255];\n        const qz = perm[(cz + 13) & 255];\n        const sz = perm[(cz + 97) & 255];\n        for (let gy = -1; gy <= 1; gy++) {\n            const cy = iy + gy;\n            const py = perm[(cy & 255) + pz];\n            const qy = perm[((cy + 37) & 255) + qz];\n            const sy = perm[((cy + 53) & 255) + sz];\n            for (let gx = -1; gx <= 1; gx++) {\n                const cx = ix + gx;\n                // a hashed feature-point offset in [0, 1) per axis, decorrelated\n                const rx = perm[(cx & 255) + py] / 256;\n                const ry = perm[((cx + 71) & 255) + qy] / 256;\n                const rz = perm[((cx + 23) & 255) + sy] / 256;\n                const dx = cx + rx - x;\n                const dy = cy + ry - y;\n                const dz = cz + rz - z;\n                const d2 = dx * dx + dy * dy + dz * dz;\n                if (d2 < f1) f1 = d2;\n            }\n        }\n    }\n\n    return Math.sqrt(f1);\n}\n"],"names":[],"mappings":";;AAKA;;;;;AAKG;AACG,SAAU,MAAM,CAAC,IAAY,EAAA;AAC/B,IAAA,OAAO,iBAAiB,CAAC,IAAI,CAAC;AAClC;AAEA;;;;;;;;;;;AAWG;AACG,SAAU,MAAM,CAAC,EAAE,IAAI,EAAqB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAA;IAC/E,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IACxB,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IACxB,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AACxB,IAAA,IAAI,EAAE,GAAG,QAAQ,CAAC;;;;AAKlB,IAAA,KAAK,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE;AAC7B,QAAA,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE;QAClB,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC;AACzB,QAAA,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC;AAChC,QAAA,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,CAAC;AAChC,QAAA,KAAK,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE;AAC7B,YAAA,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE;AAClB,YAAA,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,GAAG,GAAG,IAAI,EAAE,CAAC;AAChC,YAAA,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,EAAE,CAAC;AACvC,YAAA,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,EAAE,CAAC;AACvC,YAAA,KAAK,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE;AAC7B,gBAAA,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE;;AAElB,gBAAA,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,GAAG,GAAG,IAAI,EAAE,CAAC,GAAG,GAAG;AACtC,gBAAA,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,EAAE,CAAC,GAAG,GAAG;AAC7C,gBAAA,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,EAAE,CAAC,GAAG,GAAG;AAC7C,gBAAA,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;AACtB,gBAAA,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;AACtB,gBAAA,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;AACtB,gBAAA,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;gBACtC,IAAI,EAAE,GAAG,EAAE;oBAAE,EAAE,GAAG,EAAE;YACxB;QACJ;IACJ;AAEA,IAAA,OAAO,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;AACxB;;;;"}

package/dist/random/index.js

@@ -0,0 +1,9 @@
+import * as isaac32 from './isaac32.js';
+export { isaac32 };
+import * as isaac64 from './isaac64.js';
+export { isaac64 };
+import * as mulberry32 from './mulberry32.js';
+export { mulberry32 };
+import * as random from './random.js';
+export { random };
+//# sourceMappingURL=index.js.map

package/dist/random/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/random/isaac32.js

@@ -0,0 +1,164 @@
+// Bob Jenkins' seed mixing step (the golden-ratio scrambler from randinit).
+function mix(s) {
+    s[0] = (s[0] ^ (s[1] << 11)) >>> 0;
+    s[3] = (s[3] + s[0]) >>> 0;
+    s[1] = (s[1] + s[2]) >>> 0;
+    s[1] = (s[1] ^ (s[2] >>> 2)) >>> 0;
+    s[4] = (s[4] + s[1]) >>> 0;
+    s[2] = (s[2] + s[3]) >>> 0;
+    s[2] = (s[2] ^ (s[3] << 8)) >>> 0;
+    s[5] = (s[5] + s[2]) >>> 0;
+    s[3] = (s[3] + s[4]) >>> 0;
+    s[3] = (s[3] ^ (s[4] >>> 16)) >>> 0;
+    s[6] = (s[6] + s[3]) >>> 0;
+    s[4] = (s[4] + s[5]) >>> 0;
+    s[4] = (s[4] ^ (s[5] << 10)) >>> 0;
+    s[7] = (s[7] + s[4]) >>> 0;
+    s[5] = (s[5] + s[6]) >>> 0;
+    s[5] = (s[5] ^ (s[6] >>> 4)) >>> 0;
+    s[0] = (s[0] + s[5]) >>> 0;
+    s[6] = (s[6] + s[7]) >>> 0;
+    s[6] = (s[6] ^ (s[7] << 8)) >>> 0;
+    s[1] = (s[1] + s[6]) >>> 0;
+    s[7] = (s[7] + s[0]) >>> 0;
+    s[7] = (s[7] ^ (s[0] >>> 9)) >>> 0;
+    s[2] = (s[2] + s[7]) >>> 0;
+    s[0] = (s[0] + s[1]) >>> 0;
+}
+/**
+ * Creates ISAAC-32 PRNG state seeded with `seed`.
+ *
+ * ISAAC is a fast, high-quality generator: its cycle length is at least 2^40 and
+ * ~2^8295 on average, and its output passes stringent statistical tests. Bob
+ * Jenkins designed it to resist prediction, but it is not founded on
+ * cryptographic theory, so **do not rely on it for cryptography** — use the Web
+ * Crypto API for that.
+ *
+ * A `seed` of 0 reproduces the reference implementation's unseeded output. For
+ * the full-strength 64-bit variant see {@link Isaac64}.
+ *
+ * @param seed the seed value (32-bit integer), defaults to 0
+ * @returns state to pass to {@link sample} or {@link next}
+ */
+function create(seed = 0) {
+    const m = new Uint32Array(256);
+    m[0] = seed >>> 0;
+    const s = new Uint32Array(8).fill(0x9e3779b9); // the golden ratio
+    for (let k = 0; k < 4; k++)
+        mix(s); // scramble it
+    // fill m[], folding the seed in as we go
+    for (let i = 0; i < 256; i += 8) {
+        for (let k = 0; k < 8; k++)
+            s[k] = (s[k] + m[i + k]) >>> 0;
+        mix(s);
+        for (let k = 0; k < 8; k++)
+            m[i + k] = s[k];
+    }
+    return { m, r: new Uint32Array(256), a: 0, b: 0, c: 0, i: 256 };
+}
+// Generate the next batch of 256 results into state.r.
+//
+// This is Bob Jenkins' optimized rand.c form: two unrolled half-passes with the
+// second operand (`m[j]`) walking its own index, which drops both the per-word
+// `switch` on the shift pattern and the `(i + 128) % 256` wrap of the readable
+// reference. `a`/`b` are hoisted into locals so the hot loop stays off the heap.
+function refill(state) {
+    const m = state.m;
+    const r = state.r;
+    const c = (state.c + 1) >>> 0;
+    state.c = c;
+    let a = state.a;
+    let b = (state.b + c) >>> 0;
+    let i = 0;
+    let j = 128; // second operand starts a half-array ahead, then wraps to 0
+    let x = 0;
+    let y = 0;
+    // First half: i in [0, 128), j (the second operand) in [128, 256).
+    while (i < 128) {
+        x = m[i];
+        a = ((a ^ (a << 13)) + m[j++]) >>> 0;
+        y = (m[(x >>> 2) & 255] + a + b) >>> 0;
+        m[i] = y;
+        b = (m[(y >>> 10) & 255] + x) >>> 0;
+        r[i++] = b;
+        x = m[i];
+        a = ((a ^ (a >>> 6)) + m[j++]) >>> 0;
+        y = (m[(x >>> 2) & 255] + a + b) >>> 0;
+        m[i] = y;
+        b = (m[(y >>> 10) & 255] + x) >>> 0;
+        r[i++] = b;
+        x = m[i];
+        a = ((a ^ (a << 2)) + m[j++]) >>> 0;
+        y = (m[(x >>> 2) & 255] + a + b) >>> 0;
+        m[i] = y;
+        b = (m[(y >>> 10) & 255] + x) >>> 0;
+        r[i++] = b;
+        x = m[i];
+        a = ((a ^ (a >>> 16)) + m[j++]) >>> 0;
+        y = (m[(x >>> 2) & 255] + a + b) >>> 0;
+        m[i] = y;
+        b = (m[(y >>> 10) & 255] + x) >>> 0;
+        r[i++] = b;
+    }
+    // Second half: i in [128, 256), j wraps back to [0, 128).
+    j = 0;
+    while (i < 256) {
+        x = m[i];
+        a = ((a ^ (a << 13)) + m[j++]) >>> 0;
+        y = (m[(x >>> 2) & 255] + a + b) >>> 0;
+        m[i] = y;
+        b = (m[(y >>> 10) & 255] + x) >>> 0;
+        r[i++] = b;
+        x = m[i];
+        a = ((a ^ (a >>> 6)) + m[j++]) >>> 0;
+        y = (m[(x >>> 2) & 255] + a + b) >>> 0;
+        m[i] = y;
+        b = (m[(y >>> 10) & 255] + x) >>> 0;
+        r[i++] = b;
+        x = m[i];
+        a = ((a ^ (a << 2)) + m[j++]) >>> 0;
+        y = (m[(x >>> 2) & 255] + a + b) >>> 0;
+        m[i] = y;
+        b = (m[(y >>> 10) & 255] + x) >>> 0;
+        r[i++] = b;
+        x = m[i];
+        a = ((a ^ (a >>> 16)) + m[j++]) >>> 0;
+        y = (m[(x >>> 2) & 255] + a + b) >>> 0;
+        m[i] = y;
+        b = (m[(y >>> 10) & 255] + x) >>> 0;
+        r[i++] = b;
+    }
+    state.a = a;
+    state.b = b;
+    state.i = 0;
+}
+/**
+ * Advances `state` and returns the next raw 32-bit unsigned integer.
+ *
+ * @param state PRNG state created with {@link create}, mutated in place
+ * @returns an integer in the range [0, 2^32)
+ */
+function next(state) {
+    if (state.i >= 256)
+        refill(state);
+    return state.r[state.i++];
+}
+/**
+ * Advances `state` and returns the next number in the range [0, 1).
+ *
+ * @param state PRNG state created with {@link create}, mutated in place
+ * @returns a number in the range [0, 1)
+ */
+function sample(state) {
+    return next(state) / 4294967296;
+}
+/**
+ * Generates a random 32-bit unsigned integer seed, suitable for use with
+ * {@link create}.
+ */
+function seed() {
+    return (Math.random() * 2 ** 32) >>> 0;
+}
+
+export { create, next, sample, seed };
+//# sourceMappingURL=isaac32.js.map

package/dist/random/isaac32.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isaac32.js","sources":["../../src/random/isaac32.ts"],"sourcesContent":["/**\n * State of an ISAAC-32 PRNG: two 256-word arrays plus three accumulators and a\n * cursor into the current batch of results. Create one with {@link create}.\n *\n * ISAAC (Indirection, Shift, Accumulate, Add, Count) generates 256 words per\n * round and hands them out one at a time; {@link next}/{@link sample} refill the\n * batch automatically when it runs dry.\n *\n * The state is a plain object, so it can be inspected,\n * cloned (to fork a sequence), or serialised. `m`/`r` are typed arrays, so a\n * structural clone (e.g. `structuredClone`) forks correctly; a shallow `{...}`\n * copy shares them and does not.\n */\nexport type Isaac32 = {\n    /** internal state (\"mem\"), 256 words */\n    m: Uint32Array;\n    /** current batch of results, 256 words */\n    r: Uint32Array;\n    /** accumulator */\n    a: number;\n    /** previous result */\n    b: number;\n    /** counter, incremented once per batch */\n    c: number;\n    /** cursor into `r`; a value of 256 means the batch is spent */\n    i: number;\n};\n\n// Bob Jenkins' seed mixing step (the golden-ratio scrambler from randinit).\nfunction mix(s: Uint32Array): void {\n    s[0] = (s[0] ^ (s[1] << 11)) >>> 0;\n    s[3] = (s[3] + s[0]) >>> 0;\n    s[1] = (s[1] + s[2]) >>> 0;\n    s[1] = (s[1] ^ (s[2] >>> 2)) >>> 0;\n    s[4] = (s[4] + s[1]) >>> 0;\n    s[2] = (s[2] + s[3]) >>> 0;\n    s[2] = (s[2] ^ (s[3] << 8)) >>> 0;\n    s[5] = (s[5] + s[2]) >>> 0;\n    s[3] = (s[3] + s[4]) >>> 0;\n    s[3] = (s[3] ^ (s[4] >>> 16)) >>> 0;\n    s[6] = (s[6] + s[3]) >>> 0;\n    s[4] = (s[4] + s[5]) >>> 0;\n    s[4] = (s[4] ^ (s[5] << 10)) >>> 0;\n    s[7] = (s[7] + s[4]) >>> 0;\n    s[5] = (s[5] + s[6]) >>> 0;\n    s[5] = (s[5] ^ (s[6] >>> 4)) >>> 0;\n    s[0] = (s[0] + s[5]) >>> 0;\n    s[6] = (s[6] + s[7]) >>> 0;\n    s[6] = (s[6] ^ (s[7] << 8)) >>> 0;\n    s[1] = (s[1] + s[6]) >>> 0;\n    s[7] = (s[7] + s[0]) >>> 0;\n    s[7] = (s[7] ^ (s[0] >>> 9)) >>> 0;\n    s[2] = (s[2] + s[7]) >>> 0;\n    s[0] = (s[0] + s[1]) >>> 0;\n}\n\n/**\n * Creates ISAAC-32 PRNG state seeded with `seed`.\n *\n * ISAAC is a fast, high-quality generator: its cycle length is at least 2^40 and\n * ~2^8295 on average, and its output passes stringent statistical tests. Bob\n * Jenkins designed it to resist prediction, but it is not founded on\n * cryptographic theory, so **do not rely on it for cryptography** — use the Web\n * Crypto API for that.\n *\n * A `seed` of 0 reproduces the reference implementation's unseeded output. For\n * the full-strength 64-bit variant see {@link Isaac64}.\n *\n * @param seed the seed value (32-bit integer), defaults to 0\n * @returns state to pass to {@link sample} or {@link next}\n */\nexport function create(seed = 0): Isaac32 {\n    const m = new Uint32Array(256);\n    m[0] = seed >>> 0;\n\n    const s = new Uint32Array(8).fill(0x9e3779b9); // the golden ratio\n    for (let k = 0; k < 4; k++) mix(s); // scramble it\n\n    // fill m[], folding the seed in as we go\n    for (let i = 0; i < 256; i += 8) {\n        for (let k = 0; k < 8; k++) s[k] = (s[k] + m[i + k]) >>> 0;\n        mix(s);\n        for (let k = 0; k < 8; k++) m[i + k] = s[k];\n    }\n\n    return { m, r: new Uint32Array(256), a: 0, b: 0, c: 0, i: 256 };\n}\n\n// Generate the next batch of 256 results into state.r.\n//\n// This is Bob Jenkins' optimized rand.c form: two unrolled half-passes with the\n// second operand (`m[j]`) walking its own index, which drops both the per-word\n// `switch` on the shift pattern and the `(i + 128) % 256` wrap of the readable\n// reference. `a`/`b` are hoisted into locals so the hot loop stays off the heap.\nfunction refill(state: Isaac32): void {\n    const m = state.m;\n    const r = state.r;\n    const c = (state.c + 1) >>> 0;\n    state.c = c;\n    let a = state.a;\n    let b = (state.b + c) >>> 0;\n\n    let i = 0;\n    let j = 128; // second operand starts a half-array ahead, then wraps to 0\n    let x = 0;\n    let y = 0;\n\n    // First half: i in [0, 128), j (the second operand) in [128, 256).\n    while (i < 128) {\n        x = m[i];\n        a = ((a ^ (a << 13)) + m[j++]) >>> 0;\n        y = (m[(x >>> 2) & 255] + a + b) >>> 0;\n        m[i] = y;\n        b = (m[(y >>> 10) & 255] + x) >>> 0;\n        r[i++] = b;\n\n        x = m[i];\n        a = ((a ^ (a >>> 6)) + m[j++]) >>> 0;\n        y = (m[(x >>> 2) & 255] + a + b) >>> 0;\n        m[i] = y;\n        b = (m[(y >>> 10) & 255] + x) >>> 0;\n        r[i++] = b;\n\n        x = m[i];\n        a = ((a ^ (a << 2)) + m[j++]) >>> 0;\n        y = (m[(x >>> 2) & 255] + a + b) >>> 0;\n        m[i] = y;\n        b = (m[(y >>> 10) & 255] + x) >>> 0;\n        r[i++] = b;\n\n        x = m[i];\n        a = ((a ^ (a >>> 16)) + m[j++]) >>> 0;\n        y = (m[(x >>> 2) & 255] + a + b) >>> 0;\n        m[i] = y;\n        b = (m[(y >>> 10) & 255] + x) >>> 0;\n        r[i++] = b;\n    }\n\n    // Second half: i in [128, 256), j wraps back to [0, 128).\n    j = 0;\n    while (i < 256) {\n        x = m[i];\n        a = ((a ^ (a << 13)) + m[j++]) >>> 0;\n        y = (m[(x >>> 2) & 255] + a + b) >>> 0;\n        m[i] = y;\n        b = (m[(y >>> 10) & 255] + x) >>> 0;\n        r[i++] = b;\n\n        x = m[i];\n        a = ((a ^ (a >>> 6)) + m[j++]) >>> 0;\n        y = (m[(x >>> 2) & 255] + a + b) >>> 0;\n        m[i] = y;\n        b = (m[(y >>> 10) & 255] + x) >>> 0;\n        r[i++] = b;\n\n        x = m[i];\n        a = ((a ^ (a << 2)) + m[j++]) >>> 0;\n        y = (m[(x >>> 2) & 255] + a + b) >>> 0;\n        m[i] = y;\n        b = (m[(y >>> 10) & 255] + x) >>> 0;\n        r[i++] = b;\n\n        x = m[i];\n        a = ((a ^ (a >>> 16)) + m[j++]) >>> 0;\n        y = (m[(x >>> 2) & 255] + a + b) >>> 0;\n        m[i] = y;\n        b = (m[(y >>> 10) & 255] + x) >>> 0;\n        r[i++] = b;\n    }\n\n    state.a = a;\n    state.b = b;\n    state.i = 0;\n}\n\n/**\n * Advances `state` and returns the next raw 32-bit unsigned integer.\n *\n * @param state PRNG state created with {@link create}, mutated in place\n * @returns an integer in the range [0, 2^32)\n */\nexport function next(state: Isaac32): number {\n    if (state.i >= 256) refill(state);\n    return state.r[state.i++];\n}\n\n/**\n * Advances `state` and returns the next number in the range [0, 1).\n *\n * @param state PRNG state created with {@link create}, mutated in place\n * @returns a number in the range [0, 1)\n */\nexport function sample(state: Isaac32): number {\n    return next(state) / 4294967296;\n}\n\n/**\n * Generates a random 32-bit unsigned integer seed, suitable for use with\n * {@link create}.\n */\nexport function seed(): number {\n    return (Math.random() * 2 ** 32) >>> 0;\n}\n"],"names":[],"mappings":"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"}

package/dist/random/isaac64.js

@@ -0,0 +1,215 @@
+const MASK = 0xffffffffffffffffn;
+// The golden-ratio constant 0x9e3779b97f4a7c15 pre-scrambled by the reference's
+// four mixing rounds — the seed-mixing starting accumulators.
+const SCRAMBLED = [
+    0x647c4677a2884b7cn,
+    0xb9f8b322c73ac862n,
+    0x8c0ea5053d4712a0n,
+    0xb29b2e824a595524n,
+    0x82f053db8355e0cen,
+    0x48fe4a0fa5a09315n,
+    0xae985bf2cbfc89edn,
+    0x98f5704f6c44c0abn,
+];
+/**
+ * Creates ISAAC64 PRNG state seeded with `seed`.
+ *
+ * ISAAC64 is a fast, high-quality generator with an enormous cycle length
+ * (~2^8295 on average). Bob Jenkins designed it to resist prediction, but it is
+ * not founded on cryptographic theory, so **do not rely on it for
+ * cryptography** — use the Web Crypto API for that.
+ *
+ * A `seed` of 0 reproduces the reference implementation's unseeded output.
+ *
+ * @param seed the seed value (64-bit integer), defaults to 0n
+ * @returns state to pass to {@link sample} or {@link next}
+ */
+function create(seed = 0n) {
+    // Seed mixing is one-time (not hot), so it stays in 64-bit `bigint`; the
+    // resulting `m` is then split into the 32-bit lanes the refill loop uses.
+    const m = new BigUint64Array(256);
+    m[0] = seed & MASK;
+    const a = SCRAMBLED.slice();
+    for (let j = 0; j < 256; j += 8) {
+        for (let x = 0; x < 8; x++)
+            a[x] = (a[x] + m[j + x]) & MASK;
+        a[0] = (a[0] - a[4]) & MASK;
+        a[5] ^= a[7] >> 9n;
+        a[7] = (a[7] + a[0]) & MASK;
+        a[1] = (a[1] - a[5]) & MASK;
+        a[6] ^= (a[0] << 9n) & MASK;
+        a[0] = (a[0] + a[1]) & MASK;
+        a[2] = (a[2] - a[6]) & MASK;
+        a[7] ^= a[1] >> 23n;
+        a[1] = (a[1] + a[2]) & MASK;
+        a[3] = (a[3] - a[7]) & MASK;
+        a[0] ^= (a[2] << 15n) & MASK;
+        a[2] = (a[2] + a[3]) & MASK;
+        a[4] = (a[4] - a[0]) & MASK;
+        a[1] ^= a[3] >> 14n;
+        a[3] = (a[3] + a[4]) & MASK;
+        a[5] = (a[5] - a[1]) & MASK;
+        a[2] ^= (a[4] << 20n) & MASK;
+        a[4] = (a[4] + a[5]) & MASK;
+        a[6] = (a[6] - a[2]) & MASK;
+        a[3] ^= a[5] >> 17n;
+        a[5] = (a[5] + a[6]) & MASK;
+        a[7] = (a[7] - a[3]) & MASK;
+        a[4] ^= (a[6] << 14n) & MASK;
+        a[6] = (a[6] + a[7]) & MASK;
+        for (let x = 0; x < 8; x++)
+            m[j + x] = a[x];
+    }
+    const mHi = new Uint32Array(256);
+    const mLo = new Uint32Array(256);
+    for (let k = 0; k < 256; k++) {
+        const v = m[k];
+        mLo[k] = Number(v & 0xffffffffn);
+        mHi[k] = Number(v >> 32n);
+    }
+    return {
+        mHi,
+        mLo,
+        rHi: new Uint32Array(256),
+        rLo: new Uint32Array(256),
+        aHi: 0,
+        aLo: 0,
+        bHi: 0,
+        bLo: 0,
+        cHi: 0,
+        cLo: 0,
+        i: 256,
+    };
+}
+const TWO32 = 4294967296; // 2^32, the carry threshold
+// Generate the next batch of 256 results into state.r{Hi,Lo}.
+//
+// Bob Jenkins' ISAAC64 on split 32-bit lanes: each 64-bit add is a lane add plus
+// a carry into the high lane, and the 64-bit shifts (21/5/12/33) are done by
+// hand across the lane boundary. Results are written in reverse (r[255 - i]) to
+// match the reference stream order. `a`/`b` are hoisted into locals so the loop
+// stays in fast Word32 integer math.
+function refill(state) {
+    const mHi = state.mHi;
+    const mLo = state.mLo;
+    const rHi = state.rHi;
+    const rLo = state.rLo;
+    // c += 1
+    const cLo = (state.cLo + 1) >>> 0;
+    let cHi = state.cHi;
+    if (cLo === 0)
+        cHi = (cHi + 1) >>> 0;
+    state.cLo = cLo;
+    state.cHi = cHi;
+    // b += c
+    const b0 = state.bLo + cLo;
+    let bLo = b0 >>> 0;
+    let bHi = (state.bHi + cHi + (b0 >= TWO32 ? 1 : 0)) >>> 0;
+    let aHi = state.aHi;
+    let aLo = state.aLo;
+    for (let i = 0; i < 256; i++) {
+        // mixed = (~)(a ^ (a << k)) / (a ^ (a >> k)), the shift pattern cycling
+        // every four words. Only the mix differs between the four cases.
+        let mxHi;
+        let mxLo;
+        let tHi;
+        let tLo;
+        switch (i & 3) {
+            case 0: // ~(a ^ (a << 21))
+                tHi = ((aHi << 21) | (aLo >>> 11)) >>> 0;
+                tLo = (aLo << 21) >>> 0;
+                mxHi = ~(aHi ^ tHi) >>> 0;
+                mxLo = ~(aLo ^ tLo) >>> 0;
+                break;
+            case 1: // a ^ (a >> 5)
+                tLo = ((aLo >>> 5) | (aHi << 27)) >>> 0;
+                tHi = aHi >>> 5;
+                mxHi = (aHi ^ tHi) >>> 0;
+                mxLo = (aLo ^ tLo) >>> 0;
+                break;
+            case 2: // a ^ (a << 12)
+                tHi = ((aHi << 12) | (aLo >>> 20)) >>> 0;
+                tLo = (aLo << 12) >>> 0;
+                mxHi = (aHi ^ tHi) >>> 0;
+                mxLo = (aLo ^ tLo) >>> 0;
+                break;
+            default: // a ^ (a >> 33) — shifts entirely into the low lane
+                mxLo = (aLo ^ (aHi >>> 1)) >>> 0;
+                mxHi = aHi;
+        }
+        const i2 = (i + 128) & 255; // the second operand, half an array ahead
+        const xLo = mLo[i];
+        const xHi = mHi[i];
+        // a = mixed + m[i2]
+        const s0 = mxLo + mLo[i2];
+        aLo = s0 >>> 0;
+        aHi = (mxHi + mHi[i2] + (s0 >= TWO32 ? 1 : 0)) >>> 0;
+        // y = a + b + m[(x >> 3) & 255]   (the low 8 index bits live in the low lane)
+        const idx = (xLo >>> 3) & 255;
+        let abLo = aLo + bLo;
+        const abHi = (aHi + bHi + (abLo >= TWO32 ? 1 : 0)) >>> 0;
+        abLo = abLo >>> 0;
+        let yLo = abLo + mLo[idx];
+        const yHi = (abHi + mHi[idx] + (yLo >= TWO32 ? 1 : 0)) >>> 0;
+        yLo = yLo >>> 0;
+        mLo[i] = yLo;
+        mHi[i] = yHi;
+        // b = x + m[(y >> 11) & 255]
+        const idx2 = (yLo >>> 11) & 255;
+        const t = xLo + mLo[idx2];
+        bHi = (xHi + mHi[idx2] + (t >= TWO32 ? 1 : 0)) >>> 0;
+        bLo = t >>> 0;
+        const o = 255 - i;
+        rLo[o] = bLo;
+        rHi[o] = bHi;
+    }
+    state.aHi = aHi;
+    state.aLo = aLo;
+    state.bHi = bHi;
+    state.bLo = bLo;
+    state.i = 0;
+}
+/**
+ * Advances `state` and returns the next raw 64-bit unsigned integer.
+ *
+ * This reassembles a `bigint` from the two lanes, so it allocates; for a value
+ * in [0, 1) prefer {@link sample}, which stays in `number` arithmetic.
+ *
+ * @param state PRNG state created with {@link create}, mutated in place
+ * @returns an integer in the range [0, 2^64)
+ */
+function next(state) {
+    if (state.i >= 256)
+        refill(state);
+    const i = state.i++;
+    return (BigInt(state.rHi[i]) << 32n) | BigInt(state.rLo[i]);
+}
+/**
+ * Advances `state` and returns the next number in the range [0, 1).
+ *
+ * The result carries 53 bits of randomness (the width of a double's mantissa),
+ * taken from the high bits of a 64-bit word — read straight from the lanes, so
+ * no `bigint` is allocated.
+ *
+ * @param state PRNG state created with {@link create}, mutated in place
+ * @returns a number in the range [0, 1)
+ */
+function sample(state) {
+    if (state.i >= 256)
+        refill(state);
+    const i = state.i++;
+    // top 53 bits = (word >> 11) = hi * 2^21 + (lo >>> 11), exact in a double
+    return (state.rHi[i] * 2097152 + (state.rLo[i] >>> 11)) / 9007199254740992; // 2^21, 2^53
+}
+/**
+ * Generates a random 64-bit unsigned integer seed, suitable for use with
+ * {@link create}.
+ */
+function seed() {
+    const hi = BigInt((Math.random() * 2 ** 32) >>> 0);
+    const lo = BigInt((Math.random() * 2 ** 32) >>> 0);
+    return (hi << 32n) | lo;
+}
+
+export { create, next, sample, seed };
+//# sourceMappingURL=isaac64.js.map

package/dist/random/isaac64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isaac64.js","sources":["../../src/random/isaac64.ts"],"sourcesContent":["/**\n * State of an ISAAC64 PRNG. Create one with {@link create}.\n *\n * ISAAC64 is the 64-bit variant of ISAAC (Indirection, Shift, Accumulate, Add,\n * Count): same design as {@link Isaac32} but on 64-bit words, giving a larger\n * state and 64-bit output. JavaScript has no native 64-bit integers, so each\n * 64-bit word is split into two 32-bit lanes — `*Hi` (bits 63..32) and `*Lo`\n * (bits 31..0) — and the hot loop does 64-bit math with explicit carries in\n * plain `number`s. That keeps the whole generator in fast Word32 arithmetic\n * (see the note on {@link Isaac32}'s typed arrays); a `bigint` implementation is\n * ~6x slower. `next` reassembles a `bigint`; `sample` skips `bigint` entirely.\n *\n * The state is a plain object, so it can be inspected, cloned (to fork a\n * sequence), or serialised. The lanes are typed arrays, so a structural clone\n * (e.g. `structuredClone`) forks correctly; a shallow `{...}` copy shares them.\n */\nexport type Isaac64 = {\n    /** internal state (\"mem\") high/low lanes, 256 words */\n    mHi: Uint32Array;\n    mLo: Uint32Array;\n    /** current batch of results, high/low lanes, 256 words */\n    rHi: Uint32Array;\n    rLo: Uint32Array;\n    /** accumulator */\n    aHi: number;\n    aLo: number;\n    /** previous result */\n    bHi: number;\n    bLo: number;\n    /** counter, incremented once per batch */\n    cHi: number;\n    cLo: number;\n    /** cursor into `r`; a value of 256 means the batch is spent */\n    i: number;\n};\n\nconst MASK = 0xffffffffffffffffn;\n\n// The golden-ratio constant 0x9e3779b97f4a7c15 pre-scrambled by the reference's\n// four mixing rounds — the seed-mixing starting accumulators.\nconst SCRAMBLED = [\n    0x647c4677a2884b7cn,\n    0xb9f8b322c73ac862n,\n    0x8c0ea5053d4712a0n,\n    0xb29b2e824a595524n,\n    0x82f053db8355e0cen,\n    0x48fe4a0fa5a09315n,\n    0xae985bf2cbfc89edn,\n    0x98f5704f6c44c0abn,\n];\n\n/**\n * Creates ISAAC64 PRNG state seeded with `seed`.\n *\n * ISAAC64 is a fast, high-quality generator with an enormous cycle length\n * (~2^8295 on average). Bob Jenkins designed it to resist prediction, but it is\n * not founded on cryptographic theory, so **do not rely on it for\n * cryptography** — use the Web Crypto API for that.\n *\n * A `seed` of 0 reproduces the reference implementation's unseeded output.\n *\n * @param seed the seed value (64-bit integer), defaults to 0n\n * @returns state to pass to {@link sample} or {@link next}\n */\nexport function create(seed: bigint = 0n): Isaac64 {\n    // Seed mixing is one-time (not hot), so it stays in 64-bit `bigint`; the\n    // resulting `m` is then split into the 32-bit lanes the refill loop uses.\n    const m = new BigUint64Array(256);\n    m[0] = seed & MASK;\n\n    const a = SCRAMBLED.slice();\n    for (let j = 0; j < 256; j += 8) {\n        for (let x = 0; x < 8; x++) a[x] = (a[x] + m[j + x]) & MASK;\n        a[0] = (a[0] - a[4]) & MASK;\n        a[5] ^= a[7] >> 9n;\n        a[7] = (a[7] + a[0]) & MASK;\n        a[1] = (a[1] - a[5]) & MASK;\n        a[6] ^= (a[0] << 9n) & MASK;\n        a[0] = (a[0] + a[1]) & MASK;\n        a[2] = (a[2] - a[6]) & MASK;\n        a[7] ^= a[1] >> 23n;\n        a[1] = (a[1] + a[2]) & MASK;\n        a[3] = (a[3] - a[7]) & MASK;\n        a[0] ^= (a[2] << 15n) & MASK;\n        a[2] = (a[2] + a[3]) & MASK;\n        a[4] = (a[4] - a[0]) & MASK;\n        a[1] ^= a[3] >> 14n;\n        a[3] = (a[3] + a[4]) & MASK;\n        a[5] = (a[5] - a[1]) & MASK;\n        a[2] ^= (a[4] << 20n) & MASK;\n        a[4] = (a[4] + a[5]) & MASK;\n        a[6] = (a[6] - a[2]) & MASK;\n        a[3] ^= a[5] >> 17n;\n        a[5] = (a[5] + a[6]) & MASK;\n        a[7] = (a[7] - a[3]) & MASK;\n        a[4] ^= (a[6] << 14n) & MASK;\n        a[6] = (a[6] + a[7]) & MASK;\n        for (let x = 0; x < 8; x++) m[j + x] = a[x];\n    }\n\n    const mHi = new Uint32Array(256);\n    const mLo = new Uint32Array(256);\n    for (let k = 0; k < 256; k++) {\n        const v = m[k];\n        mLo[k] = Number(v & 0xffffffffn);\n        mHi[k] = Number(v >> 32n);\n    }\n\n    return {\n        mHi,\n        mLo,\n        rHi: new Uint32Array(256),\n        rLo: new Uint32Array(256),\n        aHi: 0,\n        aLo: 0,\n        bHi: 0,\n        bLo: 0,\n        cHi: 0,\n        cLo: 0,\n        i: 256,\n    };\n}\n\nconst TWO32 = 4294967296; // 2^32, the carry threshold\n\n// Generate the next batch of 256 results into state.r{Hi,Lo}.\n//\n// Bob Jenkins' ISAAC64 on split 32-bit lanes: each 64-bit add is a lane add plus\n// a carry into the high lane, and the 64-bit shifts (21/5/12/33) are done by\n// hand across the lane boundary. Results are written in reverse (r[255 - i]) to\n// match the reference stream order. `a`/`b` are hoisted into locals so the loop\n// stays in fast Word32 integer math.\nfunction refill(state: Isaac64): void {\n    const mHi = state.mHi;\n    const mLo = state.mLo;\n    const rHi = state.rHi;\n    const rLo = state.rLo;\n\n    // c += 1\n    const cLo = (state.cLo + 1) >>> 0;\n    let cHi = state.cHi;\n    if (cLo === 0) cHi = (cHi + 1) >>> 0;\n    state.cLo = cLo;\n    state.cHi = cHi;\n\n    // b += c\n    const b0 = state.bLo + cLo;\n    let bLo = b0 >>> 0;\n    let bHi = (state.bHi + cHi + (b0 >= TWO32 ? 1 : 0)) >>> 0;\n\n    let aHi = state.aHi;\n    let aLo = state.aLo;\n\n    for (let i = 0; i < 256; i++) {\n        // mixed = (~)(a ^ (a << k)) / (a ^ (a >> k)), the shift pattern cycling\n        // every four words. Only the mix differs between the four cases.\n        let mxHi: number;\n        let mxLo: number;\n        let tHi: number;\n        let tLo: number;\n        switch (i & 3) {\n            case 0: // ~(a ^ (a << 21))\n                tHi = ((aHi << 21) | (aLo >>> 11)) >>> 0;\n                tLo = (aLo << 21) >>> 0;\n                mxHi = ~(aHi ^ tHi) >>> 0;\n                mxLo = ~(aLo ^ tLo) >>> 0;\n                break;\n            case 1: // a ^ (a >> 5)\n                tLo = ((aLo >>> 5) | (aHi << 27)) >>> 0;\n                tHi = aHi >>> 5;\n                mxHi = (aHi ^ tHi) >>> 0;\n                mxLo = (aLo ^ tLo) >>> 0;\n                break;\n            case 2: // a ^ (a << 12)\n                tHi = ((aHi << 12) | (aLo >>> 20)) >>> 0;\n                tLo = (aLo << 12) >>> 0;\n                mxHi = (aHi ^ tHi) >>> 0;\n                mxLo = (aLo ^ tLo) >>> 0;\n                break;\n            default: // a ^ (a >> 33) — shifts entirely into the low lane\n                mxLo = (aLo ^ (aHi >>> 1)) >>> 0;\n                mxHi = aHi;\n        }\n\n        const i2 = (i + 128) & 255; // the second operand, half an array ahead\n        const xLo = mLo[i];\n        const xHi = mHi[i];\n\n        // a = mixed + m[i2]\n        const s0 = mxLo + mLo[i2];\n        aLo = s0 >>> 0;\n        aHi = (mxHi + mHi[i2] + (s0 >= TWO32 ? 1 : 0)) >>> 0;\n\n        // y = a + b + m[(x >> 3) & 255]   (the low 8 index bits live in the low lane)\n        const idx = (xLo >>> 3) & 255;\n        let abLo = aLo + bLo;\n        const abHi = (aHi + bHi + (abLo >= TWO32 ? 1 : 0)) >>> 0;\n        abLo = abLo >>> 0;\n        let yLo = abLo + mLo[idx];\n        const yHi = (abHi + mHi[idx] + (yLo >= TWO32 ? 1 : 0)) >>> 0;\n        yLo = yLo >>> 0;\n        mLo[i] = yLo;\n        mHi[i] = yHi;\n\n        // b = x + m[(y >> 11) & 255]\n        const idx2 = (yLo >>> 11) & 255;\n        const t = xLo + mLo[idx2];\n        bHi = (xHi + mHi[idx2] + (t >= TWO32 ? 1 : 0)) >>> 0;\n        bLo = t >>> 0;\n\n        const o = 255 - i;\n        rLo[o] = bLo;\n        rHi[o] = bHi;\n    }\n\n    state.aHi = aHi;\n    state.aLo = aLo;\n    state.bHi = bHi;\n    state.bLo = bLo;\n    state.i = 0;\n}\n\n/**\n * Advances `state` and returns the next raw 64-bit unsigned integer.\n *\n * This reassembles a `bigint` from the two lanes, so it allocates; for a value\n * in [0, 1) prefer {@link sample}, which stays in `number` arithmetic.\n *\n * @param state PRNG state created with {@link create}, mutated in place\n * @returns an integer in the range [0, 2^64)\n */\nexport function next(state: Isaac64): bigint {\n    if (state.i >= 256) refill(state);\n    const i = state.i++;\n    return (BigInt(state.rHi[i]) << 32n) | BigInt(state.rLo[i]);\n}\n\n/**\n * Advances `state` and returns the next number in the range [0, 1).\n *\n * The result carries 53 bits of randomness (the width of a double's mantissa),\n * taken from the high bits of a 64-bit word — read straight from the lanes, so\n * no `bigint` is allocated.\n *\n * @param state PRNG state created with {@link create}, mutated in place\n * @returns a number in the range [0, 1)\n */\nexport function sample(state: Isaac64): number {\n    if (state.i >= 256) refill(state);\n    const i = state.i++;\n    // top 53 bits = (word >> 11) = hi * 2^21 + (lo >>> 11), exact in a double\n    return (state.rHi[i] * 2097152 + (state.rLo[i] >>> 11)) / 9007199254740992; // 2^21, 2^53\n}\n\n/**\n * Generates a random 64-bit unsigned integer seed, suitable for use with\n * {@link create}.\n */\nexport function seed(): bigint {\n    const hi = BigInt((Math.random() * 2 ** 32) >>> 0);\n    const lo = BigInt((Math.random() * 2 ** 32) >>> 0);\n    return (hi << 32n) | lo;\n}\n"],"names":[],"mappings":"AAoCA,MAAM,IAAI,GAAG,mBAAmB;AAEhC;AACA;AACA,MAAM,SAAS,GAAG;IACd,mBAAmB;IACnB,mBAAmB;IACnB,mBAAmB;IACnB,mBAAmB;IACnB,mBAAmB;IACnB,mBAAmB;IACnB,mBAAmB;IACnB,mBAAmB;CACtB;AAED;;;;;;;;;;;;AAYG;AACG,SAAU,MAAM,CAAC,IAAA,GAAe,EAAE,EAAA;;;AAGpC,IAAA,MAAM,CAAC,GAAG,IAAI,cAAc,CAAC,GAAG,CAAC;AACjC,IAAA,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI;AAElB,IAAA,MAAM,CAAC,GAAG,SAAS,CAAC,KAAK,EAAE;AAC3B,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE;QAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;AAAE,YAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI;AAC3D,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;QAC3B,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;AAClB,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;AAC3B,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;AAC3B,QAAA,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,IAAI,IAAI;AAC3B,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;AAC3B,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;QAC3B,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG;AACnB,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;AAC3B,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;AAC3B,QAAA,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI;AAC5B,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;AAC3B,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;QAC3B,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG;AACnB,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;AAC3B,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;AAC3B,QAAA,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI;AAC5B,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;AAC3B,QAAA,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;QAC3B,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG;AACnB,QAAA,CAAC,CAAC,CAAC,CAAC,GAA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"}

package/dist/random/mulberry32.js

@@ -0,0 +1,48 @@
+/**
+ * Creates Mulberry32 PRNG state seeded with `seed`.
+ *
+ * Mulberry32 is a simple, fast, and effective PRNG that passes statistical tests
+ * and has good distribution properties.
+ *
+ * @param seed the seed value (32-bit integer)
+ * @returns state to pass to {@link sample}
+ */
+function create(seed) {
+    return { a: seed };
+}
+/**
+ * Advances `state` and returns the next raw 32-bit unsigned integer.
+ *
+ * The accumulator is kept to 32 bits with `| 0`; without it, `state.a` would grow
+ * as an unbounded float and lose integer precision past 2^53 (~5M draws),
+ * corrupting the sequence.
+ *
+ * @param state PRNG state created with {@link create}, mutated in place
+ * @returns an integer in the range [0, 2^32)
+ */
+function next(state) {
+    state.a = (state.a + 0x6d2b79f5) | 0;
+    let t = state.a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return (t ^ (t >>> 14)) >>> 0;
+}
+/**
+ * Advances `state` and returns the next number in the range [0, 1).
+ *
+ * @param state PRNG state created with {@link create}, mutated in place
+ * @returns a number in the range [0, 1)
+ */
+function sample(state) {
+    return next(state) / 4294967296;
+}
+/**
+ * Generates a random 32-bit unsigned integer seed, suitable for use with
+ * {@link create}.
+ */
+function seed() {
+    return (Math.random() * 2 ** 32) >>> 0;
+}
+
+export { create, next, sample, seed };
+//# sourceMappingURL=mulberry32.js.map

package/dist/random/mulberry32.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mulberry32.js","sources":["../../src/random/mulberry32.ts"],"sourcesContent":["/**\n * State of a Mulberry32 PRNG: a single 32-bit accumulator that {@link sample}\n * advances on each call. Create one with {@link create}.\n *\n * Unlike a closure-based generator, the state is a plain object — so it can be\n * inspected, cloned (to fork a sequence), or serialised.\n */\nexport type Mulberry32 = { a: number };\n\n/**\n * Creates Mulberry32 PRNG state seeded with `seed`.\n *\n * Mulberry32 is a simple, fast, and effective PRNG that passes statistical tests\n * and has good distribution properties.\n *\n * @param seed the seed value (32-bit integer)\n * @returns state to pass to {@link sample}\n */\nexport function create(seed: number): Mulberry32 {\n    return { a: seed };\n}\n\n/**\n * Advances `state` and returns the next raw 32-bit unsigned integer.\n *\n * The accumulator is kept to 32 bits with `| 0`; without it, `state.a` would grow\n * as an unbounded float and lose integer precision past 2^53 (~5M draws),\n * corrupting the sequence.\n *\n * @param state PRNG state created with {@link create}, mutated in place\n * @returns an integer in the range [0, 2^32)\n */\nexport function next(state: Mulberry32): number {\n    state.a = (state.a + 0x6d2b79f5) | 0;\n    let t = state.a;\n    t = Math.imul(t ^ (t >>> 15), t | 1);\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n    return (t ^ (t >>> 14)) >>> 0;\n}\n\n/**\n * Advances `state` and returns the next number in the range [0, 1).\n *\n * @param state PRNG state created with {@link create}, mutated in place\n * @returns a number in the range [0, 1)\n */\nexport function sample(state: Mulberry32): number {\n    return next(state) / 4294967296;\n}\n\n/**\n * Generates a random 32-bit unsigned integer seed, suitable for use with\n * {@link create}.\n */\nexport function seed(): number {\n    return (Math.random() * 2 ** 32) >>> 0;\n}\n"],"names":[],"mappings":"AASA;;;;;;;;AAQG;AACG,SAAU,MAAM,CAAC,IAAY,EAAA;AAC/B,IAAA,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE;AACtB;AAEA;;;;;;;;;AASG;AACG,SAAU,IAAI,CAAC,KAAiB,EAAA;AAClC,IAAA,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,IAAI,CAAC;AACpC,IAAA,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;AACf,IAAA,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;AACpC,IAAA,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC;IACzC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC;AACjC;AAEA;;;;;AAKG;AACG,SAAU,MAAM,CAAC,KAAiB,EAAA;AACpC,IAAA,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,UAAU;AACnC;AAEA;;;AAGG;SACa,IAAI,GAAA;AAChB,IAAA,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC;AAC1C;;;;"}