@fncts/base 0.0.20 → 0.0.21

package/_src/util/PCGRandom.ts

@@ -1,5 +1,4 @@
 /* eslint-disable no-param-reassign */
-
 /*
  * Copyright 2014 Thom Chiovoloni, released under the MIT license.
  *
@@ -14,7 +13,6 @@
 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;
@@ -159,9 +157,8 @@ function mul64(out: Int32Array, aHi: number, aLo: number, bHi: number, bLo: numb
 
   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;
+  c0     = (c0 << 16) >>> 0;
+  lo     = (lo + c0) >>> 0;
   if (lo >>> 0 < c0 >>> 0) {
     hi = (hi + 1) >>> 0;
   }
@@ -171,10 +168,8 @@ function mul64(out: Int32Array, aHi: number, aLo: number, bHi: number, bLo: numb
   if (lo >>> 0 < c1 >>> 0) {
     hi = (hi + 1) >>> 0;
   }
-
-  hi = (hi + Math.imul(aLo, bHi)) >>> 0;
-  hi = (hi + Math.imul(aHi, bLo)) >>> 0;
-
+  hi     = (hi + Math.imul(aLo, bHi)) >>> 0;
+  hi     = (hi + Math.imul(aHi, bLo)) >>> 0;
   out[0] = hi;
   out[1] = lo;
 }

package/_src/util/assert.ts

@@ -3,8 +3,7 @@ export class AssertionError extends Error {
     super(`Assertion Failed: ${message}`);
   }
 }
-
-export function assert(assertion: boolean, message: string) {
+export function assert(assertion: boolean, message: string): asserts assertion {
   if (!assertion) {
     throw new AssertionError(message);
   }

package/_src/util/pattern.ts

@@ -1,15 +1,55 @@
 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 }>(
+  <
+    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>(
+  <
+    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;
+    __: (
+      _: 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;
@@ -18,18 +58,57 @@ export const pattern_: <N extends string>(
 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>(
+  <
+    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;
+    __: (
+      _: 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");
+export const matchTag  = pattern("_tag");

package/_src/util/predicates.ts

@@ -44,7 +44,9 @@ export function isObject<A>(value: A | Primitive): boolean {
 export function hasTypeId<X extends symbol>(
   value: unknown,
   typeId: X,
-): value is { readonly _typeId: X } & Record<PropertyKey, unknown> {
+): value is {
+  readonly _typeId: X;
+} & Record<PropertyKey, unknown> {
   return isObject(value) && "_typeId" in value && value["_typeId"] === typeId;
 }
 

package/_src/util/rand/Random.ts

@@ -3,7 +3,6 @@ import type RandomGenerator from "@fncts/base/util/rand/generator/RandomGenerato
 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
@@ -15,24 +14,20 @@ export class MutableRandom {
   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
@@ -40,20 +35,16 @@ export class MutableRandom {
   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
@@ -63,7 +54,6 @@ export class MutableRandom {
   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
@@ -72,19 +62,26 @@ export class MutableRandom {
   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[] } {
+    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)
    */
@@ -93,7 +90,6 @@ export class MutableRandom {
     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

@@ -1,5 +1,4 @@
 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.

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

@@ -9,7 +9,6 @@ import {
   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)));
@@ -17,7 +16,6 @@ function uniformArrayIntInternal(from: ArrayInt, to: ArrayInt, rng: RandomGenera
   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)
  *
@@ -45,5 +43,4 @@ function uniformArrayIntDistribution(from: ArrayInt, to: ArrayInt, rng?: RandomG
     return uniformArrayIntInternal(from, to, rng);
   };
 }
-
 export { uniformArrayIntDistribution };

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

@@ -1,10 +1,8 @@
 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;
@@ -14,7 +12,6 @@ function uniformBigIntInternal(from: bigint, diff: bigint, rng: RandomGenerator)
     ++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
@@ -29,7 +26,6 @@ function uniformBigIntInternal(from: bigint, diff: bigint, rng: RandomGenerator)
     }
   }
 }
