@fncts/base 0.0.1

package/_src/util/PCGRandom.ts

@@ -0,0 +1,191 @@
+/* eslint-disable no-param-reassign */
+
+/*
+ * Copyright 2014 Thom Chiovoloni, released under the MIT license.
+ *
+ * A random number generator based on the basic implementation of the PCG algorithm,
+ * as described here: http://www.pcg-random.org/
+ *
+ * Adapted for TypeScript from Thom's original code at https://github.com/thomcc/pcg-random
+ *
+ * forked from https://github.com/frptools
+ */
+
+export function isNothing<T>(value: T | null | undefined) {
+  return value === void 0 || value === null;
+}
+
+const defaultIncHi = 0x14057b7e;
+const defaultIncLo = 0xf767814f;
+const MUL_HI       = 0x5851f42d >>> 0;
+const MUL_LO       = 0x4c957f2d >>> 0;
+const BIT_53       = 9007199254740992.0;
+const BIT_27       = 134217728.0;
+
+export type PCGRandomState = [number, number, number, number];
+export type OptionalNumber = number | null | undefined;
+
+/**
+ * PCG is a family of simple fast space-efficient statistically good algorithms for random number generation. Unlike
+ * many general-purpose RNGs, they are also hard to predict.
+ */
+export class PCGRandom {
+  private _state: Int32Array;
+
+  /**
+   * Creates an instance of PCGRandom.
+   *
+   * @param {any} seed - The low 32 bits of the seed (0 is used for high 32 bits).
+   *
+   * @memberOf PCGRandom
+   */
+  constructor(seed?: OptionalNumber);
+  /**
+   * Creates an instance of PCGRandom.
+   *
+   * @param {any} seedHi - The high 32 bits of the seed.
+   * @param {any} seedLo - The how 32 bits of the seed.
+   * @param {any} inc - The low 32 bits of the incrementer (0 is used for high 32 bits).
+   *
+   * @memberOf PCGRandom
+   */
+  constructor(seedHi: OptionalNumber, seedLo: OptionalNumber, inc?: OptionalNumber);
+  /**
+   * Creates an instance of PCGRandom.
+   *
+   * @param {any} seedHi - The high 32 bits of the seed.
+   * @param {any} seedLo - The how 32 bits of the seed.
+   * @param {any} incHi - The high 32 bits of the incrementer.
+   * @param {any} incLo - The how 32 bits of the incrementer.
+   *
+   * @memberOf PCGRandom
+   */
+  constructor(seedHi: OptionalNumber, seedLo: OptionalNumber, incHi: OptionalNumber, incLo: OptionalNumber);
+  constructor(seedHi?: OptionalNumber, seedLo?: OptionalNumber, incHi?: OptionalNumber, incLo?: OptionalNumber) {
+    if (isNothing(seedLo) && isNothing(seedHi)) {
+      seedLo = (Math.random() * 0xffffffff) >>> 0;
+      seedHi = 0;
+    } else if (isNothing(seedLo)) {
+      seedLo = seedHi;
+      seedHi = 0;
+    }
+    if (isNothing(incLo) && isNothing(incHi)) {
+      // @ts-expect-error
+      incLo = this._state ? this._state[3] : defaultIncLo;
+      // @ts-expect-error
+      incHi = this._state ? this._state[2] : defaultIncHi;
+    } else if (isNothing(incLo)) {
+      incLo = <number>incHi;
+      incHi = 0;
+    }
+
+    this._state = new Int32Array([0, 0, (<number>incHi) >>> 0, ((incLo || 0) | 1) >>> 0]);
+    this._next();
+    add64(this._state, this._state[0]!, this._state[1]!, (<number>seedHi) >>> 0, (<number>seedLo) >>> 0);
+    this._next();
+    return this;
+  }
+
+  /**
+   * @returns A copy of the internal state of this random number generator as a JavaScript Array
+   */
+  getState(): PCGRandomState {
+    return [this._state[0]!, this._state[1]!, this._state[2]!, this._state[3]!];
+  }
+
+  /**
+   * Restore state previously retrieved using getState()
+   */
+  setState(state: PCGRandomState) {
+    this._state[0] = state[0];
+    this._state[1] = state[1];
+    this._state[2] = state[2];
+    this._state[3] = state[3] | 1;
+  }
+
+  private _next() {
+    // save current state (what we'll use for this number)
+    const oldHi = this._state[0]! >>> 0;
+    const oldLo = this._state[1]! >>> 0;
+
+    // churn LCG.
+    mul64(this._state, oldHi, oldLo, MUL_HI, MUL_LO);
+    add64(this._state, this._state[0]!, this._state[1]!, this._state[2]!, this._state[3]!);
+
+    // get least sig. 32 bits of ((oldstate >> 18) ^ oldstate) >> 27
+    let xsHi         = oldHi >>> 18;
+    let xsLo         = ((oldLo >>> 18) | (oldHi << 14)) >>> 0;
+    xsHi             = (xsHi ^ oldHi) >>> 0;
+    xsLo             = (xsLo ^ oldLo) >>> 0;
+    const xorshifted = ((xsLo >>> 27) | (xsHi << 5)) >>> 0;
+    // rotate xorshifted right a random amount, based on the most sig. 5 bits
+    // bits of the old state.
+    const rot  = oldHi >>> 27;
+    const rot2 = ((-rot >>> 0) & 31) >>> 0;
+    return ((xorshifted >>> rot) | (xorshifted << rot2)) >>> 0;
+  }
+
+  /// Get a uniformly distributed 32 bit integer between [0, max).
+  integer(max: number) {
+    if (!max) {
+      return this._next();
+    }
+    max = max >>> 0;
+    if ((max & (max - 1)) === 0) {
+      return this._next() & (max - 1); // fast path for power of 2
+    }
+
+    let num    = 0;
+    const skew = (-max >>> 0) % max >>> 0;
+    for (num = this._next(); num < skew; num = this._next()) {
+      // this loop will rarely execute more than twice,
+      // and is intentionally empty
+    }
+    return num % max;
+  }
+
+  /// Get a uniformly distributed IEEE-754 double between 0.0 and 1.0, with
+  /// 53 bits of precision (every bit of the mantissa is randomized).
+  number() {
+    const hi = (this._next() & 0x03ffffff) * 1.0;
+    const lo = (this._next() & 0x07ffffff) * 1.0;
+    return (hi * BIT_27 + lo) / BIT_53;
+  }
+}
+
+function mul64(out: Int32Array, aHi: number, aLo: number, bHi: number, bLo: number): void {
+  let c1 = ((aLo >>> 16) * (bLo & 0xffff)) >>> 0;
+  let c0 = ((aLo & 0xffff) * (bLo >>> 16)) >>> 0;
+
+  let lo = ((aLo & 0xffff) * (bLo & 0xffff)) >>> 0;
+  let hi = ((aLo >>> 16) * (bLo >>> 16) + ((c0 >>> 16) + (c1 >>> 16))) >>> 0;
+
+  c0 = (c0 << 16) >>> 0;
+  lo = (lo + c0) >>> 0;
+  if (lo >>> 0 < c0 >>> 0) {
+    hi = (hi + 1) >>> 0;
+  }
+
+  c1 = (c1 << 16) >>> 0;
+  lo = (lo + c1) >>> 0;
+  if (lo >>> 0 < c1 >>> 0) {
+    hi = (hi + 1) >>> 0;
+  }
+
+  hi = (hi + Math.imul(aLo, bHi)) >>> 0;
+  hi = (hi + Math.imul(aHi, bLo)) >>> 0;
+
+  out[0] = hi;
+  out[1] = lo;
+}
+
+// add two 64 bit numbers (given in parts), and store the result in `out`.
+function add64(out: Int32Array, aHi: number, aLo: number, bHi: number, bLo: number): void {
+  let hi   = (aHi + bHi) >>> 0;
+  const lo = (aLo + bLo) >>> 0;
+  if (lo >>> 0 < aLo >>> 0) {
+    hi = (hi + 1) | 0;
+  }
+  out[0] = hi;
+  out[1] = lo;
+}

