ts-data-forge 5.0.1 → 5.1.0

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

@@ -10,8 +10,11 @@ describe('PositiveUint16 test', () => {
   describe(asPositiveUint16, () => {
     test('accepts valid positive uint16 values', () => {
       expect(() => asPositiveUint16(1)).not.toThrow();
+
       expect(() => asPositiveUint16(1000)).not.toThrow();
+
       expect(() => asPositiveUint16(65_535)).not.toThrow(); // 2^16 - 1
+
       expect(() => asPositiveUint16(32_768)).not.toThrow(); // 2^15
     });
 
@@ -21,29 +24,37 @@ describe('PositiveUint16 test', () => {
 
     test('rejects values outside uint16 range', () => {
       expect(() => asPositiveUint16(65_536)).toThrow(TypeError); // 2^16
+
       expect(() => asPositiveUint16(100_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asPositiveUint16(-1)).toThrow(TypeError);
+
       expect(() => asPositiveUint16(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asPositiveUint16(Number.NaN)).toThrow(TypeError);
+
       expect(() => asPositiveUint16(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveUint16(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveUint16(1.2)).toThrow(TypeError);
+
       expect(() => asPositiveUint16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asPositiveUint16(5)).toBe(5);
+
       expect(asPositiveUint16(1)).toBe(1);
+
       expect(asPositiveUint16(65_535)).toBe(65_535);
     });
 
@@ -71,8 +82,11 @@ describe('PositiveUint16 test', () => {
   describe(isPositiveUint16, () => {
     test('correctly identifies positive uint16 values', () => {
       expect(isPositiveUint16(1)).toBe(true);
+
       expect(isPositiveUint16(1000)).toBe(true);
+
       expect(isPositiveUint16(65_535)).toBe(true);
+
       expect(isPositiveUint16(32_768)).toBe(true);
     });
 
@@ -82,19 +96,25 @@ describe('PositiveUint16 test', () => {
 
     test('correctly identifies values outside uint16 range', () => {
       expect(isPositiveUint16(65_536)).toBe(false);
+
       expect(isPositiveUint16(100_000)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isPositiveUint16(-1)).toBe(false);
+
       expect(isPositiveUint16(-42)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isPositiveUint16(Number.NaN)).toBe(false);
+
       expect(isPositiveUint16(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isPositiveUint16(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isPositiveUint16(1.2)).toBe(false);
+
       expect(isPositiveUint16(-3.4)).toBe(false);
     });
   });
@@ -102,7 +122,9 @@ describe('PositiveUint16 test', () => {
   describe('PositiveUint16.is', () => {
     test('same as isPositiveUint16 function', () => {
       expect(PositiveUint16.is(5)).toBe(isPositiveUint16(5));
+
       expect(PositiveUint16.is(0)).toBe(isPositiveUint16(0));
+
       expect(PositiveUint16.is(-1)).toBe(isPositiveUint16(-1));
     });
   });
@@ -110,16 +132,19 @@ describe('PositiveUint16 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(PositiveUint16.MIN_VALUE).toBe(1);
+
       expect(PositiveUint16.MAX_VALUE).toBe(65_535);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asPositiveUint16(100);
+
     const b = asPositiveUint16(50);
 
     test('min and max', () => {
       expect(PositiveUint16.min(a, b)).toBe(50);
+
       expect(PositiveUint16.max(a, b)).toBe(100);
     });
 
@@ -130,11 +155,13 @@ describe('PositiveUint16 test', () => {
       );
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(PositiveUint16.add(a, b)).toBe(150);
     });
 
     test('sub (never goes below 1)', () => {
       expect(PositiveUint16.sub(a, b)).toBe(50);
+
       expect(PositiveUint16.sub(b, a)).toBe(1); // clamped to 1
     });
 
@@ -145,6 +172,7 @@ describe('PositiveUint16 test', () => {
       );
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(
         PositiveUint16.mul(asPositiveUint16(10), asPositiveUint16(5)),
       ).toBe(50);
@@ -152,9 +180,11 @@ describe('PositiveUint16 test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(PositiveUint16.div(a, asPositiveUint16(50))).toBe(2);
+
       expect(PositiveUint16.div(asPositiveUint16(7), asPositiveUint16(3))).toBe(
         2,
       );
+
       expect(
         PositiveUint16.div(asPositiveUint16(50), asPositiveUint16(100)),
       ).toBe(1); // floor(50/100) = 0, clamped to 1
@@ -167,6 +197,7 @@ describe('PositiveUint16 test', () => {
       );
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(PositiveUint16.pow(asPositiveUint16(2), asPositiveUint16(3))).toBe(
         8,
       );
@@ -176,15 +207,20 @@ describe('PositiveUint16 test', () => {
   describe('random', () => {
     test('generates positive uint16 values within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = PositiveUint16.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(PositiveUint16.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).toBeGreaterThan(0);
       }
     });
@@ -194,6 +230,7 @@ describe('PositiveUint16 test', () => {
         const result = PositiveUint16.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(65_535);
       }
     });

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

@@ -10,8 +10,11 @@ describe('PositiveUint32 test', () => {
   describe(asPositiveUint32, () => {
     test('accepts valid positive uint32 values', () => {
       expect(() => asPositiveUint32(1)).not.toThrow();
+
       expect(() => asPositiveUint32(1000)).not.toThrow();
+
       expect(() => asPositiveUint32(4_294_967_295)).not.toThrow(); // 2^32 - 1
+
       expect(() => asPositiveUint32(2_147_483_648)).not.toThrow(); // 2^31
     });
 
@@ -21,29 +24,37 @@ describe('PositiveUint32 test', () => {
 
     test('rejects values outside uint32 range', () => {
       expect(() => asPositiveUint32(4_294_967_296)).toThrow(TypeError); // 2^32
+
       expect(() => asPositiveUint32(10_000_000_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asPositiveUint32(-1)).toThrow(TypeError);
+
       expect(() => asPositiveUint32(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asPositiveUint32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asPositiveUint32(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveUint32(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveUint32(1.2)).toThrow(TypeError);
+
       expect(() => asPositiveUint32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asPositiveUint32(5)).toBe(5);
+
       expect(asPositiveUint32(1)).toBe(1);
+
       expect(asPositiveUint32(4_294_967_295)).toBe(4_294_967_295);
     });
 
@@ -71,8 +82,11 @@ describe('PositiveUint32 test', () => {
   describe(isPositiveUint32, () => {
     test('correctly identifies positive uint32 values', () => {
       expect(isPositiveUint32(1)).toBe(true);
+
       expect(isPositiveUint32(1000)).toBe(true);
+
       expect(isPositiveUint32(4_294_967_295)).toBe(true);
+
       expect(isPositiveUint32(2_147_483_648)).toBe(true);
     });
 
@@ -82,19 +96,25 @@ describe('PositiveUint32 test', () => {
 
     test('correctly identifies values outside uint32 range', () => {
       expect(isPositiveUint32(4_294_967_296)).toBe(false);
+
       expect(isPositiveUint32(10_000_000_000)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isPositiveUint32(-1)).toBe(false);
+
       expect(isPositiveUint32(-42)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isPositiveUint32(Number.NaN)).toBe(false);
+
       expect(isPositiveUint32(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isPositiveUint32(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isPositiveUint32(1.2)).toBe(false);
+
       expect(isPositiveUint32(-3.4)).toBe(false);
     });
   });
@@ -102,7 +122,9 @@ describe('PositiveUint32 test', () => {
   describe('PositiveUint32.is', () => {
     test('same as isPositiveUint32 function', () => {
       expect(PositiveUint32.is(5)).toBe(isPositiveUint32(5));
+
       expect(PositiveUint32.is(0)).toBe(isPositiveUint32(0));
+
       expect(PositiveUint32.is(-1)).toBe(isPositiveUint32(-1));
     });
   });
@@ -110,16 +132,19 @@ describe('PositiveUint32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(PositiveUint32.MIN_VALUE).toBe(1);
+
       expect(PositiveUint32.MAX_VALUE).toBe(4_294_967_295);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asPositiveUint32(1_000_000);
+
     const b = asPositiveUint32(500_000);
 
     test('min and max', () => {
       expect(PositiveUint32.min(a, b)).toBe(500_000);
+
       expect(PositiveUint32.max(a, b)).toBe(1_000_000);
     });
 
@@ -130,11 +155,13 @@ describe('PositiveUint32 test', () => {
       );
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(PositiveUint32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (never goes below 1)', () => {
       expect(PositiveUint32.sub(a, b)).toBe(500_000);
+
       expect(PositiveUint32.sub(b, a)).toBe(1); // clamped to 1
     });
 
@@ -145,6 +172,7 @@ describe('PositiveUint32 test', () => {
       );
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(
         PositiveUint32.mul(asPositiveUint32(1000), asPositiveUint32(5)),
       ).toBe(5000);
@@ -152,9 +180,11 @@ describe('PositiveUint32 test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(PositiveUint32.div(a, asPositiveUint32(500_000))).toBe(2);
+
       expect(PositiveUint32.div(asPositiveUint32(7), asPositiveUint32(3))).toBe(
         2,
       );
+
       expect(
         PositiveUint32.div(
           asPositiveUint32(500_000),
@@ -170,6 +200,7 @@ describe('PositiveUint32 test', () => {
       );
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(PositiveUint32.pow(asPositiveUint32(2), asPositiveUint32(3))).toBe(
         8,
       );
@@ -179,15 +210,20 @@ describe('PositiveUint32 test', () => {
   describe('random', () => {
     test('generates positive uint32 values within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = PositiveUint32.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(PositiveUint32.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).toBeGreaterThan(0);
       }
     });
@@ -197,6 +233,7 @@ describe('PositiveUint32 test', () => {
         const result = PositiveUint32.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(4_294_967_295);
       }
     });

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

@@ -26,9 +26,9 @@ const {
   SafeUint
 >({
   integerOrSafeInteger: 'SafeInteger',
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-min-safe-integer
   MIN_VALUE: Number.MIN_SAFE_INTEGER as SafeInt,
-  // 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);
@@ -43,7 +43,9 @@ const {
  *
  * ```ts
  * assert.ok(isSafeInt(Number.MAX_SAFE_INTEGER));
+ *
  * assert.notOk(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
+ *
  * assert.ok(SafeInt.is(Number.MIN_SAFE_INTEGER));
  * ```
  *
@@ -65,6 +67,7 @@ export const isSafeInt = is;
  * const branded = asSafeInt(123);
  *
  * assert(branded === 123);
+ *
  * assert.ok(SafeInt.is(branded));
  * ```
  *
@@ -98,7 +101,9 @@ export const SafeInt = {
    *
    * ```ts
    * assert.ok(isSafeInt(Number.MAX_SAFE_INTEGER));
+   *
    * assert.notOk(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
+   *
    * assert.ok(SafeInt.is(Number.MIN_SAFE_INTEGER));
    * ```
    *
@@ -132,9 +137,11 @@ export const SafeInt = {
    *
    * ```ts
    * const negative = asSafeInt(-900);
+   *
    * const absolute = SafeInt.abs(negative);
    *
    * assert(absolute === 900);
+   *
    * assert.ok(SafeInt.is(absolute));
    * ```
    *
@@ -182,11 +189,15 @@ export const SafeInt = {
    *
    * ```ts
    * const aboveRange = SafeInt.clamp(1e20);
+   *
    * const withinRange = SafeInt.clamp(123);
+   *
    * const belowRange = SafeInt.clamp(-1e20);
    *
    * assert(aboveRange === Number.MAX_SAFE_INTEGER);
+   *
    * assert(withinRange === 123);
+   *
    * assert(belowRange === Number.MIN_SAFE_INTEGER);
    * ```
    *
@@ -206,10 +217,13 @@ export const SafeInt = {
    *
    * ```ts
    * const min = asSafeInt(-10);
+   *
    * const max = asSafeInt(10);
+   *
    * const randomValue = SafeInt.random(min, max);
    *
    * assert.ok(SafeInt.is(randomValue));
+   *
    * assert.ok(randomValue >= -10 && randomValue <= 10);
    * ```
    *
@@ -226,10 +240,13 @@ export const SafeInt = {
    *
    * ```ts
    * const base = asSafeInt(3);
+   *
    * const exponent = asSafeInt(5);
+   *
    * const power = SafeInt.pow(base, exponent);
    *
    * assert(power === 243);
+   *
    * assert.ok(SafeInt.is(power));
    * ```
    *
@@ -248,6 +265,7 @@ export const SafeInt = {
    * const sum = SafeInt.add(asSafeInt(9), asSafeInt(4));
    *
    * assert(sum === 13);
+   *
    * assert.ok(SafeInt.is(sum));
    * ```
    *
@@ -266,6 +284,7 @@ export const SafeInt = {
    * const difference = SafeInt.sub(asSafeInt(9), asSafeInt(14));
    *
    * assert(difference === -5);
+   *
    * assert.ok(SafeInt.is(difference));
    * ```
    *
@@ -284,6 +303,7 @@ export const SafeInt = {
    * const product = SafeInt.mul(asSafeInt(-8), asSafeInt(7));
    *
    * assert(product === -56);
+   *
    * assert.ok(SafeInt.is(product));
    * ```
    *
@@ -305,6 +325,7 @@ export const SafeInt = {
    * const quotient = SafeInt.div(asSafeInt(-17), asSafeInt(5));
    *
    * assert(quotient === -4);
+   *
    * assert.ok(SafeInt.is(quotient));
    * ```
    *

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

@@ -6,34 +6,51 @@ describe('SafeInt test', () => {
   describe(asSafeInt, () => {
     test('accepts valid safe integers', () => {
       expect(() => asSafeInt(0)).not.toThrow();
+
       expect(() => asSafeInt(1)).not.toThrow();
+
       expect(() => asSafeInt(-1)).not.toThrow();
+
       expect(() => asSafeInt(42)).not.toThrow();
+
       expect(() => asSafeInt(-42)).not.toThrow();
+
       expect(() => asSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+
       expect(() => asSafeInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects values outside safe integer range', () => {
       expect(() => asSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrow(TypeError);
+
       expect(() => asSafeInt(Number.MIN_SAFE_INTEGER - 1)).toThrow(TypeError);
+
       expect(() => asSafeInt(Number.MAX_VALUE)).toThrow(TypeError);
+
       expect(() => asSafeInt(-Number.MAX_VALUE)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asSafeInt(Number.NaN)).toThrow(TypeError);
+
       expect(() => asSafeInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asSafeInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asSafeInt(1.2)).toThrow(TypeError);
+
       expect(() => asSafeInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asSafeInt(5)).toBe(5);
+
       expect(asSafeInt(-10)).toBe(-10);
+
       expect(asSafeInt(0)).toBe(0);
+
       expect(asSafeInt(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
+
       expect(asSafeInt(Number.MIN_SAFE_INTEGER)).toBe(Number.MIN_SAFE_INTEGER);
     });
 
@@ -53,26 +70,39 @@ describe('SafeInt test', () => {
   describe('SafeInt.is', () => {
     test('correctly identifies safe integers', () => {
       expect(SafeInt.is(0)).toBe(true);
+
       expect(SafeInt.is(1)).toBe(true);
+
       expect(SafeInt.is(-1)).toBe(true);
+
       expect(SafeInt.is(42)).toBe(true);
+
       expect(SafeInt.is(-42)).toBe(true);
+
       expect(SafeInt.is(Number.MAX_SAFE_INTEGER)).toBe(true);
+
       expect(SafeInt.is(Number.MIN_SAFE_INTEGER)).toBe(true);
     });
 
     test('correctly identifies values outside safe integer range', () => {
       expect(SafeInt.is(Number.MAX_SAFE_INTEGER + 1)).toBe(false);
+
       expect(SafeInt.is(Number.MIN_SAFE_INTEGER - 1)).toBe(false);
+
       expect(SafeInt.is(Number.MAX_VALUE)).toBe(false);
+
       expect(SafeInt.is(-Number.MAX_VALUE)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(SafeInt.is(Number.NaN)).toBe(false);
+
       expect(SafeInt.is(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(SafeInt.is(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(SafeInt.is(1.2)).toBe(false);
+
       expect(SafeInt.is(-3.4)).toBe(false);
     });
   });
@@ -80,41 +110,53 @@ describe('SafeInt test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(SafeInt.MIN_VALUE).toBe(Number.MIN_SAFE_INTEGER);
+
       expect(SafeInt.MAX_VALUE).toBe(Number.MAX_SAFE_INTEGER);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asSafeInt(5);
+
     const b = asSafeInt(2);
+
     const c = asSafeInt(-3);
 
     test('abs', () => {
       expect(SafeInt.abs(a)).toBe(5);
+
       expect(SafeInt.abs(c)).toBe(3);
+
       expect(SafeInt.abs(asSafeInt(0))).toBe(0);
     });
 
     test('min and max', () => {
       expect(SafeInt.min(a, b)).toBe(2);
+
       expect(SafeInt.max(a, b)).toBe(5);
+
       expect(SafeInt.min(a, c)).toBe(-3);
+
       expect(SafeInt.max(a, c)).toBe(5);
     });
 
     test('add (with clamping to safe integer range)', () => {
       const largeValue = asSafeInt(Number.MAX_SAFE_INTEGER - 1);
+
       const result = SafeInt.add(largeValue, asSafeInt(10));
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(SafeInt.add(a, b)).toBe(7);
     });
 
     test('sub (with clamping to safe integer range)', () => {
       const smallValue = asSafeInt(Number.MIN_SAFE_INTEGER + 1);
+
       const result = SafeInt.sub(smallValue, asSafeInt(10));
 
       expect(result).toBe(Number.MIN_SAFE_INTEGER); // clamped to min
+
       expect(SafeInt.sub(a, b)).toBe(3);
     });
 
@@ -122,15 +164,19 @@ describe('SafeInt test', () => {
       const largeValue = asSafeInt(
         Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER)),
       );
+
       const result = SafeInt.mul(largeValue, largeValue);
 
       expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
+
       expect(SafeInt.mul(asSafeInt(10), asSafeInt(5))).toBe(50);
     });
 
     test('div (floor division with clamping)', () => {
       expect(SafeInt.div(a, b)).toBe(2);
+
       expect(SafeInt.div(asSafeInt(7), asSafeInt(3))).toBe(2);
+
       expect(SafeInt.div(asSafeInt(-7), asSafeInt(3))).toBe(-3);
     });
 
@@ -138,6 +184,7 @@ describe('SafeInt test', () => {
       const result = SafeInt.pow(asSafeInt(1000), asSafeInt(10));
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(SafeInt.pow(asSafeInt(2), asSafeInt(3))).toBe(8);
     });
   });
@@ -145,14 +192,18 @@ describe('SafeInt test', () => {
   describe('random', () => {
     test('generates safe integers within specified range', () => {
       const min = -20;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = SafeInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(SafeInt.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
       }
     });
@@ -162,6 +213,7 @@ describe('SafeInt test', () => {
         const result = SafeInt.random(-30, 30);
 
         expect(result).toBeGreaterThanOrEqual(Number.MIN_SAFE_INTEGER);
+
         expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       }
     });

package/src/number/branded-types/safe-uint.mts

@@ -26,7 +26,7 @@ const {
 >({
   integerOrSafeInteger: 'SafeInteger',
   MIN_VALUE: 0,
-  // 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);