-
 /**
  * Uniformly generate random bigint values between `from` (included) and `to` (included)
  *
@@ -58,5 +54,4 @@ function uniformBigIntDistribution(from: bigint, to: bigint, rng?: RandomGenerat
     return uniformBigIntInternal(from, diff, rng);
   };
 }
-
 export { uniformBigIntDistribution };

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

@@ -5,18 +5,15 @@ import type RandomGenerator from "@fncts/base/util/rand/generator/RandomGenerato
 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
@@ -27,11 +24,9 @@ function uniformLargeIntInternal(from: number, to: number, rangeSize: number, rn
   } 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) {
@@ -43,7 +38,6 @@ function uniformIntInternal(from: number, to: number, rng: RandomGenerator): num
   }
   return uniformLargeIntInternal(from, to, rangeSize, rng);
 }
-
 /**
  * Uniformly generate random integer values between `from` (included) and `to` (included)
  *
@@ -71,5 +65,4 @@ function uniformIntDistribution(from: number, to: number, rng?: RandomGenerator)
     return uniformIntInternal(from, to, rng);
   };
 }
-
 export { uniformIntDistribution };

package/_src/util/rand/distribution/internals/ArrayInt.ts

@@ -20,7 +20,6 @@ export type ArrayInt = {
    */
   data: number[];
 };
-
 /**
  * Add two ArrayInt
  * @internal
@@ -48,7 +47,6 @@ export function addArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt): Arra
   }
   return { sign: arrayIntA.sign, data: data.reverse() };
 }
-
 /**
  * Add one to a given positive ArrayInt
  * @internal
@@ -67,7 +65,6 @@ export function addOneToPositiveArrayInt(arrayInt: ArrayInt): ArrayInt {
   data.unshift(1);
   return arrayInt;
 }
-
 /** @internal */
 function isStrictlySmaller(dataA: number[], dataB: number[]): boolean {
   const maxLength = Math.max(dataA.length, dataB.length);
@@ -81,7 +78,6 @@ function isStrictlySmaller(dataA: number[], dataB: number[]): boolean {
   }
   return false;
 }
-
 /**
  * Substract two ArrayInt
  * @internal
@@ -108,7 +104,6 @@ export function substractArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt)
   }
   return { sign: arrayIntA.sign, data: data.reverse() };
 }
-
 /**
  * Trim uneeded zeros in ArrayInt
  * and uniform notation for zero: {sign: 1, data: [0]}
@@ -127,12 +122,11 @@ export function trimArrayIntInplace(arrayInt: ArrayInt) {
   data.splice(0, firstNonZero);
   return arrayInt;
 }
-
 // Helpers specific to 64 bits versions
-
 /** @internal */
