@fncts/base 0.0.1

package/_cjs/util/predicates.cjs

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasTypeId = hasTypeId;
+exports.isAnyArrayBuffer = isAnyArrayBuffer;
+exports.isArray = isArray;
+exports.isArrayBuffer = isArrayBuffer;
+exports.isBoolean = isBoolean;
+exports.isByte = isByte;
+exports.isDataView = isDataView;
+exports.isDate = isDate;
+exports.isDefined = isDefined;
+exports.isFunction = isFunction;
+exports.isInstanceOf = isInstanceOf;
+exports.isIterable = isIterable;
+exports.isMap = isMap;
+exports.isNonNull = isNonNull;
+exports.isNonNullable = isNonNullable;
+exports.isNull = isNull;
+exports.isNullable = isNullable;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPlain = isPlain;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isSet = isSet;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isTypedArray = isTypedArray;
+exports.isUndefined = isUndefined;
+exports.isWeakMap = isWeakMap;
+exports.isWeakSet = isWeakSet;
+
+function isDefined(value) {
+  return value !== undefined;
+}
+
+function isUndefined(value) {
+  return value === undefined;
+}
+
+function isNonNull(value) {
+  return value !== null;
+}
+
+function isNull(value) {
+  return value === null;
+}
+
+function isNonNullable(value) {
+  return value != null;
+}
+
+function isNullable(value) {
+  return value == null;
+}
+
+function isIterable(value) {
+  return isObject(value) && Symbol.iterator in value;
+}
+
+function isArray(value) {
+  return Array.isArray(value);
+}
+
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
+function hasTypeId(value, typeId) {
+  return isObject(value) && "_typeId" in value && value["_typeId"] === typeId;
+}
+
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+
+function isString(value) {
+  return typeof value === "string";
+}
+
+function isNumber(value) {
+  return typeof value === "number";
+}
+
+function isByte(n) {
+  return typeof n === "number" && Number.isInteger(n) && n >= 0 && n <= 255;
+}
+
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+
+function isPlain(value) {
+  return isObject(value) && value.constructor === Object;
+}
+
+function isInstanceOf(type) {
+  return value => value instanceof type;
+}
+
+function isMap(u) {
+  return u instanceof Map;
+}
+
+function isWeakMap(u) {
+  return u instanceof WeakMap;
+}
+
+function isPromise(u) {
+  return u instanceof Promise;
+}
+
+function isSet(u) {
+  return u instanceof Set;
+}
+
+function isWeakSet(u) {
+  return u instanceof WeakSet;
+}
+
+function isDate(u) {
+  return u instanceof Date;
+}
+
+const TypedArrayConstructor = /*#__PURE__*/Object.getPrototypeOf(Uint8Array);
+
+function isTypedArray(u) {
+  return u instanceof TypedArrayConstructor;
+}
+
+function isRegExp(u) {
+  return isObject(u) && (getTag(u) === "[object RegExp]" || u instanceof RegExp);
+}
+
+function isAnyArrayBuffer(u) {
+  return u instanceof ArrayBuffer || u instanceof SharedArrayBuffer;
+}
+
+function isArrayBuffer(u) {
+  return u instanceof ArrayBuffer;
+}
+
+function isDataView(u) {
+  return u instanceof DataView;
+}
+
+function getTag(value) {
+  return Object.prototype.toString.call(value);
+}
+//# sourceMappingURL=predicates.cjs.map

package/_cjs/util/predicates.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicates.cjs","mappings":"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","names":["isDefined","value","undefined","isUndefined","isNonNull","isNull","isNonNullable","isNullable","isIterable","isObject","Symbol","iterator","isArray","Array","hasTypeId","typeId","isFunction","isBoolean","isString","isNumber","isByte","n","Number","isInteger","isSymbol","isPlain","constructor","Object","isInstanceOf","type","isMap","u","Map","isWeakMap","WeakMap","isPromise","Promise","isSet","Set","isWeakSet","WeakSet","isDate","Date","TypedArrayConstructor","getPrototypeOf","Uint8Array","isTypedArray","isRegExp","getTag","RegExp","isAnyArrayBuffer","ArrayBuffer","SharedArrayBuffer","isArrayBuffer","isDataView","DataView","prototype","toString","call"],"sourceRoot":"","sources":["../../_src/util/predicates.ts"],"sourcesContent":[null]}

