ts-data-forge 6.8.0 → 6.9.0

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

@@ -6,31 +6,27 @@ import { asNonZeroFiniteNumber } from './non-zero-finite-number.mjs';
 describe('FiniteNumber test', () => {
   describe(asFiniteNumber, () => {
     test('accepts valid finite numbers', () => {
-      expect(() => asFiniteNumber(0)).not.toThrowError();
+      expect(() => asFiniteNumber(0)).not.toThrow();
 
-      expect(() => asFiniteNumber(1)).not.toThrowError();
+      expect(() => asFiniteNumber(1)).not.toThrow();
 
-      expect(() => asFiniteNumber(-1)).not.toThrowError();
+      expect(() => asFiniteNumber(-1)).not.toThrow();
 
-      expect(() => asFiniteNumber(3.14)).not.toThrowError();
+      expect(() => asFiniteNumber(3.14)).not.toThrow();
 
-      expect(() => asFiniteNumber(-2.5)).not.toThrowError();
+      expect(() => asFiniteNumber(-2.5)).not.toThrow();
 
-      expect(() => asFiniteNumber(Number.MAX_VALUE)).not.toThrowError();
+      expect(() => asFiniteNumber(Number.MAX_VALUE)).not.toThrow();
 
-      expect(() => asFiniteNumber(-Number.MAX_VALUE)).not.toThrowError();
+      expect(() => asFiniteNumber(-Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects non-finite numbers', () => {
-      expect(() => asFiniteNumber(Number.NaN)).toThrowError(TypeError);
+      expect(() => asFiniteNumber(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asFiniteNumber(Number.POSITIVE_INFINITY)).toThrowError(
-        TypeError,
-      );
+      expect(() => asFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asFiniteNumber(Number.NEGATIVE_INFINITY)).toThrowError(
-        TypeError,
-      );
+      expect(() => asFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -48,7 +44,7 @@ describe('FiniteNumber test', () => {
     ] as const)(
       `asFiniteNumber($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asFiniteNumber(value)).toThrowError(
+        expect(() => asFiniteNumber(value)).toThrow(
           new TypeError(`Expected a finite number, got: ${value}`),
         );
       },

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

@@ -6,31 +6,31 @@ import { asNonZeroInt } from './non-zero-int.mjs';
 describe('Int test', () => {
   describe(asInt, () => {
     test('accepts valid integers', () => {
-      expect(() => asInt(0)).not.toThrowError();
+      expect(() => asInt(0)).not.toThrow();
 
-      expect(() => asInt(1)).not.toThrowError();
+      expect(() => asInt(1)).not.toThrow();
 
-      expect(() => asInt(-1)).not.toThrowError();
+      expect(() => asInt(-1)).not.toThrow();
 
-      expect(() => asInt(42)).not.toThrowError();
+      expect(() => asInt(42)).not.toThrow();
 
-      expect(() => asInt(-42)).not.toThrowError();
+      expect(() => asInt(-42)).not.toThrow();
 
-      expect(() => asInt(Number.MAX_SAFE_INTEGER)).not.toThrowError();
+      expect(() => asInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
 
-      expect(() => asInt(Number.MIN_SAFE_INTEGER)).not.toThrowError();
+      expect(() => asInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects non-integers', () => {
-      expect(() => asInt(Number.NaN)).toThrowError(TypeError);
+      expect(() => asInt(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asInt(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asInt(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asInt(1.2)).toThrowError(TypeError);
+      expect(() => asInt(1.2)).toThrow(TypeError);
 
-      expect(() => asInt(-3.4)).toThrowError(TypeError);
+      expect(() => asInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -48,7 +48,7 @@ describe('Int test', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
     ] as const)(`asInt($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asInt(value)).toThrowError(
+      expect(() => asInt(value)).toThrow(
         new TypeError(`Expected an integer, got: ${value}`),
       );
     });

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

@@ -6,37 +6,37 @@ import { asNonZeroInt16 } from './non-zero-int16.mjs';
 describe('Int16 test', () => {
   describe(asInt16, () => {
     test('accepts valid int16 values', () => {
-      expect(() => asInt16(0)).not.toThrowError();
+      expect(() => asInt16(0)).not.toThrow();
 
-      expect(() => asInt16(1)).not.toThrowError();
+      expect(() => asInt16(1)).not.toThrow();
 
-      expect(() => asInt16(-1)).not.toThrowError();
+      expect(() => asInt16(-1)).not.toThrow();
 
-      expect(() => asInt16(32_767)).not.toThrowError(); // 2^15 - 1
+      expect(() => asInt16(32_767)).not.toThrow(); // 2^15 - 1
 
-      expect(() => asInt16(-32_768)).not.toThrowError(); // -2^15
+      expect(() => asInt16(-32_768)).not.toThrow(); // -2^15
     });
 
     test('rejects values outside int16 range', () => {
-      expect(() => asInt16(32_768)).toThrowError(TypeError); // 2^15
+      expect(() => asInt16(32_768)).toThrow(TypeError); // 2^15
 
-      expect(() => asInt16(-32_769)).toThrowError(TypeError); // -2^15 - 1
+      expect(() => asInt16(-32_769)).toThrow(TypeError); // -2^15 - 1
 
-      expect(() => asInt16(65_536)).toThrowError(TypeError);
+      expect(() => asInt16(65_536)).toThrow(TypeError);
 
-      expect(() => asInt16(-65_536)).toThrowError(TypeError);
+      expect(() => asInt16(-65_536)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asInt16(Number.NaN)).toThrowError(TypeError);
+      expect(() => asInt16(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asInt16(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asInt16(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asInt16(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asInt16(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asInt16(1.2)).toThrowError(TypeError);
+      expect(() => asInt16(1.2)).toThrow(TypeError);
 
-      expect(() => asInt16(-3.4)).toThrowError(TypeError);
+      expect(() => asInt16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -58,7 +58,7 @@ describe('Int16 test', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
     ] as const)(`asInt16($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asInt16(value)).toThrowError(
+      expect(() => asInt16(value)).toThrow(
         new TypeError(`Expected an integer in [-2^15, 2^15), got: ${value}`),
       );
     });

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

@@ -6,37 +6,37 @@ import { asNonZeroInt32 } from './non-zero-int32.mjs';
 describe('Int32 test', () => {
   describe(asInt32, () => {
     test('accepts valid int32 values', () => {
-      expect(() => asInt32(0)).not.toThrowError();
+      expect(() => asInt32(0)).not.toThrow();
 
-      expect(() => asInt32(1)).not.toThrowError();
+      expect(() => asInt32(1)).not.toThrow();
 
-      expect(() => asInt32(-1)).not.toThrowError();
+      expect(() => asInt32(-1)).not.toThrow();
 
-      expect(() => asInt32(2_147_483_647)).not.toThrowError(); // 2^31 - 1
+      expect(() => asInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
 
-      expect(() => asInt32(-2_147_483_648)).not.toThrowError(); // -2^31
+      expect(() => asInt32(-2_147_483_648)).not.toThrow(); // -2^31
     });
 
     test('rejects values outside int32 range', () => {
-      expect(() => asInt32(2_147_483_648)).toThrowError(TypeError); // 2^31
+      expect(() => asInt32(2_147_483_648)).toThrow(TypeError); // 2^31
 
-      expect(() => asInt32(-2_147_483_649)).toThrowError(TypeError); // -2^31 - 1
+      expect(() => asInt32(-2_147_483_649)).toThrow(TypeError); // -2^31 - 1
 
-      expect(() => asInt32(4_294_967_296)).toThrowError(TypeError);
+      expect(() => asInt32(4_294_967_296)).toThrow(TypeError);
 
-      expect(() => asInt32(-4_294_967_296)).toThrowError(TypeError);
+      expect(() => asInt32(-4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asInt32(Number.NaN)).toThrowError(TypeError);
+      expect(() => asInt32(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asInt32(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asInt32(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asInt32(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asInt32(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asInt32(1.2)).toThrowError(TypeError);
+      expect(() => asInt32(1.2)).toThrow(TypeError);
 
-      expect(() => asInt32(-3.4)).toThrowError(TypeError);
+      expect(() => asInt32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -58,7 +58,7 @@ describe('Int32 test', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
     ] as const)(`asInt32($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asInt32(value)).toThrowError(
+      expect(() => asInt32(value)).toThrow(
         new TypeError(`Expected an integer in [-2^31, 2^31), got: ${value}`),
       );
     });

package/src/number/branded-types/non-negative-finite-number.test.mts

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

package/src/number/branded-types/non-negative-int16.test.mts

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

package/src/number/branded-types/non-negative-int32.test.mts

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

package/src/number/branded-types/non-zero-finite-number.test.mts

@@ -9,39 +9,39 @@ import {
 describe('NonZeroFiniteNumber test', () => {
   describe(asNonZeroFiniteNumber, () => {
     test('accepts valid non-zero finite numbers', () => {
-      expect(() => asNonZeroFiniteNumber(1)).not.toThrowError();
+      expect(() => asNonZeroFiniteNumber(1)).not.toThrow();
 
-      expect(() => asNonZeroFiniteNumber(-1)).not.toThrowError();
+      expect(() => asNonZeroFiniteNumber(-1)).not.toThrow();
 
-      expect(() => asNonZeroFiniteNumber(3.14)).not.toThrowError();
+      expect(() => asNonZeroFiniteNumber(3.14)).not.toThrow();
 
-      expect(() => asNonZeroFiniteNumber(-2.5)).not.toThrowError();
+      expect(() => asNonZeroFiniteNumber(-2.5)).not.toThrow();
 
-      expect(() => asNonZeroFiniteNumber(0.001)).not.toThrowError();
+      expect(() => asNonZeroFiniteNumber(0.001)).not.toThrow();
 
-      expect(() => asNonZeroFiniteNumber(-0.001)).not.toThrowError();
+      expect(() => asNonZeroFiniteNumber(-0.001)).not.toThrow();
 
-      expect(() => asNonZeroFiniteNumber(Number.MAX_VALUE)).not.toThrowError();
+      expect(() => asNonZeroFiniteNumber(Number.MAX_VALUE)).not.toThrow();
 
-      expect(() => asNonZeroFiniteNumber(-Number.MAX_VALUE)).not.toThrowError();
+      expect(() => asNonZeroFiniteNumber(-Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects zero', () => {
-      expect(() => asNonZeroFiniteNumber(0)).toThrowError(TypeError);
+      expect(() => asNonZeroFiniteNumber(0)).toThrow(TypeError);
 
-      expect(() => asNonZeroFiniteNumber(-0)).toThrowError(TypeError);
+      expect(() => asNonZeroFiniteNumber(-0)).toThrow(TypeError);
     });
 
     test('rejects non-finite numbers', () => {
-      expect(() => asNonZeroFiniteNumber(Number.NaN)).toThrowError(TypeError);
+      expect(() => asNonZeroFiniteNumber(Number.NaN)).toThrow(TypeError);
 
-      expect(() =>
-        asNonZeroFiniteNumber(Number.POSITIVE_INFINITY),
-      ).toThrowError(TypeError);
+      expect(() => asNonZeroFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(
+        TypeError,
+      );
 
-      expect(() =>
-        asNonZeroFiniteNumber(Number.NEGATIVE_INFINITY),
-      ).toThrowError(TypeError);
+      expect(() => asNonZeroFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(
+        TypeError,
+      );
     });
 
     test('returns the same value for valid inputs', () => {
@@ -60,7 +60,7 @@ describe('NonZeroFiniteNumber test', () => {
     ] as const)(
       `asNonZeroFiniteNumber($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asNonZeroFiniteNumber(value)).toThrowError(
+        expect(() => asNonZeroFiniteNumber(value)).toThrow(
           new TypeError(`Expected a non-zero finite number, got: ${value}`),
         );
       },

package/src/number/branded-types/non-zero-int.test.mts

@@ -5,39 +5,35 @@ import { asNonZeroInt, isNonZeroInt, NonZeroInt } from './non-zero-int.mjs';
 describe('NonZeroInt test', () => {
   describe(asNonZeroInt, () => {
     test('accepts valid non-zero integers', () => {
-      expect(() => asNonZeroInt(1)).not.toThrowError();
+      expect(() => asNonZeroInt(1)).not.toThrow();
 
-      expect(() => asNonZeroInt(-1)).not.toThrowError();
+      expect(() => asNonZeroInt(-1)).not.toThrow();
 
-      expect(() => asNonZeroInt(42)).not.toThrowError();
+      expect(() => asNonZeroInt(42)).not.toThrow();
 
-      expect(() => asNonZeroInt(-42)).not.toThrowError();
+      expect(() => asNonZeroInt(-42)).not.toThrow();
 
-      expect(() => asNonZeroInt(Number.MAX_SAFE_INTEGER)).not.toThrowError();
+      expect(() => asNonZeroInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
 
-      expect(() => asNonZeroInt(Number.MIN_SAFE_INTEGER)).not.toThrowError();
+      expect(() => asNonZeroInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects zero', () => {
-      expect(() => asNonZeroInt(0)).toThrowError(TypeError);
+      expect(() => asNonZeroInt(0)).toThrow(TypeError);
 
-      expect(() => asNonZeroInt(-0)).toThrowError(TypeError);
+      expect(() => asNonZeroInt(-0)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asNonZeroInt(Number.NaN)).toThrowError(TypeError);
+      expect(() => asNonZeroInt(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asNonZeroInt(Number.POSITIVE_INFINITY)).toThrowError(
-        TypeError,
-      );
+      expect(() => asNonZeroInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asNonZeroInt(Number.NEGATIVE_INFINITY)).toThrowError(
-        TypeError,
-      );
+      expect(() => asNonZeroInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asNonZeroInt(1.2)).toThrowError(TypeError);
+      expect(() => asNonZeroInt(1.2)).toThrow(TypeError);
 
-      expect(() => asNonZeroInt(-3.4)).toThrowError(TypeError);
+      expect(() => asNonZeroInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -56,7 +52,7 @@ describe('NonZeroInt test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '0', value: 0 },
     ] as const)(`asNonZeroInt($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asNonZeroInt(value)).toThrowError(
+      expect(() => asNonZeroInt(value)).toThrow(
         new TypeError(`Expected a non-zero integer, got: ${value}`),
       );
     });

package/src/number/branded-types/non-zero-int16.test.mts

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