package/_src/util/assert.ts

@@ -0,0 +1,11 @@
+export class AssertionError extends Error {
+  constructor(readonly message: string) {
+    super(`Assertion Failed: ${message}`);
+  }
+}
+
+export function assert(assertion: boolean, message: string) {
+  if (!assertion) {
+    throw new AssertionError(message);
+  }
+}

package/_src/util/pattern.ts

@@ -0,0 +1,35 @@
+export const pattern_: <N extends string>(
+  n: N,
+) => {
+  <X extends { [k in N]: string }, K extends { [k in X[N]]: (_: Extract<X, { [_tag in N]: k }>) => any }>(
+    m: X,
+    _: K,
+  ): ReturnType<K[keyof K]>;
+  <X extends { [k in N]: string }, K extends { [k in X[N]]?: (_: Extract<X, { [_tag in N]: k }>) => any }, H>(
+    m: X,
+    _: K,
+    __: (_: Exclude<X, { _tag: keyof K }>) => H,
+  ): { [k in keyof K]: ReturnType<NonNullable<K[k]>> }[keyof K] | H;
+} = (n) =>
+  ((m: any, _: any, d: any) => {
+    return (_[m[n]] ? _[m[n]](m) : d(m)) as any;
+  }) as any;
+
+export const pattern: <N extends string>(
+  n: N,
+) => {
+  <X extends { [k in N]: string }, K extends { [k in X[N]]: (_: Extract<X, { [_tag in N]: k }>) => any }>(_: K): (
+    m: X,
+  ) => ReturnType<K[keyof K]>;
+  <X extends { [k in N]: string }, K extends { [k in X[N]]?: (_: Extract<X, { [_tag in N]: k }>) => any }, H>(
+    _: K,
+    __: (_: Exclude<X, { _tag: keyof K }>) => H,
+  ): (m: X) => { [k in keyof K]: ReturnType<NonNullable<K[k]>> }[keyof K] | H;
+} = (n) =>
+  ((_: any, d: any) => (m: any) => {
+    return (_[m[n]] ? _[m[n]](m) : d(m)) as any;
+  }) as any;
+
+export const matchTag_ = pattern_("_tag");
+
+export const matchTag = pattern("_tag");