package/_cjs/util/rand/Random.cjs

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MutableRandom = void 0;
+
+var _UniformArrayIntDistribution = /*#__PURE__*/require("@fncts/base/util/rand/distribution/UniformArrayIntDistribution");
+
+var _UniformBigIntDistribution = /*#__PURE__*/require("@fncts/base/util/rand/distribution/UniformBigIntDistribution");
+
+var _UniformIntDistribution = /*#__PURE__*/require("@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
+ */
+class MutableRandom {
+  /**
+   * Create a mutable random number generator
+   * @param internalRng - Immutable random generator from pure-rand library
+   */
+  constructor(internalRng) {
+    this.internalRng = internalRng;
+  }
+  /**
+   * Clone the random number generator
+   */
+
+
+  clone() {
+    return new MutableRandom(this.internalRng);
+  }
+
+  uniformIn(rangeMin, rangeMax) {
+    return (0, _UniformIntDistribution.uniformIntDistribution)(rangeMin, rangeMax, this.internalRng);
+  }
+  /**
+   * Generate an integer having `bits` random bits
+   * @param bits - Number of bits to generate
+   */
+
+
+  next(bits) {
+    return this.uniformIn(0, (1 << bits) - 1);
+  }
+  /**
+   * Generate a random boolean
+   */
+
+
+  nextBoolean() {
+    return this.uniformIn(0, 1) === 1;
+  }
+
+  nextInt(min, max) {
+    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, max) {
+    return (0, _UniformBigIntDistribution.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, max) {
+    return (0, _UniformArrayIntDistribution.uniformArrayIntDistribution)(min, max, this.internalRng);
+  }
+  /**
+   * Generate a random floating point number between 0.0 (included) and 1.0 (excluded)
+   */
+
+
+  nextDouble() {
+    const a = this.next(26);
+    const b = this.next(27);
+    return (a * MutableRandom.DBL_FACTOR + b) * MutableRandom.DBL_DIVISOR;
+  }
+
+  setSeed(seed) {
+    this.internalRng.setSeed(seed);
+  }
+
+}
+
+exports.MutableRandom = MutableRandom;
+MutableRandom.MIN_INT = 0x80000000 | 0;
+MutableRandom.MAX_INT = 0x7fffffff | 0;
+MutableRandom.DBL_FACTOR = /*#__PURE__*/Math.pow(2, 27);
+MutableRandom.DBL_DIVISOR = /*#__PURE__*/Math.pow(2, -53);
+//# sourceMappingURL=Random.cjs.map

package/_cjs/util/rand/Random.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Random.cjs","mappings":";;;;;;;AAEA;;AACA;;AACA;;AAEA;;;;;;AAMM,MAAOA,aAAP,CAAoB;EAMxB;;;;EAIAC,YAAoBC,WAApB,EAAgD;IAA5B;EAAgC;EAEpD;;;;;EAGAC,KAAK;IACH,OAAO,IAAIH,aAAJ,CAAkB,KAAKE,WAAvB,CAAP;EACD;;EAEOE,SAAS,CAACC,QAAD,EAAmBC,QAAnB,EAAmC;IAClD,OAAO,oDAAuBD,QAAvB,EAAiCC,QAAjC,EAA2C,KAAKJ,WAAhD,CAAP;EACD;EAED;;;;;;EAIAK,IAAI,CAACC,IAAD,EAAa;IACf,OAAO,KAAKJ,SAAL,CAAe,CAAf,EAAkB,CAAC,KAAKI,IAAN,IAAc,CAAhC,CAAP;EACD;EAED;;;;;EAIAC,WAAW;IACT,OAAO,KAAKL,SAAL,CAAe,CAAf,EAAkB,CAAlB,MAAyB,CAAhC;EACD;;EAaDM,OAAO,CAACC,GAAD,EAAeC,GAAf,EAA2B;IAChC,OAAO,KAAKR,SAAL,CAAeO,GAAG,IAAI,IAAP,GAAcX,aAAa,CAACa,OAA5B,GAAsCF,GAArD,EAA0DC,GAAG,IAAI,IAAP,GAAcZ,aAAa,CAACc,OAA5B,GAAsCF,GAAhG,CAAP;EACD;EAED;;;;;;;EAKAG,UAAU,CAACJ,GAAD,EAAcC,GAAd,EAAyB;IACjC,OAAO,0DAA0BD,GAA1B,EAA+BC,GAA/B,EAAoC,KAAKV,WAAzC,CAAP;EACD;EAED;;;;;;;EAKAc,YAAY,CACVL,GADU,EAEVC,GAFU,EAE2B;IAErC,OAAO,8DAA4BD,GAA5B,EAAiCC,GAAjC,EAAsC,KAAKV,WAA3C,CAAP;EACD;EAED;;;;;EAGAe,UAAU;IACR,MAAMC,CAAC,GAAG,KAAKX,IAAL,CAAU,EAAV,CAAV;IACA,MAAMY,CAAC,GAAG,KAAKZ,IAAL,CAAU,EAAV,CAAV;IACA,OAAO,CAACW,CAAC,GAAGlB,aAAa,CAACoB,UAAlB,GAA+BD,CAAhC,IAAqCnB,aAAa,CAACqB,WAA1D;EACD;;EAEDC,OAAO,CAACC,IAAD,EAAa;IAClB,KAAKrB,WAAL,CAAiBoB,OAAjB,CAAyBC,IAAzB;EACD;;AAtFuB;;;AACTvB,wBAAsB,aAAa,CAAnC;AACAA,wBAAsB,aAAa,CAAnC;AACAA,wCAAsBwB,IAAI,CAACC,GAAL,CAAS,CAAT,EAAY,EAAZ,CAAtB;AACAzB,yCAAsBwB,IAAI,CAACC,GAAL,CAAS,CAAT,EAAY,CAAC,EAAb,CAAtB","names":["MutableRandom","constructor","internalRng","clone","uniformIn","rangeMin","rangeMax","next","bits","nextBoolean","nextInt","min","max","MIN_INT","MAX_INT","nextBigInt","nextArrayInt","nextDouble","a","b","DBL_FACTOR","DBL_DIVISOR","setSeed","seed","Math","pow"],"sourceRoot":"","sources":["../../../_src/util/rand/Random.ts"],"sourcesContent":[null]}

package/_cjs/util/rand/distribution/Distribution.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=Distribution.cjs.map

package/_cjs/util/rand/distribution/Distribution.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Distribution.cjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/_cjs/util/rand/distribution/UniformArrayIntDistribution.cjs

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uniformArrayIntDistribution = uniformArrayIntDistribution;
+
+var _ArrayInt = /*#__PURE__*/require("@fncts/base/util/rand/distribution/internals/ArrayInt");
+
+var _UniformArrayIntDistributionInternal = /*#__PURE__*/require("@fncts/base/util/rand/distribution/internals/UniformArrayIntDistributionInternal");
+
+/** @internal */
+function uniformArrayIntInternal(from, to, rng) {
+  const rangeSize = (0, _ArrayInt.trimArrayIntInplace)((0, _ArrayInt.addOneToPositiveArrayInt)((0, _ArrayInt.substractArrayIntToNew)(to, from)));
+  const emptyArrayIntData = rangeSize.data.slice(0);
+  const g = (0, _UniformArrayIntDistributionInternal.uniformArrayIntDistributionInternal)(emptyArrayIntData, rangeSize.data, rng);
+  return (0, _ArrayInt.trimArrayIntInplace)((0, _ArrayInt.addArrayIntToNew)({
+    sign: 1,
+    data: g
+  }, from));
+}
+
+function uniformArrayIntDistribution(from, to, rng) {
+  if (rng != null) {
+    return uniformArrayIntInternal(from, to, rng);
+  }
+
+  return function (rng) {
+    return uniformArrayIntInternal(from, to, rng);
+  };
+}
+//# sourceMappingURL=UniformArrayIntDistribution.cjs.map

package/_cjs/util/rand/distribution/UniformArrayIntDistribution.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniformArrayIntDistribution.cjs","mappings":";;;;;;;AAIA;;AAMA;;AAEA;AACA,SAASA,uBAAT,CAAiCC,IAAjC,EAAiDC,EAAjD,EAA+DC,GAA/D,EAAmF;EACjF,MAAMC,SAAS,GAAW,mCAAoB,wCAAyB,sCAAuBF,EAAvB,EAA2BD,IAA3B,CAAzB,CAApB,CAA1B;EACA,MAAMI,iBAAiB,GAAGD,SAAS,CAACE,IAAV,CAAeC,KAAf,CAAqB,CAArB,CAA1B;EACA,MAAMC,CAAC,GAAmB,8EAAoCH,iBAApC,EAAuDD,SAAS,CAACE,IAAjE,EAAuEH,GAAvE,CAA1B;EACA,OAAO,mCAAoB,gCAAiB;IAAEM,IAAI,EAAE,CAAR;IAAWH,IAAI,EAAEE;EAAjB,CAAjB,EAAuCP,IAAvC,CAApB,CAAP;AACD;;AAqBD,SAASS,2BAAT,CAAqCT,IAArC,EAAqDC,EAArD,EAAmEC,GAAnE,EAAwF;EACtF,IAAIA,GAAG,IAAI,IAAX,EAAiB;IACf,OAAOH,uBAAuB,CAACC,IAAD,EAAOC,EAAP,EAAWC,GAAX,CAA9B;EACD;;EACD,OAAO,UAAUA,GAAV,EAA8B;IACnC,OAAOH,uBAAuB,CAACC,IAAD,EAAOC,EAAP,EAAWC,GAAX,CAA9B;EACD,CAFD;AAGD","names":["uniformArrayIntInternal","from","to","rng","rangeSize","emptyArrayIntData","data","slice","g","sign","uniformArrayIntDistribution"],"sourceRoot":"","sources":["../../../../_src/util/rand/distribution/UniformArrayIntDistribution.ts"],"sourcesContent":[null]}

package/_cjs/util/rand/distribution/UniformBigIntDistribution.cjs

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uniformBigIntDistribution = uniformBigIntDistribution;
+
+function uniformBigIntInternal(from, diff, rng) {
+  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;
+    }
+  }
+}
+
+function uniformBigIntDistribution(from, to, rng) {
+  const diff = to - from + BigInt(1);
+
+  if (rng != null) {
+    return uniformBigIntInternal(from, diff, rng);
+  }
+
+  return function (rng) {
+    return uniformBigIntInternal(from, diff, rng);
+  };
+}
+//# sourceMappingURL=UniformBigIntDistribution.cjs.map

