@fncts/test 0.0.21 → 0.0.23

package/_mjs/data/TestSuccess.mjs

@@ -1,31 +1,25 @@
 export class Succeeded {
   constructor(result) {
     this.result = result;
-    this._tag = "Succeeded"
-    /* TestSuccessTag.Succeeded */
-    ;
+    this._tag = "Succeeded" /* TestSuccessTag.Succeeded */;
   }
-
 }
+
 export class Ignored {
   constructor() {
-    this._tag = "Ignored"
-    /* TestSuccessTag.Ignored */
-    ;
+    this._tag = "Ignored" /* TestSuccessTag.Ignored */;
   }
-
 }
+
 export const TestSuccess = {};
 /**
  * @tsplus static fncts.test.TestSuccessOps Succeeded
  */
-
 export function succeeded(result) {
   return new Succeeded(result);
 }
 /**
  * @tsplus static fncts.test.TestSuccessOps Ignored
  */
-
 export const ignored = /*#__PURE__*/new Ignored();
 //# sourceMappingURL=TestSuccess.mjs.map

package/_mjs/data/TestSuccess.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"TestSuccess.mjs","mappings":"AAOA,OAAM,MAAOA,SAAP,CAAgB;EAEpBC,YAAqBC,MAArB,EAAqD;IAAhC;IADZ,YAAI;IAAA;IAAJ;EACgD;;AAFrC;AAKtB,OAAM,MAAOC,OAAP,CAAc;EAApBF;IACW,YAAI;IAAA;IAAJ;EACV;;AAFmB;AAcpB,OAAO,MAAMG,WAAW,GAAmB,EAApC;AAEP;;;;AAGA,OAAM,SAAUC,SAAV,CAAoBH,MAApB,EAAoD;EACxD,OAAO,IAAIF,SAAJ,CAAcE,MAAd,CAAP;AACD;AAED;;;;AAGA,OAAO,MAAMI,OAAO,gBAAG,IAAIH,OAAJ,EAAhB","names":["Succeeded","constructor","result","Ignored","TestSuccess","succeeded","ignored"],"sourceRoot":"","sources":["../../_src/data/TestSuccess.ts"],"sourcesContent":[null]}
+{"version":3,"file":"TestSuccess.mjs","mappings":"AAOA,OAAM,MAAOA,SAAS;EAEpBC,YAAqBC,MAAgC;IAAhC,WAAM,GAANA,MAAM;IADlB,SAAI;EAC2C;;;AAG1D,OAAM,MAAOC,OAAO;EAApBF;IACW,SAAI;EACf;;;AAYA,OAAO,MAAMG,WAAW,GAAmB,EAAE;AAE7C;;;AAGA,OAAM,SAAUC,SAAS,CAACH,MAAgC;EACxD,OAAO,IAAIF,SAAS,CAACE,MAAM,CAAC;AAC9B;AAEA;;;AAGA,OAAO,MAAMI,OAAO,gBAAG,IAAIH,OAAO,EAAE","names":["Succeeded","constructor","result","Ignored","TestSuccess","succeeded","ignored"],"sourceRoot":"","sources":["../../_src/data/TestSuccess.ts"],"sourcesContent":[null]}

package/_mjs/data/TestTimeoutException.mjs

@@ -2,6 +2,5 @@ export class TestTimeoutException extends Error {
   constructor(message) {
     super(message);
   }
-
 }
 //# sourceMappingURL=TestTimeoutException.mjs.map

package/_mjs/data/TestTimeoutException.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"TestTimeoutException.mjs","mappings":"AAAA,OAAM,MAAOA,oBAAP,SAAoCC,KAApC,CAAyC;EAC7CC,YAAYC,OAAZ,EAA2B;IACzB,MAAMA,OAAN;EACD;;AAH4C","names":["TestTimeoutException","Error","constructor","message"],"sourceRoot":"","sources":["../../_src/data/TestTimeoutException.ts"],"sourcesContent":[null]}
+{"version":3,"file":"TestTimeoutException.mjs","mappings":"AAAA,OAAM,MAAOA,oBAAqB,SAAQC,KAAK;EAC7CC,YAAYC,OAAe;IACzB,KAAK,CAACA,OAAO,CAAC;EAChB","names":["TestTimeoutException","Error","constructor","message"],"sourceRoot":"","sources":["../../_src/data/TestTimeoutException.ts"],"sourcesContent":[null]}