package/_src/util/predicates.ts

@@ -0,0 +1,144 @@
+import type { Constructor, Primitive } from "@fncts/base/types";
+
+export function isDefined<A>(value: A | undefined): value is A {
+  return value !== undefined;
+}
+
+export function isUndefined<A>(value: A | undefined): value is undefined {
+  return value === undefined;
+}
+
+export function isNonNull<A>(value: A | null): value is A {
+  return value !== null;
+}
+
+export function isNull<A>(value: A | null): value is null {
+  return value === null;
+}
+
+export function isNonNullable<A>(value: A | null | undefined): value is A {
+  return value != null;
+}
+
+export function isNullable<A>(value: A | null | undefined): value is null | undefined {
+  return value == null;
+}
+
+export function isIterable<A>(value: unknown): value is Iterable<A> {
+  return isObject(value) && Symbol.iterator in value;
+}
+
+export function isArray<A>(value: A | Array<A> | ReadonlyArray<A>): value is Array<A>;
+export function isArray<A>(value: unknown): value is Array<A>;
+export function isArray(value: unknown): boolean {
+  return Array.isArray(value);
+}
+
+export function isObject<A extends Function>(value: A): false;
+export function isObject(value: unknown): value is object & Record<PropertyKey, any>;
+export function isObject<A>(value: A | Primitive): value is A & Record<PropertyKey, unknown>;
+export function isObject<A>(value: A | Primitive): boolean {
+  return typeof value === "object" && value !== null;
+}
+
+export function hasTypeId<X extends symbol>(
+  value: unknown,
+  typeId: X,
+): value is { readonly _typeId: X } & Record<PropertyKey, unknown> {
+  return isObject(value) && "_typeId" in value && value["_typeId"] === typeId;
+}
+
+export function isFunction(value: unknown): value is Function {
+  return typeof value === "function";
+}
+
+export function isBoolean(value: unknown): value is boolean {
+  return typeof value === "boolean";
+}
+
+export function isString(value: unknown): value is string {
+  return typeof value === "string";
+}
+
+export function isNumber(value: unknown): value is number {
+  return typeof value === "number";
+}
+
+export function isByte(n: unknown): n is number {
+  return typeof n === "number" && Number.isInteger(n) && n >= 0 && n <= 255;
+}
+
+export function isSymbol(value: unknown): value is symbol {
+  return typeof value === "symbol";
+}
+
+export function isPlain(value: unknown): value is object {
+  return isObject(value) && value.constructor === Object;
+}
+
+export function isInstanceOf<C extends Constructor<A>, A>(type: C): (value: unknown) => value is A {
+  return (value): value is A => value instanceof type;
+}
+
+export function isMap(u: unknown): u is Map<unknown, unknown> {
+  return u instanceof Map;
+}
+
+export function isWeakMap(u: unknown): u is WeakMap<object, unknown> {
+  return u instanceof WeakMap;
+}
+
+export function isPromise(u: unknown): u is Promise<unknown> {
+  return u instanceof Promise;
+}
+
+export function isSet(u: unknown): u is Set<unknown> {
+  return u instanceof Set;
+}
+
+export function isWeakSet(u: unknown): u is WeakSet<object> {
+  return u instanceof WeakSet;
+}
+
+export function isDate(u: unknown): u is Date {
+  return u instanceof Date;
+}
+
+export type TypedArray =
+  | BigInt64Array
+  | BigUint64Array
+  | Float64Array
+  | Float32Array
+  | Int32Array
+  | Int16Array
+  | Int8Array
+  | Uint32Array
+  | Uint16Array
+  | Uint8Array
+  | Uint8ClampedArray;
+
+const TypedArrayConstructor = Object.getPrototypeOf(Uint8Array);
+
+export function isTypedArray(u: unknown): u is TypedArray {
+  return u instanceof TypedArrayConstructor;
+}
+
+export function isRegExp(u: unknown): u is RegExp {
+  return isObject(u) && (getTag(u) === "[object RegExp]" || u instanceof RegExp);
+}
+
+export function isAnyArrayBuffer(u: unknown): u is ArrayBuffer | SharedArrayBuffer {
+  return u instanceof ArrayBuffer || u instanceof SharedArrayBuffer;
+}
+
+export function isArrayBuffer(u: unknown): u is ArrayBuffer {
+  return u instanceof ArrayBuffer;
+}
+
+export function isDataView(u: unknown): u is DataView {
+  return u instanceof DataView;
+}
+
+function getTag(value: object) {
+  return Object.prototype.toString.call(value);
+}