-export type ArrayInt64 = Required<ArrayInt> & { data: [number, number] };
-
+export type ArrayInt64 = Required<ArrayInt> & {
+  data: [number, number];
+};
 /**
  * We only accept safe integers here
  * @internal
@@ -150,7 +144,6 @@ export function fromNumberToArrayInt64(out: ArrayInt64, n: number): ArrayInt64 {
   }
   return out;
 }
-
 /**
  * Substract two ArrayInt of 64 bits on 64 bits.
  * With arrayIntA - arrayIntB >= 0
@@ -163,10 +156,8 @@ export function substractArrayInt64(out: ArrayInt64, arrayIntA: ArrayInt64, arra
   const lowB  = arrayIntB.data[1];
   const highB = arrayIntB.data[0];
   const signB = arrayIntB.sign;
-
   // Requirement: arrayIntA - arrayIntB >= 0
   out.sign = 1;
-
   if (signA === 1 && signB === -1) {
     // Operation is a simple sum of arrayIntA + abs(arrayIntB)
     const low   = lowA + lowB;
@@ -176,7 +167,6 @@ export function substractArrayInt64(out: ArrayInt64, arrayIntA: ArrayInt64, arra
     return out;
   }
   // signA === -1 with signB === 1 is impossible given: arrayIntA - arrayIntB >= 0
-
   // Operation is a substraction
   let lowFirst   = lowA;
   let highFirst  = highA;

package/_src/util/rand/distribution/internals/UniformArrayIntDistributionInternal.ts

@@ -2,7 +2,6 @@ import type { ArrayInt } from "@fncts/base/util/rand/distribution/internals/Arra
 import type RandomGenerator from "@fncts/base/util/rand/generator/RandomGenerator";
 
 import { uniformIntDistributionInternal } from "@fncts/base/util/rand/distribution/internals/UniformIntDistributionInternal";
-
 /**
  * Uniformly generate ArrayInt in range [0 ; rangeSize[
  *
@@ -18,7 +17,6 @@ export function uniformArrayIntDistributionInternal(
   rng: RandomGenerator,
 ): ArrayInt["data"] {
   const rangeLength = rangeSize.length;
-
   // We iterate until we find a valid value for arrayInt
   // eslint-disable-next-line no-constant-condition
   while (true) {
@@ -27,7 +25,6 @@ export function uniformArrayIntDistributionInternal(
       const indexRangeSize = index === 0 ? rangeSize[0]! + 1 : 0x100000000;
       out[index]           = uniformIntDistributionInternal(indexRangeSize, rng);
     }
-
     // If in the correct range we can return it
     for (let index = 0; index !== rangeLength; ++index) {
       const current        = out[index]!;

package/_src/util/rand/distribution/internals/UniformIntDistributionInternal.ts

@@ -1,5 +1,4 @@
 import type { RandomGenerator } from "@fncts/base/util/rand/generator/RandomGenerator";
-
 /**
  * Uniformly generate number in range [0 ; rangeSize[
  * @internal
@@ -7,7 +6,6 @@ import type { RandomGenerator } from "@fncts/base/util/rand/generator/RandomGene
 export function uniformIntDistributionInternal(rangeSize: number, rng: RandomGenerator): number {
   const MinRng    = rng.min();
   const NumValues = rng.max() - rng.min() + 1;
-
   // Range provided by the RandomGenerator is large enough
   if (rangeSize <= NumValues) {
     const MaxAllowed = NumValues - (NumValues % rangeSize);
@@ -20,7 +18,6 @@ export function uniformIntDistributionInternal(rangeSize: number, rng: RandomGen
       }
     }
   }
-
   // Compute number of iterations required to have enough random
   // to build uniform entries in the asked range
   let FinalNumValues = NumValues * NumValues;
@@ -30,7 +27,6 @@ export function uniformIntDistributionInternal(rangeSize: number, rng: RandomGen
     ++NumIterations;
   }
   const MaxAcceptedRandom = rangeSize * Math.floor((1 * FinalNumValues) / rangeSize);
-
   // eslint-disable-next-line no-constant-condition
   while (true) {
     // Aggregate mutiple calls to next() into a single random value

package/_src/util/rand/generator/MersenneTwister.ts

@@ -1,15 +1,15 @@
 /* eslint-disable prefer-const */
-/* 
+/*
   Original MT19937 license:
 
   A C-program for MT19937, with initialization improved 2002/1/26.
   Coded by Takuji Nishimura and Makoto Matsumoto.
 
-  Before using, initialize the state by using init_genrand(seed)  
+  Before using, initialize the state by using init_genrand(seed)
   or init_by_array(init_key, key_length).
 
   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
-  All rights reserved.                          
+  All rights reserved.
 
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
@@ -22,8 +22,8 @@
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
 
-    3. The names of its contributors may not be used to endorse or promote 
-      products derived from this software without specific prior written 
+    3. The names of its contributors may not be used to endorse or promote
+      products derived from this software without specific prior written
       permission.
 
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
@@ -43,49 +43,38 @@
   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
 */
-
 import type { RandomGenerator } from "@fncts/base/util/rand/generator/RandomGenerator";