package/_mjs/demo.mjs

@@ -4,7 +4,6 @@ import { DefaultRunnableSpec } from "@fncts/test/control/DefaultRunnableSpec";
 import { suite, test } from "./api.mjs";
 import { strictEqualTo } from "./control/Assertion.mjs";
 const ServiceATag = /*#__PURE__*/tsplus_module_1.makeTag("fncts.test.demo.ServiceA");
-
 class DemoSpec extends DefaultRunnableSpec {
   constructor() {
     super(...arguments);
@@ -26,8 +25,6 @@ class DemoSpec extends DefaultRunnableSpec {
       }
     })));
   }
-
 }
-
 new DemoSpec().main();
 //# sourceMappingURL=demo.mjs.map

package/_mjs/demo.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"demo.mjs","mappings":";;AAAA,SAASA,mBAAT,QAAoC,yCAApC;AAEA,SAASC,KAAT,EAAgBC,IAAhB,QAAoC,WAApC;AACA,SAASC,aAAT,QAA8B,yBAA9B;AACA,MAAMC,WAAW,gBAAGC,wBAEjB,0BAFiB,CAApB;;AAGA,MAAMC,QAAN,SAAuBN,mBAAvB,CAA0C;EAA1CO;;IACE,YAAON,KAAK,CACV,WADU,EAEVC,IAAI,CAAC,cAAD,EAAe,MAAEM,uBAAWL,aAAa,CAAC,CAAD,CAAxB,EAAC,CAAD,CAAjB,CAFM,EAGVD,IAAI,CAAC,cAAD,EAAe,MAAEM,uBAAuCL,aAAa,CAAC;MAAEM,CAAC,EAAE;QAAEC,CAAC,EAAE;UAAEC,CAAC,EAAE;YAAEC,CAAC,EAAE;UAAL;QAAL;MAAL;IAAL,CAAD,CAApD;MAAEH,CAAC,EAAE;QAAEC,CAAC,EAAE;UAAEC,CAAC,EAAE;YAAEC,CAAC,EAAE;UAAL;QAAL;MAAL;IAAL,EAAjB,CAHM,CAAZ;EAKD;;AANyC;;AAO1C,IAAIN,QAAJ,GAAeO,IAAf","names":["DefaultRunnableSpec","suite","test","strictEqualTo","ServiceATag","tsplus_module_1","DemoSpec","constructor","tsplus_module_2","a","b","c","d","main"],"sourceRoot":"","sources":["../_src/demo.ts"],"sourcesContent":[null]}
+{"version":3,"file":"demo.mjs","mappings":";;AAAA,SAASA,mBAAmB,QAAQ,yCAAyC;AAE7E,SAASC,KAAK,EAAEC,IAAI,QAAgB,WAAU;AAC9C,SAASC,aAAa,QAAQ,yBAAwB;AACtD,MAAMC,WAAW,gBAAGC,wBAEjB,0BAA0B,CAAC;AAC9B,MAAMC,QAAS,SAAQN,mBAAmB;EAA1CO;;IACE,SAAI,GAAGN,KAAK,CACV,WAAW,EACXC,IAAI,CAAC,cAAc,QAAEM,uBAAWL,aAAa,CAAC,CAAC,CAAC,EAA1B,CAAC,CAA0B,CAAC,EAClDD,IAAI,CAAC,cAAc,QAAEM,uBAAuCL,aAAa,CAAC;MAAEM,CAAC,EAAE;QAAEC,CAAC,EAAE;UAAEC,CAAC,EAAE;YAAEC,CAAC,EAAE;UAAC;QAAE;MAAE;IAAE,CAAE,CAAC,EAAnF;MAAEH,CAAC,EAAE;QAAEC,CAAC,EAAE;UAAEC,CAAC,EAAE;YAAEC,CAAC,EAAE;UAAG;QAAE;MAAE;IAAE,CAAE,CAAqD,CAAC,CAC3G;EACH;;AACA,IAAIN,QAAQ,EAAE,CAACO,IAAI,EAAE","names":["DefaultRunnableSpec","suite","test","strictEqualTo","ServiceATag","tsplus_module_1","DemoSpec","constructor","tsplus_module_2","a","b","c","d","main"],"sourceRoot":"","sources":["../_src/demo.ts"],"sourcesContent":[null]}

