ts-data-forge 5.0.0 → 5.1.0

package/src/number/branded-types/positive-int16.test.mts

@@ -10,7 +10,9 @@ describe('PositiveInt16 test', () => {
   describe(asPositiveInt16, () => {
     test('accepts valid positive int16 values', () => {
       expect(() => asPositiveInt16(1)).not.toThrow();
+
       expect(() => asPositiveInt16(1000)).not.toThrow();
+
       expect(() => asPositiveInt16(32_767)).not.toThrow(); // 2^15 - 1
     });
 
@@ -20,29 +22,37 @@ describe('PositiveInt16 test', () => {
 
     test('rejects values outside int16 range', () => {
       expect(() => asPositiveInt16(32_768)).toThrow(TypeError); // 2^15
+
       expect(() => asPositiveInt16(65_536)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asPositiveInt16(-1)).toThrow(TypeError);
+
       expect(() => asPositiveInt16(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asPositiveInt16(Number.NaN)).toThrow(TypeError);
+
       expect(() => asPositiveInt16(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveInt16(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveInt16(1.2)).toThrow(TypeError);
+
       expect(() => asPositiveInt16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asPositiveInt16(5)).toBe(5);
+
       expect(asPositiveInt16(1)).toBe(1);
+
       expect(asPositiveInt16(32_767)).toBe(32_767);
     });
 
@@ -70,7 +80,9 @@ describe('PositiveInt16 test', () => {
   describe(isPositiveInt16, () => {
     test('correctly identifies positive int16 values', () => {
       expect(isPositiveInt16(1)).toBe(true);
+
       expect(isPositiveInt16(1000)).toBe(true);
+
       expect(isPositiveInt16(32_767)).toBe(true);
     });
 
@@ -80,19 +92,25 @@ describe('PositiveInt16 test', () => {
 
     test('correctly identifies values outside int16 range', () => {
       expect(isPositiveInt16(32_768)).toBe(false);
+
       expect(isPositiveInt16(65_536)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isPositiveInt16(-1)).toBe(false);
+
       expect(isPositiveInt16(-42)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isPositiveInt16(Number.NaN)).toBe(false);
+
       expect(isPositiveInt16(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isPositiveInt16(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isPositiveInt16(1.2)).toBe(false);
+
       expect(isPositiveInt16(-3.4)).toBe(false);
     });
   });
@@ -100,7 +118,9 @@ describe('PositiveInt16 test', () => {
   describe('PositiveInt16.is', () => {
     test('same as isPositiveInt16 function', () => {
       expect(PositiveInt16.is(5)).toBe(isPositiveInt16(5));
+
       expect(PositiveInt16.is(0)).toBe(isPositiveInt16(0));
+
       expect(PositiveInt16.is(-1)).toBe(isPositiveInt16(-1));
     });
   });
@@ -108,16 +128,19 @@ describe('PositiveInt16 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(PositiveInt16.MIN_VALUE).toBe(1);
+
       expect(PositiveInt16.MAX_VALUE).toBe(32_767);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asPositiveInt16(100);
+
     const b = asPositiveInt16(50);
 
     test('min and max', () => {
       expect(PositiveInt16.min(a, b)).toBe(50);
+
       expect(PositiveInt16.max(a, b)).toBe(100);
     });
 
@@ -128,11 +151,13 @@ describe('PositiveInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(PositiveInt16.add(a, b)).toBe(150);
     });
 
     test('sub (never goes below 1)', () => {
       expect(PositiveInt16.sub(a, b)).toBe(50);
+
       expect(PositiveInt16.sub(b, a)).toBe(1); // clamped to 1
     });
 
@@ -143,6 +168,7 @@ describe('PositiveInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(PositiveInt16.mul(asPositiveInt16(10), asPositiveInt16(5))).toBe(
         50,
       );
@@ -150,7 +176,9 @@ describe('PositiveInt16 test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(PositiveInt16.div(a, asPositiveInt16(50))).toBe(2);
+
       expect(PositiveInt16.div(asPositiveInt16(7), asPositiveInt16(3))).toBe(2);
+
       expect(PositiveInt16.div(asPositiveInt16(50), asPositiveInt16(100))).toBe(
         1,
       ); // floor(50/100) = 0, clamped to 1
@@ -163,6 +191,7 @@ describe('PositiveInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(PositiveInt16.pow(asPositiveInt16(2), asPositiveInt16(3))).toBe(8);
     });
   });
@@ -170,15 +199,20 @@ describe('PositiveInt16 test', () => {
   describe('random', () => {
     test('generates positive int16 values within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = PositiveInt16.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(PositiveInt16.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).toBeGreaterThan(0);
       }
     });
@@ -188,6 +222,7 @@ describe('PositiveInt16 test', () => {
         const result = PositiveInt16.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(32_767);
       }
     });

package/src/number/branded-types/positive-int32.test.mts

@@ -10,7 +10,9 @@ describe('PositiveInt32 test', () => {
   describe(asPositiveInt32, () => {
     test('accepts valid positive int32 values', () => {
       expect(() => asPositiveInt32(1)).not.toThrow();
+
       expect(() => asPositiveInt32(1000)).not.toThrow();
+
       expect(() => asPositiveInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
     });
 
@@ -20,29 +22,37 @@ describe('PositiveInt32 test', () => {
 
     test('rejects values outside int32 range', () => {
       expect(() => asPositiveInt32(2_147_483_648)).toThrow(TypeError); // 2^31
+
       expect(() => asPositiveInt32(4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asPositiveInt32(-1)).toThrow(TypeError);
+
       expect(() => asPositiveInt32(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asPositiveInt32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asPositiveInt32(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveInt32(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveInt32(1.2)).toThrow(TypeError);
+
       expect(() => asPositiveInt32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asPositiveInt32(5)).toBe(5);
+
       expect(asPositiveInt32(1)).toBe(1);
+
       expect(asPositiveInt32(2_147_483_647)).toBe(2_147_483_647);
     });
 
@@ -70,7 +80,9 @@ describe('PositiveInt32 test', () => {
   describe(isPositiveInt32, () => {
     test('correctly identifies positive int32 values', () => {
       expect(isPositiveInt32(1)).toBe(true);
+
       expect(isPositiveInt32(1000)).toBe(true);
+
       expect(isPositiveInt32(2_147_483_647)).toBe(true);
     });
 
@@ -80,19 +92,25 @@ describe('PositiveInt32 test', () => {
 
     test('correctly identifies values outside int32 range', () => {
       expect(isPositiveInt32(2_147_483_648)).toBe(false);
+
       expect(isPositiveInt32(4_294_967_296)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isPositiveInt32(-1)).toBe(false);
+
       expect(isPositiveInt32(-42)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isPositiveInt32(Number.NaN)).toBe(false);
+
       expect(isPositiveInt32(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isPositiveInt32(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isPositiveInt32(1.2)).toBe(false);
+
       expect(isPositiveInt32(-3.4)).toBe(false);
     });
   });
@@ -100,7 +118,9 @@ describe('PositiveInt32 test', () => {
   describe('PositiveInt32.is', () => {
     test('same as isPositiveInt32 function', () => {
       expect(PositiveInt32.is(5)).toBe(isPositiveInt32(5));
+
       expect(PositiveInt32.is(0)).toBe(isPositiveInt32(0));
+
       expect(PositiveInt32.is(-1)).toBe(isPositiveInt32(-1));
     });
   });
@@ -108,16 +128,19 @@ describe('PositiveInt32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(PositiveInt32.MIN_VALUE).toBe(1);
+
       expect(PositiveInt32.MAX_VALUE).toBe(2_147_483_647);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asPositiveInt32(1_000_000);
+
     const b = asPositiveInt32(500_000);
 
     test('min and max', () => {
       expect(PositiveInt32.min(a, b)).toBe(500_000);
+
       expect(PositiveInt32.max(a, b)).toBe(1_000_000);
     });
 
@@ -128,11 +151,13 @@ describe('PositiveInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(PositiveInt32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (never goes below 1)', () => {
       expect(PositiveInt32.sub(a, b)).toBe(500_000);
+
       expect(PositiveInt32.sub(b, a)).toBe(1); // clamped to 1
     });
 
@@ -143,6 +168,7 @@ describe('PositiveInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(PositiveInt32.mul(asPositiveInt32(1000), asPositiveInt32(5))).toBe(
         5000,
       );
@@ -150,7 +176,9 @@ describe('PositiveInt32 test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(PositiveInt32.div(a, asPositiveInt32(500_000))).toBe(2);
+
       expect(PositiveInt32.div(asPositiveInt32(7), asPositiveInt32(3))).toBe(2);
+
       expect(
         PositiveInt32.div(asPositiveInt32(500_000), asPositiveInt32(1_000_000)),
       ).toBe(1); // floor(500000/1000000) = 0, clamped to 1
@@ -163,6 +191,7 @@ describe('PositiveInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(PositiveInt32.pow(asPositiveInt32(2), asPositiveInt32(3))).toBe(8);
     });
   });
@@ -170,15 +199,20 @@ describe('PositiveInt32 test', () => {
   describe('random', () => {
     test('generates positive int32 values within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = PositiveInt32.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(PositiveInt32.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).toBeGreaterThan(0);
       }
     });
@@ -188,6 +222,7 @@ describe('PositiveInt32 test', () => {
         const result = PositiveInt32.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(2_147_483_647);
       }
     });

package/src/number/branded-types/positive-safe-int.mts

@@ -26,7 +26,7 @@ const {
 >({
   integerOrSafeInteger: 'SafeInteger',
   MIN_VALUE: 1,
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-max-safe-integer
   MAX_VALUE: Number.MAX_SAFE_INTEGER as SafeUint,
   typeNameInMessage,
 } as const);
@@ -39,8 +39,11 @@ const {
  *
  * ```ts
  * assert.ok(isPositiveSafeInt(1));
+ *
  * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+ *
  * assert.notOk(isPositiveSafeInt(0));
+ *
  * assert.ok(PositiveSafeInt.is(42));
  * ```
  *
@@ -58,6 +61,7 @@ export const isPositiveSafeInt = is;
  * const branded = asPositiveSafeInt(128);
  *
  * assert(branded === 128);
+ *
  * assert.ok(PositiveSafeInt.is(branded));
  * ```
  *
@@ -84,8 +88,11 @@ export const PositiveSafeInt = {
    *
    * ```ts
    * assert.ok(isPositiveSafeInt(1));
+   *
    * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+   *
    * assert.notOk(isPositiveSafeInt(0));
+   *
    * assert.ok(PositiveSafeInt.is(42));
    * ```
    *
@@ -156,11 +163,15 @@ export const PositiveSafeInt = {
    *
    * ```ts
    * const belowRange = PositiveSafeInt.clamp(0);
+   *
    * const withinRange = PositiveSafeInt.clamp(123);
+   *
    * const aboveRange = PositiveSafeInt.clamp(Number.MAX_SAFE_INTEGER + 10);
    *
    * assert(belowRange === 1);
+   *
    * assert(withinRange === 123);
+   *
    * assert(aboveRange === Number.MAX_SAFE_INTEGER);
    * ```
    *
@@ -176,10 +187,13 @@ export const PositiveSafeInt = {
    *
    * ```ts
    * const min = asPositiveSafeInt(1);
+   *
    * const max = asPositiveSafeInt(6);
+   *
    * const randomValue = PositiveSafeInt.random(min, max);
    *
    * assert.ok(PositiveSafeInt.is(randomValue));
+   *
    * assert.ok(randomValue >= 1 && randomValue <= 6);
    * ```
    *
@@ -194,7 +208,9 @@ export const PositiveSafeInt = {
    *
    * ```ts
    * const base = asPositiveSafeInt(3);
+   *
    * const exponent = asPositiveSafeInt(3);
+   *
    * const power = PositiveSafeInt.pow(base, exponent);
    *
    * assert(power === 27);
@@ -218,6 +234,7 @@ export const PositiveSafeInt = {
    * );
    *
    * assert(sum === 3048);
+   *
    * assert.ok(PositiveSafeInt.is(sum));
    * ```
    *
@@ -239,6 +256,7 @@ export const PositiveSafeInt = {
    * );
    *
    * assert(difference === 1);
+   *
    * assert.ok(PositiveSafeInt.is(difference));
    * ```
    *
@@ -261,6 +279,7 @@ export const PositiveSafeInt = {
    * );
    *
    * assert(product === 1000);
+   *
    * assert.ok(PositiveSafeInt.is(product));
    * ```
    *
@@ -280,12 +299,14 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(25),
    *   asPositiveSafeInt(4),
    * );
+   *
    * const clamped = PositiveSafeInt.div(
    *   asPositiveSafeInt(5),
    *   asPositiveSafeInt(50),
    * );
    *
    * assert(quotient === 6);
+   *
    * assert(clamped === 1);
    * ```
    *

package/src/number/branded-types/positive-safe-int.test.mts

@@ -10,20 +10,27 @@ describe('PositiveSafeInt test', () => {
   describe(asPositiveSafeInt, () => {
     test('accepts valid positive safe integers', () => {
       expect(() => asPositiveSafeInt(1)).not.toThrow();
+
       expect(() => asPositiveSafeInt(2)).not.toThrow();
+
       expect(() => asPositiveSafeInt(42)).not.toThrow();
+
       expect(() => asPositiveSafeInt(100)).not.toThrow();
+
       expect(() => asPositiveSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects zero', () => {
       expect(() => asPositiveSafeInt(0)).toThrow(TypeError);
+
       expect(() => asPositiveSafeInt(-0)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asPositiveSafeInt(-1)).toThrow(TypeError);
+
       expect(() => asPositiveSafeInt(-42)).toThrow(TypeError);
+
       expect(() => asPositiveSafeInt(Number.MIN_SAFE_INTEGER)).toThrow(
         TypeError,
       );
@@ -33,24 +40,31 @@ describe('PositiveSafeInt test', () => {
       expect(() => asPositiveSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveSafeInt(Number.MAX_VALUE)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asPositiveSafeInt(Number.NaN)).toThrow(TypeError);
+
       expect(() => asPositiveSafeInt(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveSafeInt(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveSafeInt(1.2)).toThrow(TypeError);
+
       expect(() => asPositiveSafeInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asPositiveSafeInt(5)).toBe(5);
+
       expect(asPositiveSafeInt(1)).toBe(1);
+
       expect(asPositiveSafeInt(10)).toBe(10);
     });
 
@@ -75,33 +89,45 @@ describe('PositiveSafeInt test', () => {
   describe(isPositiveSafeInt, () => {
     test('correctly identifies positive safe integers', () => {
       expect(isPositiveSafeInt(1)).toBe(true);
+
       expect(isPositiveSafeInt(2)).toBe(true);
+
       expect(isPositiveSafeInt(42)).toBe(true);
+
       expect(isPositiveSafeInt(100)).toBe(true);
+
       expect(isPositiveSafeInt(Number.MAX_SAFE_INTEGER)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
       expect(isPositiveSafeInt(0)).toBe(false);
+
       expect(isPositiveSafeInt(-0)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isPositiveSafeInt(-1)).toBe(false);
+
       expect(isPositiveSafeInt(-42)).toBe(false);
+
       expect(isPositiveSafeInt(Number.MIN_SAFE_INTEGER)).toBe(false);
     });
 
     test('correctly identifies values outside safe integer range', () => {
       expect(isPositiveSafeInt(Number.MAX_SAFE_INTEGER + 1)).toBe(false);
+
       expect(isPositiveSafeInt(Number.MAX_VALUE)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isPositiveSafeInt(Number.NaN)).toBe(false);
+
       expect(isPositiveSafeInt(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isPositiveSafeInt(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isPositiveSafeInt(1.2)).toBe(false);
+
       expect(isPositiveSafeInt(-3.4)).toBe(false);
     });
   });
@@ -109,7 +135,9 @@ describe('PositiveSafeInt test', () => {
   describe('PositiveSafeInt.is', () => {
     test('same as isPositiveSafeInt function', () => {
       expect(PositiveSafeInt.is(5)).toBe(isPositiveSafeInt(5));
+
       expect(PositiveSafeInt.is(0)).toBe(isPositiveSafeInt(0));
+
       expect(PositiveSafeInt.is(-10)).toBe(isPositiveSafeInt(-10));
     });
   });
@@ -117,33 +145,43 @@ describe('PositiveSafeInt test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(PositiveSafeInt.MIN_VALUE).toBe(1);
+
       expect(PositiveSafeInt.MAX_VALUE).toBe(Number.MAX_SAFE_INTEGER);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asPositiveSafeInt(5);
+
     const b = asPositiveSafeInt(2);
+
     const c = asPositiveSafeInt(1);
 
     test('min and max', () => {
       expect(PositiveSafeInt.min(a, b)).toBe(2);
+
       expect(PositiveSafeInt.max(a, b)).toBe(5);
+
       expect(PositiveSafeInt.min(a, c)).toBe(1);
+
       expect(PositiveSafeInt.max(a, c)).toBe(5);
     });
 
     test('add (clamped to positive safe int range)', () => {
       const largeValue = asPositiveSafeInt(Number.MAX_SAFE_INTEGER - 1);
+
       const result = PositiveSafeInt.add(largeValue, asPositiveSafeInt(10));
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(PositiveSafeInt.add(a, b)).toBe(7);
     });
 
     test('sub (never goes below 1)', () => {
       expect(PositiveSafeInt.sub(a, b)).toBe(3);
+
       expect(PositiveSafeInt.sub(b, a)).toBe(1); // clamped to 1
+
       expect(PositiveSafeInt.sub(c, a)).toBe(1); // clamped to 1
     });
 
@@ -151,9 +189,11 @@ describe('PositiveSafeInt test', () => {
       const largeValue = asPositiveSafeInt(
         Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER)),
       );
+
       const result = PositiveSafeInt.mul(largeValue, largeValue);
 
       expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
+
       expect(
         PositiveSafeInt.mul(asPositiveSafeInt(10), asPositiveSafeInt(5)),
       ).toBe(50);
@@ -161,9 +201,11 @@ describe('PositiveSafeInt test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(PositiveSafeInt.div(a, b)).toBe(2);
+
       expect(
         PositiveSafeInt.div(asPositiveSafeInt(7), asPositiveSafeInt(3)),
       ).toBe(2);
+
       expect(PositiveSafeInt.div(b, a)).toBe(1); // floor(2/5) = 0, but clamped to 1
     });
 
@@ -174,6 +216,7 @@ describe('PositiveSafeInt test', () => {
       );
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(
         PositiveSafeInt.pow(asPositiveSafeInt(2), asPositiveSafeInt(3)),
       ).toBe(8);
@@ -183,15 +226,20 @@ describe('PositiveSafeInt test', () => {
   describe('random', () => {
     test('generates positive safe integers within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = PositiveSafeInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(PositiveSafeInt.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).toBeGreaterThan(0);
       }
     });
@@ -201,6 +249,7 @@ describe('PositiveSafeInt test', () => {
         const result = PositiveSafeInt.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       }
     });