package/_cjs/util/rand/distribution/UniformBigIntDistribution.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniformBigIntDistribution.cjs","mappings":";;;;;;;AAGA,SAASA,qBAAT,CAA+BC,IAA/B,EAA6CC,IAA7C,EAA2DC,GAA3D,EAA+E;EAC7E,MAAMC,MAAM,GAAMC,MAAM,CAACF,GAAG,CAACG,GAAJ,EAAD,CAAxB;EACA,MAAMC,SAAS,GAAGF,MAAM,CAACF,GAAG,CAACK,GAAJ,KAAYL,GAAG,CAACG,GAAJ,EAAZ,GAAwB,CAAzB,CAAxB,CAF6E,CAI7E;EACA;;EACA,IAAIG,cAAc,GAAGF,SAArB;EACA,IAAIG,aAAa,GAAIL,MAAM,CAAC,CAAD,CAA3B;;EACA,OAAOI,cAAc,GAAGP,IAAxB,EAA8B;IAC5BO,cAAc,IAAIF,SAAlB;IACA,EAAEG,aAAF;EACD;;EACD,MAAMC,iBAAiB,GAAGF,cAAc,GAAIA,cAAc,GAAGP,IAA7D,CAZ6E,CAc7E;;EACA,OAAO,IAAP,EAAa;IACX;IACA,IAAIU,KAAK,GAAGP,MAAM,CAAC,CAAD,CAAlB;;IACA,KAAK,IAAIQ,GAAG,GAAGR,MAAM,CAAC,CAAD,CAArB,EAA0BQ,GAAG,KAAKH,aAAlC,EAAiD,EAAEG,GAAnD,EAAwD;MACtD,MAAMC,GAAG,GAAGX,GAAG,CAACY,IAAJ,EAAZ;MACAH,KAAK,GAAOL,SAAS,GAAGK,KAAZ,IAAqBP,MAAM,CAACS,GAAD,CAAN,GAAcV,MAAnC,CAAZ;IACD;;IACD,IAAIQ,KAAK,GAAGD,iBAAZ,EAA+B;MAC7B,MAAMK,MAAM,GAAGJ,KAAK,GAAGV,IAAvB;MACA,OAAOc,MAAM,GAAGf,IAAhB;IACD;EACF;AACF;;AAqBD,SAASgB,yBAAT,CAAmChB,IAAnC,EAAiDiB,EAAjD,EAA6Df,GAA7D,EAAkF;EAChF,MAAMD,IAAI,GAAGgB,EAAE,GAAGjB,IAAL,GAAYI,MAAM,CAAC,CAAD,CAA/B;;EACA,IAAIF,GAAG,IAAI,IAAX,EAAiB;IACf,OAAOH,qBAAqB,CAACC,IAAD,EAAOC,IAAP,EAAaC,GAAb,CAA5B;EACD;;EACD,OAAO,UAAUA,GAAV,EAA8B;IACnC,OAAOH,qBAAqB,CAACC,IAAD,EAAOC,IAAP,EAAaC,GAAb,CAA5B;EACD,CAFD;AAGD","names":["uniformBigIntInternal","from","diff","rng","MinRng","BigInt","min","NumValues","max","FinalNumValues","NumIterations","MaxAcceptedRandom","value","num","out","next","inDiff","uniformBigIntDistribution","to"],"sourceRoot":"","sources":["../../../../_src/util/rand/distribution/UniformBigIntDistribution.ts"],"sourcesContent":[null]}