package/_src/util/rand/Random.ts

@@ -0,0 +1,100 @@
+import type RandomGenerator from "@fncts/base/util/rand/generator/RandomGenerator";
+
+import { uniformArrayIntDistribution } from "@fncts/base/util/rand/distribution/UniformArrayIntDistribution";
+import { uniformBigIntDistribution } from "@fncts/base/util/rand/distribution/UniformBigIntDistribution";
+import { uniformIntDistribution } from "@fncts/base/util/rand/distribution/UniformIntDistribution";
+
+/**
+ * Wrapper around an instance of a `pure-rand`'s random number generator
+ * offering a simpler interface to deal with random with impure patterns
+ *
+ * @public
+ */
+export class MutableRandom {
+  private static MIN_INT: number     = 0x80000000 | 0;
+  private static MAX_INT: number     = 0x7fffffff | 0;
+  private static DBL_FACTOR: number  = Math.pow(2, 27);
+  private static DBL_DIVISOR: number = Math.pow(2, -53);
+
+  /**
+   * Create a mutable random number generator
+   * @param internalRng - Immutable random generator from pure-rand library
+   */
+  constructor(private internalRng: RandomGenerator) {}
+
+  /**
+   * Clone the random number generator
+   */
+  clone(): MutableRandom {
+    return new MutableRandom(this.internalRng);
+  }
+
+  private uniformIn(rangeMin: number, rangeMax: number): number {
+    return uniformIntDistribution(rangeMin, rangeMax, this.internalRng);
+  }
+
+  /**
+   * Generate an integer having `bits` random bits
+   * @param bits - Number of bits to generate
+   */
+  next(bits: number): number {
+    return this.uniformIn(0, (1 << bits) - 1);
+  }
+
+  /**
+   * Generate a random boolean
+   */
+
+  nextBoolean(): boolean {
+    return this.uniformIn(0, 1) === 1;
+  }
+
+  /**
+   * Generate a random integer (32 bits)
+   */
+  nextInt(): number;
+
+  /**
+   * Generate a random integer between min (included) and max (included)
+   * @param min - Minimal integer value
+   * @param max - Maximal integer value
+   */
+  nextInt(min: number, max: number): number;
+  nextInt(min?: number, max?: number): number {
+    return this.uniformIn(min == null ? MutableRandom.MIN_INT : min, max == null ? MutableRandom.MAX_INT : max);
+  }
+
+  /**
+   * Generate a random bigint between min (included) and max (included)
+   * @param min - Minimal bigint value
+   * @param max - Maximal bigint value
+   */
+  nextBigInt(min: bigint, max: bigint): bigint {
+    return uniformBigIntDistribution(min, max, this.internalRng);
+  }
+
+  /**
+   * Generate a random ArrayInt between min (included) and max (included)
+   * @param min - Minimal ArrayInt value
+   * @param max - Maximal ArrayInt value
+   */
+  nextArrayInt(
+    min: { sign: 1 | -1; data: number[] },
+    max: { sign: 1 | -1; data: number[] },
+  ): { sign: 1 | -1; data: number[] } {
+    return uniformArrayIntDistribution(min, max, this.internalRng);
+  }
+
+  /**
+   * Generate a random floating point number between 0.0 (included) and 1.0 (excluded)
+   */
+  nextDouble(): number {
+    const a = this.next(26);
+    const b = this.next(27);
+    return (a * MutableRandom.DBL_FACTOR + b) * MutableRandom.DBL_DIVISOR;
+  }
+
+  setSeed(seed: number): void {
+    this.internalRng.setSeed(seed);
+  }
+}

