ts-data-forge 6.0.0 → 6.1.0

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

@@ -9,43 +9,43 @@ import {
 describe('PositiveFiniteNumber test', () => {
   describe(asPositiveFiniteNumber, () => {
     test('accepts valid positive finite numbers', () => {
-      expect(() => asPositiveFiniteNumber(1)).not.toThrow();
+      expect(() => asPositiveFiniteNumber(1)).not.toThrowError();
 
-      expect(() => asPositiveFiniteNumber(3.14)).not.toThrow();
+      expect(() => asPositiveFiniteNumber(3.14)).not.toThrowError();
 
-      expect(() => asPositiveFiniteNumber(0.5)).not.toThrow();
+      expect(() => asPositiveFiniteNumber(0.5)).not.toThrowError();
 
-      expect(() => asPositiveFiniteNumber(Number.MIN_VALUE)).not.toThrow();
+      expect(() => asPositiveFiniteNumber(Number.MIN_VALUE)).not.toThrowError();
 
-      expect(() => asPositiveFiniteNumber(Number.MAX_VALUE)).not.toThrow();
+      expect(() => asPositiveFiniteNumber(Number.MAX_VALUE)).not.toThrowError();
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveFiniteNumber(0)).toThrow(TypeError);
+      expect(() => asPositiveFiniteNumber(0)).toThrowError(TypeError);
 
-      expect(() => asPositiveFiniteNumber(-0)).toThrow(TypeError);
+      expect(() => asPositiveFiniteNumber(-0)).toThrowError(TypeError);
     });
 
     test('rejects negative numbers', () => {
-      expect(() => asPositiveFiniteNumber(-1)).toThrow(TypeError);
+      expect(() => asPositiveFiniteNumber(-1)).toThrowError(TypeError);
 
-      expect(() => asPositiveFiniteNumber(-0.1)).toThrow(TypeError);
+      expect(() => asPositiveFiniteNumber(-0.1)).toThrowError(TypeError);
 
-      expect(() => asPositiveFiniteNumber(-Number.MAX_VALUE)).toThrow(
+      expect(() => asPositiveFiniteNumber(-Number.MAX_VALUE)).toThrowError(
         TypeError,
       );
     });
 
     test('rejects non-finite numbers', () => {
-      expect(() => asPositiveFiniteNumber(Number.NaN)).toThrow(TypeError);
+      expect(() => asPositiveFiniteNumber(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asPositiveFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(
-        TypeError,
-      );
+      expect(() =>
+        asPositiveFiniteNumber(Number.POSITIVE_INFINITY),
+      ).toThrowError(TypeError);
 
-      expect(() => asPositiveFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(
-        TypeError,
-      );
+      expect(() =>
+        asPositiveFiniteNumber(Number.NEGATIVE_INFINITY),
+      ).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -64,7 +64,7 @@ describe('PositiveFiniteNumber test', () => {
     ] as const)(
       `asPositiveFiniteNumber($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveFiniteNumber(value)).toThrow(
+        expect(() => asPositiveFiniteNumber(value)).toThrowError(
           new TypeError(`Expected a positive finite number, got: ${value}`),
         );
       },

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

@@ -5,41 +5,47 @@ import { asPositiveInt, isPositiveInt, PositiveInt } from './positive-int.mjs';
 describe('PositiveInt test', () => {
   describe(asPositiveInt, () => {
     test('accepts valid positive integers', () => {
-      expect(() => asPositiveInt(1)).not.toThrow();
+      expect(() => asPositiveInt(1)).not.toThrowError();
 
-      expect(() => asPositiveInt(2)).not.toThrow();
+      expect(() => asPositiveInt(2)).not.toThrowError();
 
-      expect(() => asPositiveInt(42)).not.toThrow();
+      expect(() => asPositiveInt(42)).not.toThrowError();
 
-      expect(() => asPositiveInt(100)).not.toThrow();
+      expect(() => asPositiveInt(100)).not.toThrowError();
 
-      expect(() => asPositiveInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+      expect(() => asPositiveInt(Number.MAX_SAFE_INTEGER)).not.toThrowError();
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveInt(0)).toThrow(TypeError);
+      expect(() => asPositiveInt(0)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt(-0)).toThrow(TypeError);
+      expect(() => asPositiveInt(-0)).toThrowError(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveInt(-1)).toThrow(TypeError);
+      expect(() => asPositiveInt(-1)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt(-42)).toThrow(TypeError);
+      expect(() => asPositiveInt(-42)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt(Number.MIN_SAFE_INTEGER)).toThrow(TypeError);
+      expect(() => asPositiveInt(Number.MIN_SAFE_INTEGER)).toThrowError(
+        TypeError,
+      );
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveInt(Number.NaN)).toThrow(TypeError);
+      expect(() => asPositiveInt(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asPositiveInt(Number.POSITIVE_INFINITY)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asPositiveInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asPositiveInt(Number.NEGATIVE_INFINITY)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asPositiveInt(1.2)).toThrow(TypeError);
+      expect(() => asPositiveInt(1.2)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt(-3.4)).toThrow(TypeError);
+      expect(() => asPositiveInt(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -61,7 +67,7 @@ describe('PositiveInt test', () => {
     ] as const)(
       `asPositiveInt($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveInt(value)).toThrow(
+        expect(() => asPositiveInt(value)).toThrowError(
           new TypeError(`Expected a positive integer, got: ${value}`),
         );
       },

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

@@ -9,43 +9,43 @@ import {
 describe('PositiveInt16 test', () => {
   describe(asPositiveInt16, () => {
     test('accepts valid positive int16 values', () => {
-      expect(() => asPositiveInt16(1)).not.toThrow();
+      expect(() => asPositiveInt16(1)).not.toThrowError();
 
-      expect(() => asPositiveInt16(1000)).not.toThrow();
+      expect(() => asPositiveInt16(1000)).not.toThrowError();
 
-      expect(() => asPositiveInt16(32_767)).not.toThrow(); // 2^15 - 1
+      expect(() => asPositiveInt16(32_767)).not.toThrowError(); // 2^15 - 1
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveInt16(0)).toThrow(TypeError);
+      expect(() => asPositiveInt16(0)).toThrowError(TypeError);
     });
 
     test('rejects values outside int16 range', () => {
-      expect(() => asPositiveInt16(32_768)).toThrow(TypeError); // 2^15
+      expect(() => asPositiveInt16(32_768)).toThrowError(TypeError); // 2^15
 
-      expect(() => asPositiveInt16(65_536)).toThrow(TypeError);
+      expect(() => asPositiveInt16(65_536)).toThrowError(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveInt16(-1)).toThrow(TypeError);
+      expect(() => asPositiveInt16(-1)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt16(-42)).toThrow(TypeError);
+      expect(() => asPositiveInt16(-42)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveInt16(Number.NaN)).toThrow(TypeError);
+      expect(() => asPositiveInt16(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt16(Number.POSITIVE_INFINITY)).toThrow(
+      expect(() => asPositiveInt16(Number.POSITIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveInt16(Number.NEGATIVE_INFINITY)).toThrow(
+      expect(() => asPositiveInt16(Number.NEGATIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveInt16(1.2)).toThrow(TypeError);
+      expect(() => asPositiveInt16(1.2)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt16(-3.4)).toThrow(TypeError);
+      expect(() => asPositiveInt16(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -68,7 +68,7 @@ describe('PositiveInt16 test', () => {
     ] as const)(
       `asPositiveInt16($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveInt16(value)).toThrow(
+        expect(() => asPositiveInt16(value)).toThrowError(
           new TypeError(
             `Expected a positive integer in [1, 2^15), got: ${value}`,
           ),

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

@@ -9,43 +9,43 @@ import {
 describe('PositiveInt32 test', () => {
   describe(asPositiveInt32, () => {
     test('accepts valid positive int32 values', () => {
-      expect(() => asPositiveInt32(1)).not.toThrow();
+      expect(() => asPositiveInt32(1)).not.toThrowError();
 
-      expect(() => asPositiveInt32(1000)).not.toThrow();
+      expect(() => asPositiveInt32(1000)).not.toThrowError();
 
-      expect(() => asPositiveInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
+      expect(() => asPositiveInt32(2_147_483_647)).not.toThrowError(); // 2^31 - 1
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveInt32(0)).toThrow(TypeError);
+      expect(() => asPositiveInt32(0)).toThrowError(TypeError);
     });
 
     test('rejects values outside int32 range', () => {
-      expect(() => asPositiveInt32(2_147_483_648)).toThrow(TypeError); // 2^31
+      expect(() => asPositiveInt32(2_147_483_648)).toThrowError(TypeError); // 2^31
 
-      expect(() => asPositiveInt32(4_294_967_296)).toThrow(TypeError);
+      expect(() => asPositiveInt32(4_294_967_296)).toThrowError(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveInt32(-1)).toThrow(TypeError);
+      expect(() => asPositiveInt32(-1)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt32(-42)).toThrow(TypeError);
+      expect(() => asPositiveInt32(-42)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveInt32(Number.NaN)).toThrow(TypeError);
+      expect(() => asPositiveInt32(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt32(Number.POSITIVE_INFINITY)).toThrow(
+      expect(() => asPositiveInt32(Number.POSITIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveInt32(Number.NEGATIVE_INFINITY)).toThrow(
+      expect(() => asPositiveInt32(Number.NEGATIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveInt32(1.2)).toThrow(TypeError);
+      expect(() => asPositiveInt32(1.2)).toThrowError(TypeError);
 
-      expect(() => asPositiveInt32(-3.4)).toThrow(TypeError);
+      expect(() => asPositiveInt32(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -68,7 +68,7 @@ describe('PositiveInt32 test', () => {
     ] as const)(
       `asPositiveInt32($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveInt32(value)).toThrow(
+        expect(() => asPositiveInt32(value)).toThrowError(
           new TypeError(
             `Expected a positive integer in [1, 2^31), got: ${value}`,
           ),

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

@@ -9,55 +9,57 @@ import {
 describe('PositiveSafeInt test', () => {
   describe(asPositiveSafeInt, () => {
     test('accepts valid positive safe integers', () => {
-      expect(() => asPositiveSafeInt(1)).not.toThrow();
+      expect(() => asPositiveSafeInt(1)).not.toThrowError();
 
-      expect(() => asPositiveSafeInt(2)).not.toThrow();
+      expect(() => asPositiveSafeInt(2)).not.toThrowError();
 
-      expect(() => asPositiveSafeInt(42)).not.toThrow();
+      expect(() => asPositiveSafeInt(42)).not.toThrowError();
 
-      expect(() => asPositiveSafeInt(100)).not.toThrow();
+      expect(() => asPositiveSafeInt(100)).not.toThrowError();
 
-      expect(() => asPositiveSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+      expect(() =>
+        asPositiveSafeInt(Number.MAX_SAFE_INTEGER),
+      ).not.toThrowError();
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveSafeInt(0)).toThrow(TypeError);
+      expect(() => asPositiveSafeInt(0)).toThrowError(TypeError);
 
-      expect(() => asPositiveSafeInt(-0)).toThrow(TypeError);
+      expect(() => asPositiveSafeInt(-0)).toThrowError(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveSafeInt(-1)).toThrow(TypeError);
+      expect(() => asPositiveSafeInt(-1)).toThrowError(TypeError);
 
-      expect(() => asPositiveSafeInt(-42)).toThrow(TypeError);
+      expect(() => asPositiveSafeInt(-42)).toThrowError(TypeError);
 
-      expect(() => asPositiveSafeInt(Number.MIN_SAFE_INTEGER)).toThrow(
+      expect(() => asPositiveSafeInt(Number.MIN_SAFE_INTEGER)).toThrowError(
         TypeError,
       );
     });
 
     test('rejects values outside safe integer range', () => {
-      expect(() => asPositiveSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrow(
+      expect(() => asPositiveSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveSafeInt(Number.MAX_VALUE)).toThrow(TypeError);
+      expect(() => asPositiveSafeInt(Number.MAX_VALUE)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveSafeInt(Number.NaN)).toThrow(TypeError);
+      expect(() => asPositiveSafeInt(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asPositiveSafeInt(Number.POSITIVE_INFINITY)).toThrow(
+      expect(() => asPositiveSafeInt(Number.POSITIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveSafeInt(Number.NEGATIVE_INFINITY)).toThrow(
+      expect(() => asPositiveSafeInt(Number.NEGATIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveSafeInt(1.2)).toThrow(TypeError);
+      expect(() => asPositiveSafeInt(1.2)).toThrowError(TypeError);
 
-      expect(() => asPositiveSafeInt(-3.4)).toThrow(TypeError);
+      expect(() => asPositiveSafeInt(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -79,7 +81,7 @@ describe('PositiveSafeInt test', () => {
     ] as const)(
       `asPositiveSafeInt($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveSafeInt(value)).toThrow(
+        expect(() => asPositiveSafeInt(value)).toThrowError(
           new TypeError(`Expected a positive safe integer, got: ${value}`),
         );
       },

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

@@ -9,45 +9,45 @@ import {
 describe('PositiveUint16 test', () => {
   describe(asPositiveUint16, () => {
     test('accepts valid positive uint16 values', () => {
-      expect(() => asPositiveUint16(1)).not.toThrow();
+      expect(() => asPositiveUint16(1)).not.toThrowError();
 
-      expect(() => asPositiveUint16(1000)).not.toThrow();
+      expect(() => asPositiveUint16(1000)).not.toThrowError();
 
-      expect(() => asPositiveUint16(65_535)).not.toThrow(); // 2^16 - 1
+      expect(() => asPositiveUint16(65_535)).not.toThrowError(); // 2^16 - 1
 
-      expect(() => asPositiveUint16(32_768)).not.toThrow(); // 2^15
+      expect(() => asPositiveUint16(32_768)).not.toThrowError(); // 2^15
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveUint16(0)).toThrow(TypeError);
+      expect(() => asPositiveUint16(0)).toThrowError(TypeError);
     });
 
     test('rejects values outside uint16 range', () => {
-      expect(() => asPositiveUint16(65_536)).toThrow(TypeError); // 2^16
+      expect(() => asPositiveUint16(65_536)).toThrowError(TypeError); // 2^16
 
-      expect(() => asPositiveUint16(100_000)).toThrow(TypeError);
+      expect(() => asPositiveUint16(100_000)).toThrowError(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveUint16(-1)).toThrow(TypeError);
+      expect(() => asPositiveUint16(-1)).toThrowError(TypeError);
 
-      expect(() => asPositiveUint16(-42)).toThrow(TypeError);
+      expect(() => asPositiveUint16(-42)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveUint16(Number.NaN)).toThrow(TypeError);
+      expect(() => asPositiveUint16(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asPositiveUint16(Number.POSITIVE_INFINITY)).toThrow(
+      expect(() => asPositiveUint16(Number.POSITIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveUint16(Number.NEGATIVE_INFINITY)).toThrow(
+      expect(() => asPositiveUint16(Number.NEGATIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveUint16(1.2)).toThrow(TypeError);
+      expect(() => asPositiveUint16(1.2)).toThrowError(TypeError);
 
-      expect(() => asPositiveUint16(-3.4)).toThrow(TypeError);
+      expect(() => asPositiveUint16(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -70,7 +70,7 @@ describe('PositiveUint16 test', () => {
     ] as const)(
       `asPositiveUint16($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveUint16(value)).toThrow(
+        expect(() => asPositiveUint16(value)).toThrowError(
           new TypeError(
             `Expected a positive integer in [1, 2^16), got: ${value}`,
           ),

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

@@ -9,45 +9,45 @@ import {
 describe('PositiveUint32 test', () => {
   describe(asPositiveUint32, () => {
     test('accepts valid positive uint32 values', () => {
-      expect(() => asPositiveUint32(1)).not.toThrow();
+      expect(() => asPositiveUint32(1)).not.toThrowError();
 
-      expect(() => asPositiveUint32(1000)).not.toThrow();
+      expect(() => asPositiveUint32(1000)).not.toThrowError();
 
-      expect(() => asPositiveUint32(4_294_967_295)).not.toThrow(); // 2^32 - 1
+      expect(() => asPositiveUint32(4_294_967_295)).not.toThrowError(); // 2^32 - 1
 
-      expect(() => asPositiveUint32(2_147_483_648)).not.toThrow(); // 2^31
+      expect(() => asPositiveUint32(2_147_483_648)).not.toThrowError(); // 2^31
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveUint32(0)).toThrow(TypeError);
+      expect(() => asPositiveUint32(0)).toThrowError(TypeError);
     });
 
     test('rejects values outside uint32 range', () => {
-      expect(() => asPositiveUint32(4_294_967_296)).toThrow(TypeError); // 2^32
+      expect(() => asPositiveUint32(4_294_967_296)).toThrowError(TypeError); // 2^32
 
-      expect(() => asPositiveUint32(10_000_000_000)).toThrow(TypeError);
+      expect(() => asPositiveUint32(10_000_000_000)).toThrowError(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveUint32(-1)).toThrow(TypeError);
+      expect(() => asPositiveUint32(-1)).toThrowError(TypeError);
 
-      expect(() => asPositiveUint32(-42)).toThrow(TypeError);
+      expect(() => asPositiveUint32(-42)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveUint32(Number.NaN)).toThrow(TypeError);
+      expect(() => asPositiveUint32(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asPositiveUint32(Number.POSITIVE_INFINITY)).toThrow(
+      expect(() => asPositiveUint32(Number.POSITIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveUint32(Number.NEGATIVE_INFINITY)).toThrow(
+      expect(() => asPositiveUint32(Number.NEGATIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveUint32(1.2)).toThrow(TypeError);
+      expect(() => asPositiveUint32(1.2)).toThrowError(TypeError);
 
-      expect(() => asPositiveUint32(-3.4)).toThrow(TypeError);
+      expect(() => asPositiveUint32(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -70,7 +70,7 @@ describe('PositiveUint32 test', () => {
     ] as const)(
       `asPositiveUint32($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveUint32(value)).toThrow(
+        expect(() => asPositiveUint32(value)).toThrowError(
           new TypeError(
             `Expected a positive integer in [1, 2^32), got: ${value}`,
           ),

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

@@ -5,41 +5,45 @@ import { asSafeInt, SafeInt } from './safe-int.mjs';
 describe('SafeInt test', () => {
   describe(asSafeInt, () => {
     test('accepts valid safe integers', () => {
-      expect(() => asSafeInt(0)).not.toThrow();
+      expect(() => asSafeInt(0)).not.toThrowError();
 
-      expect(() => asSafeInt(1)).not.toThrow();
+      expect(() => asSafeInt(1)).not.toThrowError();
 
-      expect(() => asSafeInt(-1)).not.toThrow();
+      expect(() => asSafeInt(-1)).not.toThrowError();
 
-      expect(() => asSafeInt(42)).not.toThrow();
+      expect(() => asSafeInt(42)).not.toThrowError();
 
-      expect(() => asSafeInt(-42)).not.toThrow();
+      expect(() => asSafeInt(-42)).not.toThrowError();
 
-      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrowError();
 
-      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
+      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER)).not.toThrowError();
     });
 
     test('rejects values outside safe integer range', () => {
-      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER - 1)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER - 1)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asSafeInt(Number.MAX_VALUE)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.MAX_VALUE)).toThrowError(TypeError);
 
-      expect(() => asSafeInt(-Number.MAX_VALUE)).toThrow(TypeError);
+      expect(() => asSafeInt(-Number.MAX_VALUE)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asSafeInt(Number.NaN)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asSafeInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asSafeInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asSafeInt(1.2)).toThrow(TypeError);
+      expect(() => asSafeInt(1.2)).toThrowError(TypeError);
 
-      expect(() => asSafeInt(-3.4)).toThrow(TypeError);
+      expect(() => asSafeInt(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -61,7 +65,7 @@ describe('SafeInt test', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
     ] as const)(`asSafeInt($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asSafeInt(value)).toThrow(
+      expect(() => asSafeInt(value)).toThrowError(
         new TypeError(`Expected a safe integer, got: ${value}`),
       );
     });

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

@@ -5,41 +5,47 @@ import { asSafeUint, isSafeUint, SafeUint } from './safe-uint.mjs';
 describe('SafeUint test', () => {
   describe(asSafeUint, () => {
     test('accepts valid safe unsigned integers', () => {
-      expect(() => asSafeUint(0)).not.toThrow();
+      expect(() => asSafeUint(0)).not.toThrowError();
 
-      expect(() => asSafeUint(1)).not.toThrow();
+      expect(() => asSafeUint(1)).not.toThrowError();
 
-      expect(() => asSafeUint(42)).not.toThrow();
+      expect(() => asSafeUint(42)).not.toThrowError();
 
-      expect(() => asSafeUint(100)).not.toThrow();
+      expect(() => asSafeUint(100)).not.toThrowError();
 
-      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER)).not.toThrow();
+      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER)).not.toThrowError();
     });
 
     test('rejects negative numbers', () => {
-      expect(() => asSafeUint(-1)).toThrow(TypeError);
+      expect(() => asSafeUint(-1)).toThrowError(TypeError);
 
-      expect(() => asSafeUint(-42)).toThrow(TypeError);
+      expect(() => asSafeUint(-42)).toThrowError(TypeError);
 
-      expect(() => asSafeUint(Number.MIN_SAFE_INTEGER)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.MIN_SAFE_INTEGER)).toThrowError(TypeError);
     });
 
     test('rejects values outside safe integer range', () => {
-      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER + 1)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER + 1)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asSafeUint(Number.MAX_VALUE)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.MAX_VALUE)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asSafeUint(Number.NaN)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asSafeUint(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.POSITIVE_INFINITY)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asSafeUint(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.NEGATIVE_INFINITY)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asSafeUint(1.2)).toThrow(TypeError);
+      expect(() => asSafeUint(1.2)).toThrowError(TypeError);
 
-      expect(() => asSafeUint(-3.4)).toThrow(TypeError);
+      expect(() => asSafeUint(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -60,7 +66,7 @@ describe('SafeUint test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '-1', value: -1 },
     ] as const)(`asSafeUint($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asSafeUint(value)).toThrow(
+      expect(() => asSafeUint(value)).toThrowError(
         new TypeError(`Expected a non-negative safe integer, got: ${value}`),
       );
     });