package/_cjs/util/rand/distribution/UniformIntDistribution.cjs

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uniformIntDistribution = uniformIntDistribution;
+
+var _ArrayInt = /*#__PURE__*/require("@fncts/base/util/rand/distribution/internals/ArrayInt");
+
+var _UniformArrayIntDistributionInternal = /*#__PURE__*/require("@fncts/base/util/rand/distribution/internals/UniformArrayIntDistributionInternal");
+
+var _UniformIntDistributionInternal = /*#__PURE__*/require("@fncts/base/util/rand/distribution/internals/UniformIntDistributionInternal");
+
+const sharedA = {
+  sign: 1,
+  data: [0, 0]
+};
+const sharedB = {
+  sign: 1,
+  data: [0, 0]
+};
+const sharedC = {
+  sign: 1,
+  data: [0, 0]
+};
+const sharedData = [0, 0];
+
+function uniformLargeIntInternal(from, to, rangeSize, rng) {
+  const rangeSizeArrayIntValue = rangeSize <= Number.MAX_SAFE_INTEGER ? (0, _ArrayInt.fromNumberToArrayInt64)(sharedC, rangeSize) // no possible overflow given rangeSize is in a safe range
+  : (0, _ArrayInt.substractArrayInt64)(sharedC, (0, _ArrayInt.fromNumberToArrayInt64)(sharedA, to), (0, _ArrayInt.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;
+  }
+
+  (0, _UniformArrayIntDistributionInternal.uniformArrayIntDistributionInternal)(sharedData, rangeSizeArrayIntValue.data, rng);
+  return sharedData[0] * 0x100000000 + sharedData[1] + from;
+}
+
+function uniformIntInternal(from, to, rng) {
+  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 = (0, _UniformIntDistributionInternal.uniformIntDistributionInternal)(rangeSize + 1, rng);
+    g += from;
+    return g;
+  }
+
+  return uniformLargeIntInternal(from, to, rangeSize, rng);
+}
+
+function uniformIntDistribution(from, to, rng) {
+  if (rng != null) {
+    return uniformIntInternal(from, to, rng);
+  }
+
+  return function (rng) {
+    return uniformIntInternal(from, to, rng);
+  };
+}
+//# sourceMappingURL=UniformIntDistribution.cjs.map