package/_mjs/util/math.mjs

@@ -2,47 +2,34 @@ const fileName_1 = "(@fncts/test) src/util/math.ts";
 import * as tsplus_module_1 from "@fncts/io/IO/api";
 import * as tsplus_module_2 from "@fncts/io/Random/api";
 /** @internal */
-
 export const MIN_VALUE_32 = 2 ** -126 * 2 ** -23;
 /** @internal */
-
 export const MAX_VALUE_32 = 2 ** 127 * (1 + (2 ** 23 - 1) / 2 ** 23);
 /** @internal */
-
 export const EPSILON_32 = 2 ** -23;
 /** @internal */
-
 const INDEX_POSITIVE_INFINITY_32 = 2139095040; // floatToIndex(MAX_VALUE_32) + 1;
-
 /** @internal */
-
 const INDEX_NEGATIVE_INFINITY_32 = -2139095041; // floatToIndex(-MAX_VALUE_32) - 1
-
 export function safeFloatToIndex(f, label) {
   const conversionTrick = "you can convert any double to a 32-bit float by using `new Float32Array([myDouble])[0]`";
   const errorMessage = "fc.floatNext constraints." + label + " must be a 32-bit float - " + conversionTrick;
-
   if (Number.isNaN(f) || Number.isFinite(f) && (f < -MAX_VALUE_32 || f > MAX_VALUE_32)) {
     return tsplus_module_1.haltNow(new Error(errorMessage), fileName_1 + ":16:22");
   }
-
   const index = floatToIndex(f);
-
   if (!Number.isInteger(index)) {
     return tsplus_module_1.haltNow(new Error(errorMessage), fileName_1 + ":20:22");
   }
-
   return tsplus_module_1.succeedNow(index, fileName_1 + ":22:23");
 }
 export function decomposeFloat(f) {
   // 1 => significand 0b1   - exponent 1 (will be preferred)
   //   => significand 0b0.1 - exponent 2
   const maxSignificand = 1 + (2 ** 23 - 1) / 2 ** 23;
-
   for (let exponent = -126; exponent !== 128; ++exponent) {
     const powExponent = 2 ** exponent;
     const maxForExponent = maxSignificand * powExponent;
-
     if (Math.abs(f) <= maxForExponent) {
       return {
         exponent,
@@ -50,7 +37,6 @@ export function decomposeFloat(f) {
       };
     }
   }
-
   return {
     exponent: Number.NaN,
     significand: Number.NaN
@@ -60,20 +46,16 @@ export function floatToIndex(f) {
   if (f === Number.POSITIVE_INFINITY) {
     return INDEX_POSITIVE_INFINITY_32;
   }
-
   if (f === Number.NEGATIVE_INFINITY) {
     return INDEX_NEGATIVE_INFINITY_32;
   }
-
   const {
     exponent,
     significand
   } = decomposeFloat(f);
-
   if (Number.isNaN(exponent) || Number.isNaN(significand) || !Number.isInteger(significand * 0x800000)) {
     return Number.NaN;
   }
-
   if (f > 0 || f === 0 && 1 / f === Number.POSITIVE_INFINITY) {
     return indexInFloatFromDecomp(exponent, significand);
   } else {
@@ -81,7 +63,6 @@ export function floatToIndex(f) {
   }
 }
 /** @internal */
-
 export function indexInFloatFromDecomp(exponent, significand) {
   // WARNING: significand >= 0
   // By construct of significand in decomposeFloat,
@@ -92,10 +73,9 @@ export function indexInFloatFromDecomp(exponent, significand) {
   // All other ranges (other exponents) have a length of 2**23 elements.
   if (exponent === -126) {
     return significand * 0x800000; // significand * 2**23
-  } // Offset due to exp = -126 + Offset of previous exp (excl. -126) + Offset in current exp
+  }
+  // Offset due to exp = -126 + Offset of previous exp (excl. -126) + Offset in current exp
   // 2**24 + (exponent - (-126) -1) * 2**23 + (significand - 1) * 2**23
-
-
   return (exponent + 127) * 0x800000 + (significand - 1) * 0x800000;
 }
 /**
@@ -105,58 +85,48 @@ export function indexInFloatFromDecomp(exponent, significand) {
  *
  * @internal
  */
-
 export function indexToFloat(index) {
   if (index < 0) {
     return -indexToFloat(-index - 1);
   }
-
   if (index === INDEX_POSITIVE_INFINITY_32) {
     return Number.POSITIVE_INFINITY;
   }
-
   if (index < 0x1000000) {
     // The first 2**24 elements correspond to values having
     // exponent = -126 and significand = index * 2**(-23)
     return index * 2 ** -149;
   }
-
-  const postIndex = index - 0x1000000; // Math.floor(postIndex / 0x800000) = Math.floor(postIndex / 2**23) = (postIndex >> 23)
-
-  const exponent = -125 + (postIndex >> 23); // (postIndex % 0x800000) / 0x800000 = (postIndex & 0x7fffff) / 0x800000
-
+  const postIndex = index - 0x1000000;
+  // Math.floor(postIndex / 0x800000) = Math.floor(postIndex / 2**23) = (postIndex >> 23)
+  const exponent = -125 + (postIndex >> 23);
+  // (postIndex % 0x800000) / 0x800000 = (postIndex & 0x7fffff) / 0x800000
   const significand = 1 + (postIndex & 0x7fffff) / 0x800000;
   return significand * 2 ** exponent;
 }
 /** @internal */
-
 export const Zero64 = {
   sign: 1,
   data: [0, 0]
 };
 /** @internal */
-
 export const Unit64 = {
   sign: 1,
   data: [0, 1]
 };
 /** @internal */
-
 export function isZero64(a) {
   return a.data[0] === 0 && a.data[1] === 0;
 }
 /** @internal */
-
 export function isStrictlyNegative64(a) {
   return a.sign === -1 && !isZero64(a);
 }
 /** @internal */
-
 export function isStrictlyPositive64(a) {
   return a.sign === 1 && !isZero64(a);
 }
 /** @internal */
-
 export function isEqual64(a, b) {
   if (a.data[0] === b.data[0] && a.data[1] === b.data[1]) {
     return a.sign === b.sign || a.data[0] === 0 && a.data[1] === 0; // either the same or both zero
@@ -165,24 +135,19 @@ export function isEqual64(a, b) {
   return false;
 }
 /** @internal */
-
 function isStrictlySmaller64Internal(a, b) {
   return a[0] < b[0] || a[0] === b[0] && a[1] < b[1];
 }
 /** @internal */
-
-
 export function isStrictlySmaller64(a, b) {
   if (a.sign === b.sign) {
     return a.sign === 1 ? isStrictlySmaller64Internal(a.data, b.data) // a.sign = +1, b.sign = +1
     : isStrictlySmaller64Internal(b.data, a.data); // a.sign = -1, b.sign = -1
-  } // a.sign = +1, b.sign = -1 is always false
-
-
+  }
+  // a.sign = +1, b.sign = -1 is always false
   return a.sign === -1 && (!isZero64(a) || !isZero64(b)); // a.sign = -1, b.sign = +1
 }
 /** @internal */
-
 export function clone64(a) {
   return {
     sign: a.sign,
@@ -190,24 +155,19 @@ export function clone64(a) {
   };
 }
 /** @internal */
-
 function substract64DataInternal(a, b) {
   let reminderLow = 0;
   let low = a[1] - b[1];
-
   if (low < 0) {
     reminderLow = 1;
     low = low >>> 0;
   }
-
   return [a[0] - b[0] - reminderLow, low];
 }
 /**
  * Expects a >= b
  * @internal
  */
-
-
 function substract64Internal(a, b) {
   if (a.sign === 1 && b.sign === -1) {
     // Operation is a simple sum of a + abs(b)
@@ -217,10 +177,9 @@ function substract64Internal(a, b) {
       sign: 1,
       data: [high >>> 0, low >>> 0]
     };
-  } // a.sign === -1 with b.sign === 1 is impossible given: a - b >= 0, except for a = 0 and b = 0
+  }
+  // a.sign === -1 with b.sign === 1 is impossible given: a - b >= 0, except for a = 0 and b = 0
   // Operation is a substraction
-
-
   return {
     sign: 1,
     data: a.sign === 1 ? substract64DataInternal(a.data, b.data) : substract64DataInternal(b.data, a.data)
@@ -231,22 +190,18 @@ function substract64Internal(a, b) {
  * @returns When result is zero always with sign=1
  * @internal
  */
-
-
 export function substract64(arrayIntA, arrayIntB) {
   if (isStrictlySmaller64(arrayIntA, arrayIntB)) {
     const out = substract64Internal(arrayIntB, arrayIntA);
     out.sign = -1;
     return out;
   }
-
   return substract64Internal(arrayIntA, arrayIntB);
 }
 /**
  * Negative version of an ArrayInt64
  * @internal
  */
-
 export function negative64(arrayIntA) {
   return {
     sign: -arrayIntA.sign,
@@ -258,23 +213,19 @@ export function negative64(arrayIntA) {
  * @returns When result is zero always with sign=1
  * @internal
  */
-
 export function add64(arrayIntA, arrayIntB) {
   if (isZero64(arrayIntB)) {
     if (isZero64(arrayIntA)) {
       return clone64(Zero64);
     }
-
     return clone64(arrayIntA);
   }
-
   return substract64(arrayIntA, negative64(arrayIntB));
 }
 /**
  * Halve an ArrayInt64
  * @internal
  */
-
 export function halve64(a) {
   return {
     sign: a.sign,
@@ -285,7 +236,6 @@ export function halve64(a) {
  * Apply log2 to an ArrayInt64 (preserve sign)
  * @internal
  */
-
 export function logLike64(a) {
   // Math.floor(Math.log(hi * 2**32 + low) / Math.log(2)) <= Math.floor(Math.log(2**64) / Math.log(2)) = 64
   return {
@@ -294,19 +244,15 @@ export function logLike64(a) {
   };
 }
 /** @internal */
-
 const INDEX_POSITIVE_INFINITY = {
   sign: 1,
   data: [2146435072, 0]
 }; // doubleToIndex(Number.MAX_VALUE) + 1;
-
 /** @internal */
-
 const INDEX_NEGATIVE_INFINITY = {
   sign: -1,
   data: [2146435072, 1]
 }; // doubleToIndex(-Number.MAX_VALUE) - 1
-
 /**
  * Decompose a 64-bit floating point number into a significand and exponent
  * such that:
@@ -322,16 +268,13 @@ const INDEX_NEGATIVE_INFINITY = {
  *
  * @internal
  */
-
 export function decomposeDouble(d) {
   // 1 => significand 0b1   - exponent 1 (will be preferred)
   //   => significand 0b0.1 - exponent 2
   const maxSignificand = 2 - Number.EPSILON;
-
   for (let exponent = -1022; exponent !== 1024; ++exponent) {
     const powExponent = 2 ** exponent;
     const maxForExponent = maxSignificand * powExponent;
-
     if (Math.abs(d) <= maxForExponent) {
       return {
         exponent,
@@ -339,20 +282,16 @@ export function decomposeDouble(d) {
       };
     }
   }
-
   return {
     exponent: Number.NaN,
     significand: Number.NaN
   };
 }
 /** @internal */
-
 function positiveNumberToInt64(n) {
   return [~~(n / 0x100000000), n >>> 0];
 }
 /** @internal */
-
-
 function indexInDoubleFromDecomp(exponent, significand) {
   // WARNING: significand >= 0
   // By construct of significand in decomposeDouble,
@@ -364,17 +303,13 @@ function indexInDoubleFromDecomp(exponent, significand) {
   if (exponent === -1022) {
     // We want the significand to be an integer value (like an index)
     const rescaledSignificand = significand * 2 ** 52; // significand * 2**52
-
     return positiveNumberToInt64(rescaledSignificand);
-  } // Offset due to exp = -1022 + Offset of previous exp (excl. -1022) + Offset in current exp
+  }
+  // Offset due to exp = -1022 + Offset of previous exp (excl. -1022) + Offset in current exp
   // 2**53 + (exponent - (-1022) -1) * 2**52 + (significand - 1) * 2**52
   // (exponent + 1023) * 2**52 + (significand - 1) * 2**52
-
-
   const rescaledSignificand = (significand - 1) * 2 ** 52; // (significand-1) * 2**52
-
   const exponentOnlyHigh = (exponent + 1023) * 2 ** 20; // (exponent + 1023) * 2**52 => [high: (exponent + 1023) * 2**20, low: 0]
-
   const index = positiveNumberToInt64(rescaledSignificand);
   index[0] += exponentOnlyHigh;
   return index;
@@ -387,21 +322,16 @@ function indexInDoubleFromDecomp(exponent, significand) {
  *
  * @internal
  */
-
-
 export function doubleToIndex(d) {
   if (d === Number.POSITIVE_INFINITY) {
     return clone64(INDEX_POSITIVE_INFINITY);
   }
-
   if (d === Number.NEGATIVE_INFINITY) {
     return clone64(INDEX_NEGATIVE_INFINITY);
   }
-
   const decomp = decomposeDouble(d);
   const exponent = decomp.exponent;
   const significand = decomp.significand;
-
   if (d > 0 || d === 0 && 1 / d === Number.POSITIVE_INFINITY) {
     return {
       sign: 1,
@@ -409,14 +339,12 @@ export function doubleToIndex(d) {
     };
   } else {
     const indexOpposite = indexInDoubleFromDecomp(exponent, -significand);
-
     if (indexOpposite[1] === 0xffffffff) {
       indexOpposite[0] += 1;
       indexOpposite[1] = 0;
     } else {
       indexOpposite[1] += 1;
     }
-
     return {
       sign: -1,
       data: indexOpposite
@@ -430,28 +358,24 @@ export function doubleToIndex(d) {
  *
  * @internal
  */
-
 export function indexToDouble(index) {
   if (index.sign === -1) {
     const indexOpposite = {
       sign: 1,
       data: [index.data[0], index.data[1]]
     };
-
     if (indexOpposite.data[1] === 0) {
       indexOpposite.data[0] -= 1;
       indexOpposite.data[1] = 0xffffffff;
     } else {
       indexOpposite.data[1] -= 1;
     }
-
     return -indexToDouble(indexOpposite); // -indexToDouble(-index - 1);
   }
 
   if (isEqual64(index, INDEX_POSITIVE_INFINITY)) {
     return Number.POSITIVE_INFINITY;
   }
-
   if (index.data[0] < 0x200000) {
     // if: index < 2 ** 53  <--> index[0] < 2 ** (53-32) = 0x20_0000
     // The first 2**53 elements correspond to values having
@@ -461,19 +385,17 @@ export function indexToDouble(index) {
     //              = index * 2 ** -1074
     return (index.data[0] * 0x100000000 + index.data[1]) * 2 ** -1074;
   }
-
   const postIndexHigh = index.data[0] - 0x200000; // postIndex = index - 2 ** 53
   // exponent = -1021 + Math.floor(postIndex / 2**52)
   //          = -1021 + Math.floor(postIndexHigh / 2**(52-32))
   //          = -1021 + Math.floor(postIndexHigh / 2**20)
   //          = -1021 + (postIndexHigh >> 20)
-
-  const exponent = -1021 + (postIndexHigh >> 20); // significand = 1 + (postIndex % 2**52) / 2**52
+  const exponent = -1021 + (postIndexHigh >> 20);
+  // significand = 1 + (postIndex % 2**52) / 2**52
   //             = 1 + ((postIndexHigh * 2**32 + postIndexLow) % 2**52) / 2**52
   //             = 1 + ((postIndexHigh % 2**20) * 2**32 + postIndexLow) / 2**52
   //             = 1 + ((postIndexHigh & 0xfffff) * 2**32 + postIndexLow) / 2**52
   //             = 1 + ((postIndexHigh & 0xfffff) * 2**32 + postIndexLow) * Number.EPSILON
-
   const significand = 1 + ((postIndexHigh & 0xfffff) * 2 ** 32 + index.data[1]) * Number.EPSILON;
   return significand * 2 ** exponent;
 }
@@ -482,13 +404,11 @@ export function indexToDouble(index) {
  *
  * @internal
  */
-
 export function safeDoubleToIndex(d, label) {
   if (Number.isNaN(d)) {
     // Number.NaN does not have any associated index in the current implementation
     return tsplus_module_1.haltNow(new Error("fc.doubleNext constraints." + label + " must be a 32-bit float"), fileName_1 + ":403:22");
   }
-
   return tsplus_module_1.succeedNow(doubleToIndex(d), fileName_1 + ":405:23");
 }
 const EPSILON = /*#__PURE__*/Math.pow(2, -52);
@@ -498,41 +418,30 @@ export function nextUp(x) {
   if (x !== x) {
     return x;
   }
-
   if (x === -1 / 0) {
     return -MAX_VALUE;
   }
-
   if (x === +1 / 0) {
     return +1 / 0;
   }
-
   if (x === +MAX_VALUE) {
     return +1 / 0;
   }
-
   let y = x * (x < 0 ? 1 - EPSILON / 2 : 1 + EPSILON);
-
   if (y === x) {
     y = MIN_VALUE * EPSILON > 0 ? x + MIN_VALUE * EPSILON : x + MIN_VALUE;
   }
-
   if (y === +1 / 0) {
     y = +MAX_VALUE;
   }
-
   const b = x + (y - x) / 2;
-
   if (x < b && b < y) {
     y = b;
   }
-
   const c = (y + x) / 2;
-
   if (x < c && c < y) {
     y = c;
   }
-
   return y === 0 ? -0 : y;
 }
 export function nextAfter(x, y) {
@@ -542,17 +451,14 @@ export function computeBiasedRanges(min, max, biasedRanges) {
   if (biasedRanges != null) {
     return biasedRanges;
   }
-
   if (isEqual64(min, max)) {
     return [{
       min,
       max
     }];
   }
-
   const minStrictlySmallerThanZero = isStrictlyNegative64(min);
   const maxStrictlyGreaterThanZero = isStrictlyPositive64(max);
-
   if (minStrictlySmallerThanZero && maxStrictlyGreaterThanZero) {
     const logMin = logLike64(min);
     const logMax = logLike64(max);
@@ -587,13 +493,10 @@ export function computeArrayInt64GenerateRange(min, max, biasFactor, biasedRange
         max
       };
     }
-
     const ranges = computeBiasedRanges(min, max, biasedRanges);
-
     if (ranges.length === 1) {
       return ranges[0];
     }
-
     const id = yield* _(tsplus_module_2.nextIntBetween(-2 * (ranges.length - 1), ranges.length - 2, fileName_1 + ":504:46"), fileName_1 + ":504:24");
     return id < 0 ? ranges[0] : ranges[id + 1];
   }, fileName_1 + ":496:16");