-
 const MAX_INT    = 4294967296.0;
 const N          = 624;
 const M          = 397;
 const UPPER_MASK = 0x80000000;
 const LOWER_MASK = 0x7fffffff;
 const MATRIX_A   = 0x9908b0df;
-
 export class MersenneTwister implements RandomGenerator {
   private mt: Array<number>;
   private mti: number;
-
   constructor(seed?: number) {
     this.mt  = new Array(N);
     this.mti = N + 1;
     this.setSeed(seed ?? Date.now());
   }
-
   setSeed(seed: number) {
     let s: number;
-
     this.mt[0] = seed >>> 0;
-
     for (this.mti = 1; this.mti < N; this.mti++) {
       s                    = this.mt[this.mti - 1]! ^ (this.mt[this.mti - 1]! >>> 30);
       this.mt[this.mti]    = ((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253 + this.mti;
       this.mt[this.mti] >>>= 0;
     }
   }
-
   seedArray(vector: ReadonlyArray<number>) {
     let i = 1,
       j = 0,
       k = N > vector.length ? N : vector.length,
       s: number;
-
     this.setSeed(19650218);
-
     for (; k > 0; k--) {
       s = this.mt[i - 1]! ^ (this.mt[i - 1]! >>> 30);
-
       this.mt[i] =
         (this.mt[i]! ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + (s & 0x0000ffff) * 1664525)) + vector[j]! + j;
       this.mt[i] >>>= 0;
@@ -99,7 +88,6 @@ export class MersenneTwister implements RandomGenerator {
         j = 0;
       }
     }
-
     for (k = N - 1; k; k--) {
       s = this.mt[i - 1]! ^ (this.mt[i - 1]! >>> 30);
       this.mt[i] =
@@ -111,49 +99,38 @@ export class MersenneTwister implements RandomGenerator {
         i          = 1;
       }
     }
-
     this.mt[0] = 0x80000000;
   }
-
   next() {
     let y: number,
       kk: number,
       mag01: [number, number] = [0, MATRIX_A];
-
     if (this.mti >= N) {
       if (this.mti === N + 1) {
         this.setSeed(5489);
       }
-
       for (kk = 0; kk < N - M; kk++) {
         y           = (this.mt[kk]! & UPPER_MASK) | (this.mt[kk + 1]! & LOWER_MASK);
         this.mt[kk] = this.mt[kk + M]! ^ (y >>> 1) ^ mag01[y & 1]!;
       }
-
       for (; kk < N - 1; kk++) {
         y           = (this.mt[kk]! & UPPER_MASK) | (this.mt[kk + 1]! & LOWER_MASK);
         this.mt[kk] = this.mt[kk + (M - N)]! ^ (y >>> 1) ^ mag01[y & 1]!;
       }
-
       y              = (this.mt[N - 1]! & UPPER_MASK) | (this.mt[0]! & LOWER_MASK);
       this.mt[N - 1] = this.mt[M - 1]! ^ (y >>> 1) ^ mag01[y & 1]!;
       this.mti       = 0;
     }
-
-    y = this.mt[this.mti++]!;
-
+    y  = this.mt[this.mti++]!;
     y ^= y >>> 11;
     y ^= (y << 7) & 0x9d2c5680;
     y ^= (y << 15) & 0xefc60000;
     y ^= y >>> 18;
-
     return y >>> 0;
   }
-
   min(): number {
     return 0;
   }
-
   max(): number {
     return 0xffffffff;
   }

package/_src/util/rand/generator/RandomGenerator.ts

@@ -5,7 +5,6 @@ export default interface RandomGenerator {
   min(): number; //inclusive
   max(): number; //inclusive
 }
-
 function generateN(rng: RandomGenerator, num: number): number[] {
   const out: number[] = [];
   for (let idx = 0; idx != num; ++idx) {
@@ -14,9 +13,7 @@ function generateN(rng: RandomGenerator, num: number): number[] {
   }
   return out;
 }
-
 function skipN(rng: RandomGenerator, num: number): void {
   generateN(rng, num);
 }
-
 export { generateN, RandomGenerator, skipN };