package/_cjs/util/rand/distribution/UniformIntDistribution.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniformIntDistribution.cjs","mappings":";;;;;;;AAIA;;AACA;;AACA;;AAEA,MAAMA,OAAO,GAAe;EAAEC,IAAI,EAAE,CAAR;EAAWC,IAAI,EAAE,CAAC,CAAD,EAAI,CAAJ;AAAjB,CAA5B;AACA,MAAMC,OAAO,GAAe;EAAEF,IAAI,EAAE,CAAR;EAAWC,IAAI,EAAE,CAAC,CAAD,EAAI,CAAJ;AAAjB,CAA5B;AACA,MAAME,OAAO,GAAe;EAAEH,IAAI,EAAE,CAAR;EAAWC,IAAI,EAAE,CAAC,CAAD,EAAI,CAAJ;AAAjB,CAA5B;AACA,MAAMG,UAAU,GAAY,CAAC,CAAD,EAAI,CAAJ,CAA5B;;AAEA,SAASC,uBAAT,CAAiCC,IAAjC,EAA+CC,EAA/C,EAA2DC,SAA3D,EAA8EC,GAA9E,EAAkG;EAChG,MAAMC,sBAAsB,GAC1BF,SAAS,IAAIG,MAAM,CAACC,gBAApB,GACI,sCAAuBT,OAAvB,EAAgCK,SAAhC,CADJ,CAC+C;EAD/C,EAEI,mCAAoBL,OAApB,EAA6B,sCAAuBJ,OAAvB,EAAgCQ,EAAhC,CAA7B,EAAkE,sCAAuBL,OAAvB,EAAgCI,IAAhC,CAAlE,CAHN,CADgG,CAIgB;EAEhH;;EACA,IAAII,sBAAsB,CAACT,IAAvB,CAA4B,CAA5B,MAAmC,UAAvC,EAAmD;IACjD;IACA;IACA;IACAS,sBAAsB,CAACT,IAAvB,CAA4B,CAA5B,KAAkC,CAAlC;IACAS,sBAAsB,CAACT,IAAvB,CAA4B,CAA5B,IAAkC,CAAlC;EACD,CAND,MAMO;IACLS,sBAAsB,CAACT,IAAvB,CAA4B,CAA5B,KAAkC,CAAlC;EACD;;EAED,8EAAoCG,UAApC,EAAgDM,sBAAsB,CAACT,IAAvE,EAA6EQ,GAA7E;EACA,OAAOL,UAAU,CAAC,CAAD,CAAV,GAAiB,WAAjB,GAA+BA,UAAU,CAAC,CAAD,CAAzC,GAAgDE,IAAvD;AACD;;AAED,SAASO,kBAAT,CAA4BP,IAA5B,EAA0CC,EAA1C,EAAsDE,GAAtD,EAA0E;EACxE,MAAMD,SAAS,GAAGD,EAAE,GAAGD,IAAvB;;EACA,IAAIE,SAAS,IAAI,UAAjB,EAA6B;IAC3B;IACA;IACA,IAAIM,CAAC,GAAG,oEAA+BN,SAAS,GAAG,CAA3C,EAA8CC,GAA9C,CAAR;IACAK,CAAC,IAAOR,IAAR;IACA,OAAOQ,CAAP;EACD;;EACD,OAAOT,uBAAuB,CAACC,IAAD,EAAOC,EAAP,EAAWC,SAAX,EAAsBC,GAAtB,CAA9B;AACD;;AAqBD,SAASM,sBAAT,CAAgCT,IAAhC,EAA8CC,EAA9C,EAA0DE,GAA1D,EAA+E;EAC7E,IAAIA,GAAG,IAAI,IAAX,EAAiB;IACf,OAAOI,kBAAkB,CAACP,IAAD,EAAOC,EAAP,EAAWE,GAAX,CAAzB;EACD;;EACD,OAAO,UAAUA,GAAV,EAA8B;IACnC,OAAOI,kBAAkB,CAACP,IAAD,EAAOC,EAAP,EAAWE,GAAX,CAAzB;EACD,CAFD;AAGD","names":["sharedA","sign","data","sharedB","sharedC","sharedData","uniformLargeIntInternal","from","to","rangeSize","rng","rangeSizeArrayIntValue","Number","MAX_SAFE_INTEGER","uniformIntInternal","g","uniformIntDistribution"],"sourceRoot":"","sources":["../../../../_src/util/rand/distribution/UniformIntDistribution.ts"],"sourcesContent":[null]}

