@thi.ng/random 3.6.16 → 3.6.18

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-03T12:13:31Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/api.js

@@ -1 +0,0 @@
-export {};

package/arandom.js

@@ -1,29 +1,32 @@
 const INV_MAX = 1 / 2 ** 32;
-export class ARandom {
-    float(norm = 1) {
-        return this.int() * INV_MAX * norm;
-    }
-    probability(p) {
-        return this.float() < p;
-    }
-    norm(norm = 1) {
-        return (this.int() * INV_MAX - 0.5) * 2 * norm;
-    }
-    normMinMax(min, max) {
-        const x = this.minmax(min, max);
-        return this.float() < 0.5 ? x : -x;
-    }
-    minmax(min, max) {
-        return this.float() * (max - min) + min;
-    }
-    minmaxInt(min, max) {
-        min |= 0;
-        const range = (max | 0) - min;
-        return range ? min + (this.int() % range) : min;
-    }
-    minmaxUint(min, max) {
-        min >>>= 0;
-        const range = (max >>> 0) - min;
-        return range ? min + (this.int() % range) : min;
-    }
+class ARandom {
+  float(norm = 1) {
+    return this.int() * INV_MAX * norm;
+  }
+  probability(p) {
+    return this.float() < p;
+  }
+  norm(norm = 1) {
+    return (this.int() * INV_MAX - 0.5) * 2 * norm;
+  }
+  normMinMax(min, max) {
+    const x = this.minmax(min, max);
+    return this.float() < 0.5 ? x : -x;
+  }
+  minmax(min, max) {
+    return this.float() * (max - min) + min;
+  }
+  minmaxInt(min, max) {
+    min |= 0;
+    const range = (max | 0) - min;
+    return range ? min + this.int() % range : min;
+  }
+  minmaxUint(min, max) {
+    min >>>= 0;
+    const range = (max >>> 0) - min;
+    return range ? min + this.int() % range : min;
+  }
 }
+export {
+  ARandom
+};

package/coin.js

@@ -1,30 +1,14 @@
 import { SYSTEM } from "./system.js";
-/**
- * Returns true w/ a (theoretical) probability of 50% (obviously depending on
- * quality of given {@link IRandom}) PRNG.
- *
- * @remarks
- * Also see {@link fairCoin} and {@link IRandom.probability}.
- *
- * @param rnd -
- */
-export const coin = (rnd = SYSTEM) => rnd.float() < 0.5;
-/**
- * Similar to {@link coin}, but more strict. Calls {@link coin} in a pairwise
- * manner as long as both results are equal (and discarding results). Otherwise
- * returns result of first call.
- *
- * @remarks
- * Reference:
- * https://en.m.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_biased_coin
- *
- * @param rnd -
- */
-export const fairCoin = (rnd = SYSTEM) => {
-    let a, b;
-    do {
-        a = coin(rnd);
-        b = coin(rnd);
-    } while (a === b);
-    return a;
+const coin = (rnd = SYSTEM) => rnd.float() < 0.5;
+const fairCoin = (rnd = SYSTEM) => {
+  let a, b;
+  do {
+    a = coin(rnd);
+    b = coin(rnd);
+  } while (a === b);
+  return a;
+};
+export {
+  coin,
+  fairCoin
 };

package/constants.js

@@ -1,5 +1,13 @@
-export const DEFAULT_SEED_32 = 0xdecafbad;
-export const DEFAULT_SEED_128 = [
-    0xdecafbad, 0x2fa9d75b, 0xe41f67e3, 0x5c83ec1a,
+const DEFAULT_SEED_32 = 3737844653;
+const DEFAULT_SEED_128 = [
+  3737844653,
+  799659867,
+  3827263459,
+  1552149530
 ];
-export const DEFAULT_SEED_160 = [...DEFAULT_SEED_128, 0xf69a5c71];
+const DEFAULT_SEED_160 = [...DEFAULT_SEED_128, 4137311345];
+export {
+  DEFAULT_SEED_128,
+  DEFAULT_SEED_160,
+  DEFAULT_SEED_32
+};

package/crypto.js

@@ -1,43 +1,34 @@
 import { ARandom } from "./arandom.js";
 import { randomBytes } from "./random-bytes.js";
-/**
- * Currently browser only, a `window.crypto` backed {@link IRandom}
- * implementation. Random values are buffered to minimize overhead. Buffer size
- * is configurable via ctor.
- *
- * @remarks
- * Internally uses {@link randomBytes} to source values, which falls back to
- * using {@link SYSTEM} iff `window.crypto` is not available.
- *
- */
-export class Crypto extends ARandom {
-    buffer;
-    u32;
-    i;
-    /**
-     * @param size - buffer size in bytes (will be rounded to next multiple of 4)
-     */
-    constructor(size = 1024) {
-        super();
-        this.buffer = new Uint8Array((size + 3) & ~3);
-        this.u32 = new Uint32Array(this.buffer.buffer);
-        this.i = size >>> 2;
-    }
-    copy() {
-        return new Crypto(this.buffer.length);
-    }
-    bytes() {
-        return new Uint8Array(this.buffer.buffer);
-    }
-    int() {
-        if (this.i >= this.u32.length) {
-            randomBytes(this.buffer);
-            this.i = 0;
-        }
-        return this.u32[this.i++];
+class Crypto extends ARandom {
+  buffer;
+  u32;
+  i;
+  /**
+   * @param size - buffer size in bytes (will be rounded to next multiple of 4)
+   */
+  constructor(size = 1024) {
+    super();
+    this.buffer = new Uint8Array(size + 3 & ~3);
+    this.u32 = new Uint32Array(this.buffer.buffer);
+    this.i = size >>> 2;
+  }
+  copy() {
+    return new Crypto(this.buffer.length);
+  }
+  bytes() {
+    return new Uint8Array(this.buffer.buffer);
+  }
+  int() {
+    if (this.i >= this.u32.length) {
+      randomBytes(this.buffer);
+      this.i = 0;
     }
+    return this.u32[this.i++];
+  }
 }
-/**
- * Default instance for {@link Crypto} PRNG.
- */
-export const CRYPTO = new Crypto();
+const CRYPTO = new Crypto();
+export {
+  CRYPTO,
+  Crypto
+};

package/distributions/exponential.js

@@ -1,12 +1,5 @@
 import { SYSTEM } from "../system.js";
-/**
- * Higher order function. Returns no-arg function, yielding values in
- * exponential distribution based on given rate `lambda`.
- *
- * @remarks
- * https://en.wikipedia.org/wiki/Exponential_distribution
- *
- * @param rnd -
- * @param lambda - event interval [0,Inf)
- */
-export const exponential = (rnd = SYSTEM, lambda = 10) => lambda === 0 ? () => Infinity : () => -Math.log(1 - rnd.float(1)) / lambda;
+const exponential = (rnd = SYSTEM, lambda = 10) => lambda === 0 ? () => Infinity : () => -Math.log(1 - rnd.float(1)) / lambda;
+export {
+  exponential
+};

package/distributions/gaussian.js

@@ -1,24 +1,11 @@
 import { SYSTEM } from "../system.js";
-/**
- * Higher order function. Takes a {@link IRandom} instance and returns a no-arg
- * function which produces values with approx. normal distribution using CLT
- * (Central Limit Theorem).
- *
- * @remarks
- * The default configuration produces samples in the approx. [-0.5,0.5] range
- * with a ~12% standard deviation.
- *
- * Reference: https://en.wikipedia.org/wiki/Central_limit_theorem
- *
- * @param rnd - default `SYSTEM`
- * @param n - num samples, default 24
- * @param offset - center offset / bias, default 0
- * @param scale - scale, default 1
- */
-export const gaussian = (rnd = SYSTEM, n = 24, offset = 0, scale = 1) => () => {
-    let sum = 0;
-    let m = n;
-    while (m-- > 0)
-        sum += rnd.norm(scale);
-    return sum / n + offset;
+const gaussian = (rnd = SYSTEM, n = 24, offset = 0, scale = 1) => () => {
+  let sum = 0;
+  let m = n;
+  while (m-- > 0)
+    sum += rnd.norm(scale);
+  return sum / n + offset;
+};
+export {
+  gaussian
 };

package/distributions/geometric.js

@@ -1,20 +1,5 @@
 import { SYSTEM } from "../system.js";
-/**
- * HOF. Returns zero-arg function, yielding values in geometric distribution,
- * aka the number of independent trials required for the first occurrence of
- * success, and each trial using the given success probability `p`.
- *
- * @remarks
- * Returns 0 for p <= 0 and 1 for p >= 1.
- *
- * Reference: https://en.wikipedia.org/wiki/Geometric_distribution
- *
- * @param rnd -
- * @param p - probability (0,1]
- */
-export const geometric = (rnd = SYSTEM, p = 0.5) => p <= 0
-    ? () => Infinity
-    : p >= 1
-        ? () => 1
-        : ((p = Math.log(1 - p)),
-            () => Math.floor(Math.log(1 - rnd.float(1)) / p) + 1);
+const geometric = (rnd = SYSTEM, p = 0.5) => p <= 0 ? () => Infinity : p >= 1 ? () => 1 : (p = Math.log(1 - p), () => Math.floor(Math.log(1 - rnd.float(1)) / p) + 1);
+export {
+  geometric
+};

package/distributions/normal.js

@@ -1,31 +1,22 @@
 import { SYSTEM } from "../system.js";
-/**
- * HOF. Returns zero-arg function, yielding values with normal distribution
- * for given `bias` and standard deviation `sigma`.
- *
- * @remarks
- * Also see {@link gaussian} for alternative implementation.
- *
- * @param rnd -
- * @param bias -
- * @param sigma -
- */
-export const normal = (rnd = SYSTEM, bias = 0, sigma = 1) => {
-    let a;
-    let b;
-    let r;
-    return () => {
-        if (a != null) {
-            b = a;
-            a = null;
-        }
-        else {
-            do {
-                a = rnd.norm();
-                b = rnd.norm();
-                r = a * a + b * b;
-            } while (r > 1 || r === 0);
-        }
-        return bias + sigma * b * Math.sqrt((-2 * Math.log(r)) / r);
-    };
+const normal = (rnd = SYSTEM, bias = 0, sigma = 1) => {
+  let a;
+  let b;
+  let r;
+  return () => {
+    if (a != null) {
+      b = a;
+      a = null;
+    } else {
+      do {
+        a = rnd.norm();
+        b = rnd.norm();
+        r = a * a + b * b;
+      } while (r > 1 || r === 0);
+    }
+    return bias + sigma * b * Math.sqrt(-2 * Math.log(r) / r);
+  };
+};
+export {
+  normal
 };

package/distributions/uniform.js

@@ -1,13 +1,5 @@
 import { SYSTEM } from "../system.js";
-/**
- * HOF. Returns zero-arg function, yielding uniformly distributed values in the
- * `[min,max)` interval (default: `[0,1)`).
- *
- * @remarks
- * This function is syntax sugar for `rnd.minmax()`.
- *
- * @param rnd -
- * @param min -
- * @param max -
- */
-export const uniform = (rnd = SYSTEM, min = 0, max = 1) => () => rnd.minmax(min, max);
+const uniform = (rnd = SYSTEM, min = 0, max = 1) => () => rnd.minmax(min, max);
+export {
+  uniform
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/random",
-  "version": "3.6.16",
+  "version": "3.6.18",
   "description": "Pseudo-random number generators w/ unified API, distributions, weighted choices, ID generation",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc distributions",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,14 +35,14 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.10",
-    "@thi.ng/checks": "^3.4.10",
-    "@thi.ng/errors": "^2.4.4",
-    "@thi.ng/hex": "^2.3.22"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/hex": "^2.3.24"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/testament": "^0.4.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -155,5 +157,5 @@
       "ksuid"
     ]
   },
-  "gitHead": "04d1de79f256d7a53c6b5fd157b37f49bc88e11d\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/pick-random.js

@@ -1,19 +1,7 @@
 import { SYSTEM } from "./system.js";
-/**
- * Returns a random element from `src` using given {@link IRandom} instance
- * (default: {@link SYSTEM}). The index selection will be constrained to the
- * `[start,end)` interval (default: entire array).
- *
- * @param src -
- * @param rnd -
- * @param start -
- * @param end -
- */
-export const pickRandom = (src, rnd = SYSTEM, start = 0, end = src.length) => src[rnd.minmax(start, end) | 0];
-/**
- * Returns a random key from given `object`.
- *
- * @param obj
- * @param rnd
- */
-export const pickRandomKey = (obj, rnd = SYSTEM) => pickRandom(Object.keys(obj), rnd);
+const pickRandom = (src, rnd = SYSTEM, start = 0, end = src.length) => src[rnd.minmax(start, end) | 0];
+const pickRandomKey = (obj, rnd = SYSTEM) => pickRandom(Object.keys(obj), rnd);
+export {
+  pickRandom,
+  pickRandomKey
+};

package/random-bytes.js

@@ -1,29 +1,13 @@
 import { hasCrypto } from "@thi.ng/checks/has-crypto";
 import { SYSTEM } from "./system.js";
-/**
- * Fills given byte array with random values sourced from given {@link IRandom}
- * instance.
- *
- * @param rnd -
- * @param buf -
- * @param start -
- * @param end -
- */
-export const randomBytesFrom = (rnd, buf, start = 0, end = buf.length) => {
-    for (let i = start; i < end; i++) {
-        buf[i] = rnd.int() & 0xff;
-    }
-    return buf;
+const randomBytesFrom = (rnd, buf, start = 0, end = buf.length) => {
+  for (let i = start; i < end; i++) {
+    buf[i] = rnd.int() & 255;
+  }
+  return buf;
+};
+const randomBytes = hasCrypto() ? (buf, start = 0, end = buf.length) => (window.crypto.getRandomValues(buf.subarray(start, end)), buf) : (buf, start, end) => randomBytesFrom(SYSTEM, buf, start, end);
+export {
+  randomBytes,
+  randomBytesFrom
 };
-/**
- * Fills given byte array with random values. Wrapper for
- * `crypto.getRandomValues()` with automatic fallback to using `Math.random` if
- * platform doesn't provide global crypto instance.
- *
- * @param buf -
- * @param start -
- * @param end -
- */
-export const randomBytes = hasCrypto()
-    ? (buf, start = 0, end = buf.length) => (window.crypto.getRandomValues(buf.subarray(start, end)), buf)
-    : (buf, start, end) => randomBytesFrom(SYSTEM, buf, start, end);

package/random-id.js

@@ -1,31 +1,11 @@
 import { SYSTEM } from "./system.js";
-/**
- * Generates and returns a random string of `len` characters (default 4), plus
- * optional given `prefix` and using only provided `syms` characters (default
- * lowercase a-z).
- *
- * @remarks
- * See [thi.ng/ksuid](https://thi.ng/thi.ng/ksuid) for a more advanced and
- * collision-free approach.
- *
- * @example
- * ```ts
- * randomID()
- * "qgdt"
- *
- * randomID(8, "id-", "0123456789ABCDEF")
- * "id-94EF6E1A"
- * ```
- *
- * @param len -
- * @param prefix -
- * @param syms -
- * @param rnd -
- */
-export const randomID = (len = 4, prefix = "", syms = "abcdefghijklmnopqrstuvwxyz", rnd = SYSTEM) => {
-    const n = syms.length;
-    for (; len-- > 0;) {
-        prefix += syms[rnd.int() % n];
-    }
-    return prefix;
+const randomID = (len = 4, prefix = "", syms = "abcdefghijklmnopqrstuvwxyz", rnd = SYSTEM) => {
+  const n = syms.length;
+  for (; len-- > 0; ) {
+    prefix += syms[rnd.int() % n];
+  }
+  return prefix;
+};
+export {
+  randomID
 };

package/sfc32.js

@@ -1,36 +1,32 @@
 import { ARandom } from "./arandom.js";
 import { DEFAULT_SEED_128 } from "./constants.js";
-/**
- * Simple Fast Counter PRNG (32bit version)
- *
- * @remarks
- * References:
- * - http://pracrand.sourceforge.net/
- */
-export class SFC32 extends ARandom {
-    buffer;
-    constructor(seed = DEFAULT_SEED_128) {
-        super();
-        this.buffer = new Uint32Array(4);
-        this.seed(seed);
-    }
-    copy() {
-        return new SFC32(this.buffer);
-    }
-    bytes() {
-        return new Uint8Array(this.buffer.buffer);
-    }
-    int() {
-        const s = this.buffer;
-        const t = (((s[0] + s[1]) >>> 0) + s[3]) >>> 0;
-        s[3] = (s[3] + 1) >>> 0;
-        s[0] = s[1] ^ (s[1] >>> 9);
-        s[1] = (s[2] + (s[2] << 3)) >>> 0;
-        s[2] = (((s[2] << 21) | (s[2] >>> 11)) + t) >>> 0;
-        return t;
-    }
-    seed(seed) {
-        this.buffer.set(seed);
-        return this;
-    }
+class SFC32 extends ARandom {
+  buffer;
+  constructor(seed = DEFAULT_SEED_128) {
+    super();
+    this.buffer = new Uint32Array(4);
+    this.seed(seed);
+  }
+  copy() {
+    return new SFC32(this.buffer);
+  }
+  bytes() {
+    return new Uint8Array(this.buffer.buffer);
+  }
+  int() {
+    const s = this.buffer;
+    const t = (s[0] + s[1] >>> 0) + s[3] >>> 0;
+    s[3] = s[3] + 1 >>> 0;
+    s[0] = s[1] ^ s[1] >>> 9;
+    s[1] = s[2] + (s[2] << 3) >>> 0;
+    s[2] = (s[2] << 21 | s[2] >>> 11) + t >>> 0;
+    return t;
+  }
+  seed(seed) {
+    this.buffer.set(seed);
+    return this;
+  }
 }
+export {
+  SFC32
+};

package/smush32.js

@@ -1,32 +1,28 @@
 import { ARandom } from "./arandom.js";
 import { DEFAULT_SEED_32 } from "./constants.js";
-/**
- * @remarks
- * References:
- * -
- * - https://github.com/thi-ng/ct-head/blob/master/random.h
- * - https://gist.github.com/voidqk/d112165a26b45244a65298933c0349a4
- */
-export class Smush32 extends ARandom {
-    buffer;
-    constructor(seed = DEFAULT_SEED_32) {
-        super();
-        this.buffer = new Uint32Array([seed, 0]);
-    }
-    copy() {
-        const gen = new Smush32();
-        gen.buffer.set(this.buffer);
-        return gen;
-    }
-    seed(s) {
-        this.buffer.set([s, 0]);
-        return this;
-    }
-    int() {
-        const b = this.buffer;
-        const m = 0x5bd1e995;
-        const k = (b[1]++ * m) >>> 0;
-        const s = (b[0] = ((k ^ (k >> 24) ^ ((b[0] * m) >>> 0)) * m) >>> 0);
-        return (s ^ (s >>> 13)) >>> 0;
-    }
+class Smush32 extends ARandom {
+  buffer;
+  constructor(seed = DEFAULT_SEED_32) {
+    super();
+    this.buffer = new Uint32Array([seed, 0]);
+  }
+  copy() {
+    const gen = new Smush32();
+    gen.buffer.set(this.buffer);
+    return gen;
+  }
+  seed(s) {
+    this.buffer.set([s, 0]);
+    return this;
+  }
+  int() {
+    const b = this.buffer;
+    const m = 1540483477;
+    const k = b[1]++ * m >>> 0;
+    const s = b[0] = (k ^ k >> 24 ^ b[0] * m >>> 0) * m >>> 0;
+    return (s ^ s >>> 13) >>> 0;
+  }
 }
+export {
+  Smush32
+};

package/system.js

@@ -1,22 +1,18 @@
 import { ARandom } from "./arandom.js";
 const random = Math.random;
-/**
- * A `Math.random()` based {@link IRandom} implementation. Also @see
- * {@link SYSTEM}.
- */
-export class SystemRandom extends ARandom {
-    int() {
-        return (random() * 4294967296) /* 2**32 */ >>> 0;
-    }
-    float(norm = 1) {
-        return random() * norm;
-    }
-    norm(norm = 1) {
-        return (random() - 0.5) * 2 * norm;
-    }
+class SystemRandom extends ARandom {
+  int() {
+    return random() * 4294967296 >>> 0;
+  }
+  float(norm = 1) {
+    return random() * norm;
+  }
+  norm(norm = 1) {
+    return (random() - 0.5) * 2 * norm;
+  }
 }
-/**
- * Used as default PRNG throughout most other thi.ng projects, though usually is
- * configurable.
- */
-export const SYSTEM = new SystemRandom();
+const SYSTEM = new SystemRandom();
+export {
+  SYSTEM,
+  SystemRandom
+};

package/unique-indices.js

@@ -1,67 +1,27 @@
 import { assert } from "@thi.ng/errors/assert";
 import { SYSTEM } from "./system.js";
-/**
- * Attempts to draw `k` unique values from given zero-arg function `fn`
- * (presumably a PRNG of sorts) and adds them to `existing` array of unique
- * samples (or creates a new one). Returns the array. Gives up after
- * `maxTrials`.
- *
- * @remarks
- * Internally uses `Array.includes()` to check for duplicates.
- *
- * @param k -
- * @param fn -
- * @param existing -
- * @param maxTrials -
- */
-export const uniqueValuesFrom = (k, fn, existing = [], maxTrials = 100) => {
-    let n = 0;
-    while (n < k) {
-        let i;
-        let trials = maxTrials;
-        do {
-            i = fn();
-        } while (existing.includes(i) && --trials > 0);
-        if (trials <= 0)
-            break;
-        existing.push(i);
-        n++;
-    }
-    return existing;
+const uniqueValuesFrom = (k, fn, existing = [], maxTrials = 100) => {
+  let n = 0;
+  while (n < k) {
+    let i;
+    let trials = maxTrials;
+    do {
+      i = fn();
+    } while (existing.includes(i) && --trials > 0);
+    if (trials <= 0)
+      break;
+    existing.push(i);
+    n++;
+  }
+  return existing;
 };
-/**
- * Similar to (and based on) {@link uniqueValuesFrom}. Attempts to add `k`
- * unique integer indices in the `[0, max)` interval to the (optional) array of
- * pre-`existing` indices (which will never be picked again and new indices will
- * be added to). Returns updated array.
- *
- * @remarks
- * Candidates are drawn from the provided `rnd` {@link IRandom} (default:
- * {@link SYSTEM}) and only `maxTrials` are attempted before giving up.
- *
- * @param k -
- * @param max -
- * @param existing -
- * @param maxTrials -
- * @param rnd -
- */
-export const uniqueIndices = (k, max, existing, maxTrials = max, rnd = SYSTEM) => {
-    assert(k >= 0 && k <= max, `k must be in [0, ${max}] interval`);
-    return uniqueValuesFrom(k, () => rnd.int() % max, existing, maxTrials);
+const uniqueIndices = (k, max, existing, maxTrials = max, rnd = SYSTEM) => {
+  assert(k >= 0 && k <= max, `k must be in [0, ${max}] interval`);
+  return uniqueValuesFrom(k, () => rnd.int() % max, existing, maxTrials);
+};
+const pickRandomUnique = (k, src, existing, maxTrials = 100, rnd = SYSTEM) => uniqueValuesFrom(k, () => src[rnd.int() % src.length], existing, maxTrials);
+export {
+  pickRandomUnique,
+  uniqueIndices,
+  uniqueValuesFrom
 };
-/**
- * Combination of {@link pickRandom} and {@link uniqueValuesFrom}. Picks up to
- * `k` unique values from `src` array (each with `maxTrials`) and adds them to
- * given `existing` array (or creates a new one by default) and returns it. Uses
- * given `rnd` instance (default: {@link SYSTEM} to randomly select candidates.
- *
- * @remarks
- * Internally uses `Array.includes()` to check for duplicates.
- *
- * @param k
- * @param src
- * @param existing
- * @param maxTrials
- * @param rnd
- */
-export const pickRandomUnique = (k, src, existing, maxTrials = 100, rnd = SYSTEM) => uniqueValuesFrom(k, () => src[rnd.int() % src.length], existing, maxTrials);

package/uuid.js

@@ -1,27 +1,15 @@
 import { uuid as $uuid } from "@thi.ng/hex";
 import { randomBytes, randomBytesFrom } from "./random-bytes.js";
-/**
- * Depending on if `rnd` is given, uses {@link randomBytesFrom} or
- * {@link randomBytes} to fill given (optional) byte array with a new UUIDv4.
- * Creates new Uint8Array if none given.
- *
- * @param buf -
- * @param rnd -
- */
-export const uuidv4Bytes = (buf, rnd) => {
-    buf = buf || new Uint8Array(16);
-    buf = rnd ? randomBytesFrom(rnd, buf) : randomBytes(buf);
-    buf[6] = 0x40 | (buf[6] & 0x0f);
-    buf[8] = 0x80 | (buf[8] & 0x3f);
-    return buf;
+const uuidv4Bytes = (buf, rnd) => {
+  buf = buf || new Uint8Array(16);
+  buf = rnd ? randomBytesFrom(rnd, buf) : randomBytes(buf);
+  buf[6] = 64 | buf[6] & 15;
+  buf[8] = 128 | buf[8] & 63;
+  return buf;
 };
-/** @internal */
 const __buf = new Uint8Array(16);
-/**
- * Returns a UUID string, either from given byte array, or if omitted, using a
- * new UUID v4 produced by {@link uuidv4Bytes}.
- *
- * @param id - byte array
- * @param i - start index
- */
-export const uuid = (id, i = 0) => $uuid(id || uuidv4Bytes(__buf), i);
+const uuid = (id, i = 0) => $uuid(id || uuidv4Bytes(__buf), i);
+export {
+  uuid,
+  uuidv4Bytes
+};

package/weighted-random.js

@@ -1,54 +1,32 @@
 import { assert } from "@thi.ng/errors/assert";
 import { SYSTEM } from "./system.js";
-/**
- * Returns a no-arg function which produces a random choice of given weighted
- * `choices` and using given {@link IRandom} instance (default {@link SYSTEM}.
- * If `weights` are given, it must be the same size as `choices` (else missing
- * weights will be assumed zero). If omitted entirely, each choice will have
- * same probability.
- *
- * @remarks
- * Throws an error if the `choices` array is empty (requires at least 1 item).
- * If the total sum of `weights` is <= 0 a warning is printed to the console and
- * the resulting function will only ever return the first `choice`.
- *
- * Based on:
- * https://www.electricmonk.nl/log/2009/12/23/weighted-random-distribution/
- *
- * @param choices -
- * @param weights - optional weights
- */
-export const weightedRandom = (choices, weights, rnd = SYSTEM) => {
-    const n = choices.length;
-    assert(n > 0, "no choices given");
-    const opts = weights
-        ? choices
-            .map((x, i) => [weights[i] || 0, x])
-            .sort((a, b) => b[0] - a[0])
-        : choices.map((x) => [1, x]);
-    const total = opts.reduce((acc, o) => acc + o[0], 0);
-    total <= 0 && console.warn("total weights <= 0");
-    return () => {
-        const r = rnd.float(total);
-        let sum = total;
-        for (let i = 0; i < n; i++) {
-            sum -= opts[i][0];
-            if (sum <= r) {
-                return opts[i][1];
-            }
-        }
-        return undefined;
-    };
+const weightedRandom = (choices, weights, rnd = SYSTEM) => {
+  const n = choices.length;
+  assert(n > 0, "no choices given");
+  const opts = weights ? choices.map((x, i) => [weights[i] || 0, x]).sort((a, b) => b[0] - a[0]) : choices.map((x) => [1, x]);
+  const total = opts.reduce((acc, o) => acc + o[0], 0);
+  total <= 0 && console.warn("total weights <= 0");
+  return () => {
+    const r = rnd.float(total);
+    let sum = total;
+    for (let i = 0; i < n; i++) {
+      sum -= opts[i][0];
+      if (sum <= r) {
+        return opts[i][1];
+      }
+    }
+    return void 0;
+  };
 };
-/**
- * Alt version of {@link weightedRandom}, accepting an object of weights
- * instead. The returned function will return keys of given `choices` object,
- * taking into account the weights given for each key.
- *
- * @param choices
- * @param rnd
- */
-export const weightedRandomKey = (choices, rnd = SYSTEM) => {
-    const keys = Object.keys(choices);
-    return weightedRandom(keys, keys.map((x) => choices[x]), rnd);
+const weightedRandomKey = (choices, rnd = SYSTEM) => {
+  const keys = Object.keys(choices);
+  return weightedRandom(
+    keys,
+    keys.map((x) => choices[x]),
+    rnd
+  );
+};
+export {
+  weightedRandom,
+  weightedRandomKey
 };

package/xorshift128.js

@@ -1,35 +1,34 @@
 import { ARandom } from "./arandom.js";
 import { DEFAULT_SEED_128 } from "./constants.js";
-/**
- * @remarks
- * Reference: https://en.wikipedia.org/wiki/Xorshift
- */
-export class XorShift128 extends ARandom {
-    buffer;
-    constructor(seed = DEFAULT_SEED_128) {
-        super();
-        this.buffer = new Uint32Array(4);
-        this.seed(seed);
-    }
-    copy() {
-        return new XorShift128(this.buffer);
-    }
-    bytes() {
-        return new Uint8Array(this.buffer.buffer);
-    }
-    seed(seed) {
-        this.buffer.set(seed);
-        return this;
-    }
-    int() {
-        const s = this.buffer;
-        let t = s[3];
-        let w;
-        t ^= t << 11;
-        t ^= t >>> 8;
-        s[3] = s[2];
-        s[2] = s[1];
-        w = s[1] = s[0];
-        return (s[0] = (t ^ w ^ (w >>> 19)) >>> 0);
-    }
+class XorShift128 extends ARandom {
+  buffer;
+  constructor(seed = DEFAULT_SEED_128) {
+    super();
+    this.buffer = new Uint32Array(4);
+    this.seed(seed);
+  }
+  copy() {
+    return new XorShift128(this.buffer);
+  }
+  bytes() {
+    return new Uint8Array(this.buffer.buffer);
+  }
+  seed(seed) {
+    this.buffer.set(seed);
+    return this;
+  }
+  int() {
+    const s = this.buffer;
+    let t = s[3];
+    let w;
+    t ^= t << 11;
+    t ^= t >>> 8;
+    s[3] = s[2];
+    s[2] = s[1];
+    w = s[1] = s[0];
+    return s[0] = (t ^ w ^ w >>> 19) >>> 0;
+  }
 }
+export {
+  XorShift128
+};

package/xorwow.js

@@ -1,38 +1,37 @@
 import { ARandom } from "./arandom.js";
 import { DEFAULT_SEED_160 } from "./constants.js";
-/**
- * @remarks
- * Reference: https://en.wikipedia.org/wiki/Xorshift#xorwow
- */
-export class XorWow extends ARandom {
-    buffer;
-    constructor(seed = DEFAULT_SEED_160) {
-        super();
-        this.buffer = new Uint32Array(5);
-        this.seed(seed);
-    }
-    copy() {
-        return new XorWow(this.buffer);
-    }
-    seed(seed) {
-        this.buffer.set(seed);
-        return this;
-    }
-    bytes() {
-        return new Uint8Array(this.buffer.buffer);
-    }
-    int() {
-        const s = this.buffer;
-        let t = s[3];
-        let w;
-        t ^= t >>> 2;
-        t ^= t << 1;
-        s[3] = s[2];
-        s[2] = s[1];
-        w = s[1] = s[0];
-        t ^= w;
-        t ^= w << 4;
-        s[0] = t;
-        return (t + (s[4] += 0x587c5)) >>> 0;
-    }
+class XorWow extends ARandom {
+  buffer;
+  constructor(seed = DEFAULT_SEED_160) {
+    super();
+    this.buffer = new Uint32Array(5);
+    this.seed(seed);
+  }
+  copy() {
+    return new XorWow(this.buffer);
+  }
+  seed(seed) {
+    this.buffer.set(seed);
+    return this;
+  }
+  bytes() {
+    return new Uint8Array(this.buffer.buffer);
+  }
+  int() {
+    const s = this.buffer;
+    let t = s[3];
+    let w;
+    t ^= t >>> 2;
+    t ^= t << 1;
+    s[3] = s[2];
+    s[2] = s[1];
+    w = s[1] = s[0];
+    t ^= w;
+    t ^= w << 4;
+    s[0] = t;
+    return t + (s[4] += 362437) >>> 0;
+  }
 }
+export {
+  XorWow
+};

package/xoshiro128.js

@@ -1,40 +1,37 @@
 import { ARandom } from "./arandom.js";
 import { DEFAULT_SEED_128 } from "./constants.js";
-/**
- * @remarks
- * References:
- * - http://prng.di.unimi.it/
- * - http://prng.di.unimi.it/xoshiro128plusplus.c
- */
-export class Xoshiro128 extends ARandom {
-    buffer;
-    constructor(seed = DEFAULT_SEED_128) {
-        super();
-        this.buffer = new Uint32Array(4);
-        this.seed(seed);
-    }
-    copy() {
-        return new Xoshiro128(this.buffer);
-    }
-    bytes() {
-        return new Uint8Array(this.buffer.buffer);
-    }
-    seed(seed) {
-        this.buffer.set(seed);
-        return this;
-    }
-    int() {
-        const s = this.buffer;
-        let t = s[0] + s[3];
-        const res = ((t << 7) | (t >>> 25)) >>> 0;
-        t = s[1] << 9;
-        s[2] ^= s[0];
-        s[3] ^= s[1];
-        s[1] ^= s[2];
-        s[0] ^= s[3];
-        s[2] ^= t;
-        t = s[3];
-        s[3] = ((t << 11) | (t >>> 21)) >>> 0;
-        return res;
-    }
+class Xoshiro128 extends ARandom {
+  buffer;
+  constructor(seed = DEFAULT_SEED_128) {
+    super();
+    this.buffer = new Uint32Array(4);
+    this.seed(seed);
+  }
+  copy() {
+    return new Xoshiro128(this.buffer);
+  }
+  bytes() {
+    return new Uint8Array(this.buffer.buffer);
+  }
+  seed(seed) {
+    this.buffer.set(seed);
+    return this;
+  }
+  int() {
+    const s = this.buffer;
+    let t = s[0] + s[3];
+    const res = (t << 7 | t >>> 25) >>> 0;
+    t = s[1] << 9;
+    s[2] ^= s[0];
+    s[3] ^= s[1];
+    s[1] ^= s[2];
+    s[0] ^= s[3];
+    s[2] ^= t;
+    t = s[3];
+    s[3] = (t << 11 | t >>> 21) >>> 0;
+    return res;
+  }
 }
+export {
+  Xoshiro128
+};

package/xsadd.js

@@ -1,44 +1,43 @@
 import { ARandom } from "./arandom.js";
 import { DEFAULT_SEED_32 } from "./constants.js";
-/**
- * @remarks
- * Reference: https://github.com/MersenneTwister-Lab/XSadd/blob/develop/xsadd.h
- */
-export class XsAdd extends ARandom {
-    buffer;
-    constructor(seed = DEFAULT_SEED_32) {
-        super();
-        this.buffer = new Uint32Array(4);
-        this.seed(seed);
-    }
-    bytes() {
-        return new Uint8Array(this.buffer.buffer);
-    }
-    copy() {
-        const gen = new XsAdd();
-        gen.buffer.set(this.buffer);
-        return gen;
-    }
-    seed(seed) {
-        const s = this.buffer;
-        s.set([seed, 0, 0, 0]);
-        for (let j = 0, i = 1; i < 8; j = i++) {
-            let x = (s[j & 3] ^ (s[j & 3] >>> 30)) >>> 0;
-            x = (0x8965 * x + (((0x6c07 * x) & 0xffff) << 16)) >>> 0;
-            s[i & 3] ^= (i + x) >>> 0;
-        }
-        return this;
-    }
-    int() {
-        const s = this.buffer;
-        let t = s[0];
-        t ^= t << 15;
-        t ^= t >>> 18;
-        t ^= s[3] << 11;
-        s[0] = s[1];
-        s[1] = s[2];
-        s[2] = s[3];
-        s[3] = t;
-        return (t + s[2]) >>> 0;
+class XsAdd extends ARandom {
+  buffer;
+  constructor(seed = DEFAULT_SEED_32) {
+    super();
+    this.buffer = new Uint32Array(4);
+    this.seed(seed);
+  }
+  bytes() {
+    return new Uint8Array(this.buffer.buffer);
+  }
+  copy() {
+    const gen = new XsAdd();
+    gen.buffer.set(this.buffer);
+    return gen;
+  }
+  seed(seed) {
+    const s = this.buffer;
+    s.set([seed, 0, 0, 0]);
+    for (let j = 0, i = 1; i < 8; j = i++) {
+      let x = (s[j & 3] ^ s[j & 3] >>> 30) >>> 0;
+      x = 35173 * x + ((27655 * x & 65535) << 16) >>> 0;
+      s[i & 3] ^= i + x >>> 0;
     }
+    return this;
+  }
+  int() {
+    const s = this.buffer;
+    let t = s[0];
+    t ^= t << 15;
+    t ^= t >>> 18;
+    t ^= s[3] << 11;
+    s[0] = s[1];
+    s[1] = s[2];
+    s[2] = s[3];
+    s[3] = t;
+    return t + s[2] >>> 0;
+  }
 }
+export {
+  XsAdd
+};