package/_src/util/rand/distribution/Distribution.ts

@@ -0,0 +1,10 @@
+import type { RandomGenerator } from "@fncts/base/util/rand/generator/RandomGenerator";
+
+/**
+ * Generate random value based on a given RandomGenerator.
+ * Return the generated value and an offsetted version of the RandomGenerator.
+ * @public
+ */
+type Distribution<T> = (rng: RandomGenerator) => T;
+export default Distribution;
+export { Distribution };

package/_src/util/rand/distribution/UniformArrayIntDistribution.ts

@@ -0,0 +1,49 @@
+import type Distribution from "@fncts/base/util/rand/distribution/Distribution";
+import type { ArrayInt } from "@fncts/base/util/rand/distribution/internals/ArrayInt";
+import type RandomGenerator from "@fncts/base/util/rand/generator/RandomGenerator";
+
+import {
+  addArrayIntToNew,
+  addOneToPositiveArrayInt,
+  substractArrayIntToNew,
+  trimArrayIntInplace,
+} from "@fncts/base/util/rand/distribution/internals/ArrayInt";
+import { uniformArrayIntDistributionInternal } from "@fncts/base/util/rand/distribution/internals/UniformArrayIntDistributionInternal";
+
+/** @internal */
+function uniformArrayIntInternal(from: ArrayInt, to: ArrayInt, rng: RandomGenerator): ArrayInt {
+  const rangeSize         = trimArrayIntInplace(addOneToPositiveArrayInt(substractArrayIntToNew(to, from)));
+  const emptyArrayIntData = rangeSize.data.slice(0);
+  const g                 = uniformArrayIntDistributionInternal(emptyArrayIntData, rangeSize.data, rng);
+  return trimArrayIntInplace(addArrayIntToNew({ sign: 1, data: g }, from));
+}
+
+/**
+ * Uniformly generate random ArrayInt values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ *
+ * @public
+ */
+function uniformArrayIntDistribution(from: ArrayInt, to: ArrayInt): Distribution<ArrayInt>;
+/**
+ * Uniformly generate random ArrayInt values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ * @param rng - Instance of RandomGenerator to extract random values from
+ *
+ * @public
+ */
+function uniformArrayIntDistribution(from: ArrayInt, to: ArrayInt, rng: RandomGenerator): ArrayInt;
+function uniformArrayIntDistribution(from: ArrayInt, to: ArrayInt, rng?: RandomGenerator) {
+  if (rng != null) {
+    return uniformArrayIntInternal(from, to, rng);
+  }
+  return function (rng: RandomGenerator) {
+    return uniformArrayIntInternal(from, to, rng);
+  };
+}
+
+export { uniformArrayIntDistribution };