package/_cjs/util/rand/distribution/internals/ArrayInt.cjs

@@ -0,0 +1,220 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addArrayIntToNew = addArrayIntToNew;
+exports.addOneToPositiveArrayInt = addOneToPositiveArrayInt;
+exports.fromNumberToArrayInt64 = fromNumberToArrayInt64;
+exports.substractArrayInt64 = substractArrayInt64;
+exports.substractArrayIntToNew = substractArrayIntToNew;
+exports.trimArrayIntInplace = trimArrayIntInplace;
+
+/**
+ * Add two ArrayInt
+ * @internal
+ */
+function addArrayIntToNew(arrayIntA, arrayIntB) {
+  if (arrayIntA.sign !== arrayIntB.sign) {
+    return substractArrayIntToNew(arrayIntA, {
+      sign: -arrayIntB.sign,
+      data: arrayIntB.data
+    });
+  }
+
+  const data = [];
+  let reminder = 0;
+  const dataA = arrayIntA.data;
+  const dataB = arrayIntB.data;
+
+  for (let indexA = dataA.length - 1, indexB = dataB.length - 1; indexA >= 0 || indexB >= 0; --indexA, --indexB) {
+    const vA = indexA >= 0 ? dataA[indexA] : 0;
+    const vB = indexB >= 0 ? dataB[indexB] : 0;
+    const current = vA + vB + reminder;
+    data.push(current >>> 0);
+    reminder = ~~(current / 0x100000000);
+  }
+
+  if (reminder !== 0) {
+    data.push(reminder);
+  }
+
+  return {
+    sign: arrayIntA.sign,
+    data: data.reverse()
+  };
+}
+/**
+ * Add one to a given positive ArrayInt
+ * @internal
+ */
+
+
+function addOneToPositiveArrayInt(arrayInt) {
+  arrayInt.sign = 1; // handling case { sign: -1, data: [0,...,0] }
+
+  const data = arrayInt.data;
+
+  for (let index = data.length - 1; index >= 0; --index) {
+    if (data[index] === 0xffffffff) {
+      data[index] = 0;
+    } else {
+      data[index] += 1;
+      return arrayInt;
+    }
+  }
+
+  data.unshift(1);
+  return arrayInt;
+}
+/** @internal */
+
+
+function isStrictlySmaller(dataA, dataB) {
+  const maxLength = Math.max(dataA.length, dataB.length);
+
+  for (let index = 0; index < maxLength; ++index) {
+    const indexA = index + dataA.length - maxLength;
+    const indexB = index + dataB.length - maxLength;
+    const vA = indexA >= 0 ? dataA[indexA] : 0;
+    const vB = indexB >= 0 ? dataB[indexB] : 0;
+    if (vA < vB) return true;
+    if (vA > vB) return false;
+  }
+
+  return false;
+}
+/**
+ * Substract two ArrayInt
+ * @internal
+ */
+
+
+function substractArrayIntToNew(arrayIntA, arrayIntB) {
+  if (arrayIntA.sign !== arrayIntB.sign) {
+    return addArrayIntToNew(arrayIntA, {
+      sign: -arrayIntB.sign,
+      data: arrayIntB.data
+    });
+  }
+
+  const dataA = arrayIntA.data;
+  const dataB = arrayIntB.data;
+
+  if (isStrictlySmaller(dataA, dataB)) {
+    const out = substractArrayIntToNew(arrayIntB, arrayIntA);
+    out.sign = -out.sign;
+    return out;
+  }
+
+  const data = [];
+  let reminder = 0;
+
+  for (let indexA = dataA.length - 1, indexB = dataB.length - 1; indexA >= 0 || indexB >= 0; --indexA, --indexB) {
+    const vA = indexA >= 0 ? dataA[indexA] : 0;
+    const vB = indexB >= 0 ? dataB[indexB] : 0;
+    const current = vA - vB - reminder;
+    data.push(current >>> 0);
+    reminder = current < 0 ? 1 : 0;
+  }
+
+  return {
+    sign: arrayIntA.sign,
+    data: data.reverse()
+  };
+}
+/**
+ * Trim uneeded zeros in ArrayInt
+ * and uniform notation for zero: {sign: 1, data: [0]}
+ */
+
+
+function trimArrayIntInplace(arrayInt) {
+  const data = arrayInt.data;
+  let firstNonZero = 0; // eslint-disable-next-line no-empty
+
+  for (; firstNonZero !== data.length && data[firstNonZero] === 0; ++firstNonZero) {}
+
+  if (firstNonZero === data.length) {
+    // only zeros
+    arrayInt.sign = 1;
+    arrayInt.data = [0];
+    return arrayInt;
+  }
+
+  data.splice(0, firstNonZero);
+  return arrayInt;
+}
+/**
+ * We only accept safe integers here
+ * @internal
+ */
+
+
+function fromNumberToArrayInt64(out, n) {
+  if (n < 0) {
+    const posN = -n;
+    out.sign = -1;
+    out.data[0] = ~~(posN / 0x100000000);
+    out.data[1] = posN >>> 0;
+  } else {
+    out.sign = 1;
+    out.data[0] = ~~(n / 0x100000000);
+    out.data[1] = n >>> 0;
+  }
+
+  return out;
+}
+/**
+ * Substract two ArrayInt of 64 bits on 64 bits.
+ * With arrayIntA - arrayIntB >= 0
+ * @internal
+ */
+
+
+function substractArrayInt64(out, arrayIntA, arrayIntB) {
+  const lowA = arrayIntA.data[1];
+  const highA = arrayIntA.data[0];
+  const signA = arrayIntA.sign;
+  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;
+    const high = highA + highB + (low > 0xffffffff ? 1 : 0);
+    out.data[0] = high >>> 0;
+    out.data[1] = low >>> 0;
+    return out;
+  } // signA === -1 with signB === 1 is impossible given: arrayIntA - arrayIntB >= 0
+  // Operation is a substraction
+
+
+  let lowFirst = lowA;
+  let highFirst = highA;
+  let lowSecond = lowB;
+  let highSecond = highB;
+
+  if (signA === -1) {
+    lowFirst = lowB;
+    highFirst = highB;
+    lowSecond = lowA;
+    highSecond = highA;
+  }
+
+  let reminderLow = 0;
+  let low = lowFirst - lowSecond;
+
+  if (low < 0) {
+    reminderLow = 1;
+    low = low >>> 0;
+  }
+
+  out.data[0] = highFirst - highSecond - reminderLow;
+  out.data[1] = low;
+  return out;
+}
+//# sourceMappingURL=ArrayInt.cjs.map