package/_src/util/rand/distribution/UniformBigIntDistribution.ts

@@ -0,0 +1,62 @@
+import type Distribution from "@fncts/base/util/rand/distribution/Distribution";
+import type { RandomGenerator } from "@fncts/base/util/rand/generator/RandomGenerator";
+
+function uniformBigIntInternal(from: bigint, diff: bigint, rng: RandomGenerator): bigint {
+  const MinRng    = BigInt(rng.min());
+  const NumValues = BigInt(rng.max() - rng.min() + 1);
+
+  // Number of iterations required to have enough random
+  // to build uniform entries in the asked range
+  let FinalNumValues = NumValues;
+  let NumIterations  = BigInt(1);
+  while (FinalNumValues < diff) {
+    FinalNumValues *= NumValues;
+    ++NumIterations;
+  }
+  const MaxAcceptedRandom = FinalNumValues - (FinalNumValues % diff);
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    // Aggregate mutiple calls to next() into a single random value
+    let value = BigInt(0);
+    for (let num = BigInt(0); num !== NumIterations; ++num) {
+      const out = rng.next();
+      value     = NumValues * value + (BigInt(out) - MinRng);
+    }
+    if (value < MaxAcceptedRandom) {
+      const inDiff = value % diff;
+      return inDiff + from;
+    }
+  }
+}
+
+/**
+ * Uniformly generate random bigint values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ *
+ * @public
+ */
+function uniformBigIntDistribution(from: bigint, to: bigint): Distribution<bigint>;
+/**
+ * Uniformly generate random bigint values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ * @param rng - Instance of RandomGenerator to extract random values from
+ *
+ * @public
+ */
+function uniformBigIntDistribution(from: bigint, to: bigint, rng: RandomGenerator): bigint;
+function uniformBigIntDistribution(from: bigint, to: bigint, rng?: RandomGenerator) {
+  const diff = to - from + BigInt(1);
+  if (rng != null) {
+    return uniformBigIntInternal(from, diff, rng);
+  }
+  return function (rng: RandomGenerator) {
+    return uniformBigIntInternal(from, diff, rng);
+  };
+}
+
+export { uniformBigIntDistribution };

package/_src/util/rand/distribution/UniformIntDistribution.ts

@@ -0,0 +1,75 @@
+import type Distribution from "@fncts/base/util/rand/distribution/Distribution";
+import type { ArrayInt64 } from "@fncts/base/util/rand/distribution/internals/ArrayInt";
+import type RandomGenerator from "@fncts/base/util/rand/generator/RandomGenerator";
+
+import { fromNumberToArrayInt64, substractArrayInt64 } from "@fncts/base/util/rand/distribution/internals/ArrayInt";
+import { uniformArrayIntDistributionInternal } from "@fncts/base/util/rand/distribution/internals/UniformArrayIntDistributionInternal";
+import { uniformIntDistributionInternal } from "@fncts/base/util/rand/distribution/internals/UniformIntDistributionInternal";
+
+const sharedA: ArrayInt64 = { sign: 1, data: [0, 0] };
+const sharedB: ArrayInt64 = { sign: 1, data: [0, 0] };
+const sharedC: ArrayInt64 = { sign: 1, data: [0, 0] };
+const sharedData          = [0, 0];
+
+function uniformLargeIntInternal(from: number, to: number, rangeSize: number, rng: RandomGenerator): number {
+  const rangeSizeArrayIntValue =
+    rangeSize <= Number.MAX_SAFE_INTEGER
+      ? fromNumberToArrayInt64(sharedC, rangeSize) // no possible overflow given rangeSize is in a safe range
+      : substractArrayInt64(sharedC, fromNumberToArrayInt64(sharedA, to), fromNumberToArrayInt64(sharedB, from)); // rangeSize might be incorrect, we compute a safer range
+
+  // Adding 1 to the range
+  if (rangeSizeArrayIntValue.data[1] === 0xffffffff) {
+    // rangeSizeArrayIntValue.length === 2 by construct
+    // rangeSize >= 0x00000001_00000000 and rangeSize <= 0x003fffff_fffffffe
+    // with Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER = 0x003fffff_fffffffe
+    rangeSizeArrayIntValue.data[0] += 1;
+    rangeSizeArrayIntValue.data[1]  = 0;
+  } else {
+    rangeSizeArrayIntValue.data[1] += 1;
+  }
+
+  uniformArrayIntDistributionInternal(sharedData, rangeSizeArrayIntValue.data, rng);
+  return sharedData[0]! * 0x100000000 + sharedData[1]! + from;
+}
+
+function uniformIntInternal(from: number, to: number, rng: RandomGenerator): number {
+  const rangeSize = to - from;
+  if (rangeSize <= 0xffffffff) {
+    // Calling uniformIntDistributionInternal can be considered safe
+    // up-to 2**32 values. Above this range it may miss values.
+    let g = uniformIntDistributionInternal(rangeSize + 1, rng);
+    g    += from;
+    return g;
+  }
+  return uniformLargeIntInternal(from, to, rangeSize, rng);
+}
+
+/**
+ * Uniformly generate random integer values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ *
+ * @public
+ */
+function uniformIntDistribution(from: number, to: number): Distribution<number>;
+/**
+ * Uniformly generate random integer values between `from` (included) and `to` (included)
+ *
+ * @param from - Lower bound of the range (included)
+ * @param to - Upper bound of the range (included)
+ * @param rng - Instance of RandomGenerator to extract random values from
+ *
+ * @public
+ */
+function uniformIntDistribution(from: number, to: number, rng: RandomGenerator): number;
+function uniformIntDistribution(from: number, to: number, rng?: RandomGenerator) {
+  if (rng != null) {
+    return uniformIntInternal(from, to, rng);
+  }
+  return function (rng: RandomGenerator) {
+    return uniformIntInternal(from, to, rng);
+  };
+}
+
+export { uniformIntDistribution };