ts-data-forge 6.8.0 → 6.9.0

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

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

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

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

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

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

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

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

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.toThrowError();
+      expect(() => asPositiveFiniteNumber(1)).not.toThrow();
 
-      expect(() => asPositiveFiniteNumber(3.14)).not.toThrowError();
+      expect(() => asPositiveFiniteNumber(3.14)).not.toThrow();
 
-      expect(() => asPositiveFiniteNumber(0.5)).not.toThrowError();
+      expect(() => asPositiveFiniteNumber(0.5)).not.toThrow();
 
-      expect(() => asPositiveFiniteNumber(Number.MIN_VALUE)).not.toThrowError();
+      expect(() => asPositiveFiniteNumber(Number.MIN_VALUE)).not.toThrow();
 
-      expect(() => asPositiveFiniteNumber(Number.MAX_VALUE)).not.toThrowError();
+      expect(() => asPositiveFiniteNumber(Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveFiniteNumber(0)).toThrowError(TypeError);
+      expect(() => asPositiveFiniteNumber(0)).toThrow(TypeError);
 
-      expect(() => asPositiveFiniteNumber(-0)).toThrowError(TypeError);
+      expect(() => asPositiveFiniteNumber(-0)).toThrow(TypeError);
     });
 
     test('rejects negative numbers', () => {
-      expect(() => asPositiveFiniteNumber(-1)).toThrowError(TypeError);
+      expect(() => asPositiveFiniteNumber(-1)).toThrow(TypeError);
 
-      expect(() => asPositiveFiniteNumber(-0.1)).toThrowError(TypeError);
+      expect(() => asPositiveFiniteNumber(-0.1)).toThrow(TypeError);
 
-      expect(() => asPositiveFiniteNumber(-Number.MAX_VALUE)).toThrowError(
+      expect(() => asPositiveFiniteNumber(-Number.MAX_VALUE)).toThrow(
         TypeError,
       );
     });
 
     test('rejects non-finite numbers', () => {
-      expect(() => asPositiveFiniteNumber(Number.NaN)).toThrowError(TypeError);
+      expect(() => asPositiveFiniteNumber(Number.NaN)).toThrow(TypeError);
 
-      expect(() =>
-        asPositiveFiniteNumber(Number.POSITIVE_INFINITY),
-      ).toThrowError(TypeError);
+      expect(() => asPositiveFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(
+        TypeError,
+      );
 
-      expect(() =>
-        asPositiveFiniteNumber(Number.NEGATIVE_INFINITY),
-      ).toThrowError(TypeError);
+      expect(() => asPositiveFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(
+        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)).toThrowError(
+        expect(() => asPositiveFiniteNumber(value)).toThrow(
           new TypeError(`Expected a positive finite number, got: ${value}`),
         );
       },

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

@@ -5,47 +5,41 @@ import { asPositiveInt, isPositiveInt, PositiveInt } from './positive-int.mjs';
 describe('PositiveInt test', () => {
   describe(asPositiveInt, () => {
     test('accepts valid positive integers', () => {
-      expect(() => asPositiveInt(1)).not.toThrowError();
+      expect(() => asPositiveInt(1)).not.toThrow();
 
-      expect(() => asPositiveInt(2)).not.toThrowError();
+      expect(() => asPositiveInt(2)).not.toThrow();
 
-      expect(() => asPositiveInt(42)).not.toThrowError();
+      expect(() => asPositiveInt(42)).not.toThrow();
 
-      expect(() => asPositiveInt(100)).not.toThrowError();
+      expect(() => asPositiveInt(100)).not.toThrow();
 
-      expect(() => asPositiveInt(Number.MAX_SAFE_INTEGER)).not.toThrowError();
+      expect(() => asPositiveInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveInt(0)).toThrowError(TypeError);
+      expect(() => asPositiveInt(0)).toThrow(TypeError);
 
-      expect(() => asPositiveInt(-0)).toThrowError(TypeError);
+      expect(() => asPositiveInt(-0)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveInt(-1)).toThrowError(TypeError);
+      expect(() => asPositiveInt(-1)).toThrow(TypeError);
 
-      expect(() => asPositiveInt(-42)).toThrowError(TypeError);
+      expect(() => asPositiveInt(-42)).toThrow(TypeError);
 
-      expect(() => asPositiveInt(Number.MIN_SAFE_INTEGER)).toThrowError(
-        TypeError,
-      );
+      expect(() => asPositiveInt(Number.MIN_SAFE_INTEGER)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveInt(Number.NaN)).toThrowError(TypeError);
+      expect(() => asPositiveInt(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asPositiveInt(Number.POSITIVE_INFINITY)).toThrowError(
-        TypeError,
-      );
+      expect(() => asPositiveInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asPositiveInt(Number.NEGATIVE_INFINITY)).toThrowError(
-        TypeError,
-      );
+      expect(() => asPositiveInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asPositiveInt(1.2)).toThrowError(TypeError);
+      expect(() => asPositiveInt(1.2)).toThrow(TypeError);
 
-      expect(() => asPositiveInt(-3.4)).toThrowError(TypeError);
+      expect(() => asPositiveInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -67,7 +61,7 @@ describe('PositiveInt test', () => {
     ] as const)(
       `asPositiveInt($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveInt(value)).toThrowError(
+        expect(() => asPositiveInt(value)).toThrow(
           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.toThrowError();
+      expect(() => asPositiveInt16(1)).not.toThrow();
 
-      expect(() => asPositiveInt16(1000)).not.toThrowError();
+      expect(() => asPositiveInt16(1000)).not.toThrow();
 
-      expect(() => asPositiveInt16(32_767)).not.toThrowError(); // 2^15 - 1
+      expect(() => asPositiveInt16(32_767)).not.toThrow(); // 2^15 - 1
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveInt16(0)).toThrowError(TypeError);
+      expect(() => asPositiveInt16(0)).toThrow(TypeError);
     });
 
     test('rejects values outside int16 range', () => {
-      expect(() => asPositiveInt16(32_768)).toThrowError(TypeError); // 2^15
+      expect(() => asPositiveInt16(32_768)).toThrow(TypeError); // 2^15
 
-      expect(() => asPositiveInt16(65_536)).toThrowError(TypeError);
+      expect(() => asPositiveInt16(65_536)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveInt16(-1)).toThrowError(TypeError);
+      expect(() => asPositiveInt16(-1)).toThrow(TypeError);
 
-      expect(() => asPositiveInt16(-42)).toThrowError(TypeError);
+      expect(() => asPositiveInt16(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveInt16(Number.NaN)).toThrowError(TypeError);
+      expect(() => asPositiveInt16(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asPositiveInt16(Number.POSITIVE_INFINITY)).toThrowError(
+      expect(() => asPositiveInt16(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() => asPositiveInt16(Number.NEGATIVE_INFINITY)).toThrowError(
+      expect(() => asPositiveInt16(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() => asPositiveInt16(1.2)).toThrowError(TypeError);
+      expect(() => asPositiveInt16(1.2)).toThrow(TypeError);
 
-      expect(() => asPositiveInt16(-3.4)).toThrowError(TypeError);
+      expect(() => asPositiveInt16(-3.4)).toThrow(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)).toThrowError(
+        expect(() => asPositiveInt16(value)).toThrow(
           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.toThrowError();
+      expect(() => asPositiveInt32(1)).not.toThrow();
 
-      expect(() => asPositiveInt32(1000)).not.toThrowError();
+      expect(() => asPositiveInt32(1000)).not.toThrow();
 
-      expect(() => asPositiveInt32(2_147_483_647)).not.toThrowError(); // 2^31 - 1
+      expect(() => asPositiveInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveInt32(0)).toThrowError(TypeError);
+      expect(() => asPositiveInt32(0)).toThrow(TypeError);
     });
 
     test('rejects values outside int32 range', () => {
-      expect(() => asPositiveInt32(2_147_483_648)).toThrowError(TypeError); // 2^31
+      expect(() => asPositiveInt32(2_147_483_648)).toThrow(TypeError); // 2^31
 
-      expect(() => asPositiveInt32(4_294_967_296)).toThrowError(TypeError);
+      expect(() => asPositiveInt32(4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveInt32(-1)).toThrowError(TypeError);
+      expect(() => asPositiveInt32(-1)).toThrow(TypeError);
 
-      expect(() => asPositiveInt32(-42)).toThrowError(TypeError);
+      expect(() => asPositiveInt32(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveInt32(Number.NaN)).toThrowError(TypeError);
+      expect(() => asPositiveInt32(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asPositiveInt32(Number.POSITIVE_INFINITY)).toThrowError(
+      expect(() => asPositiveInt32(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() => asPositiveInt32(Number.NEGATIVE_INFINITY)).toThrowError(
+      expect(() => asPositiveInt32(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() => asPositiveInt32(1.2)).toThrowError(TypeError);
+      expect(() => asPositiveInt32(1.2)).toThrow(TypeError);
 
-      expect(() => asPositiveInt32(-3.4)).toThrowError(TypeError);
+      expect(() => asPositiveInt32(-3.4)).toThrow(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)).toThrowError(
+        expect(() => asPositiveInt32(value)).toThrow(
           new TypeError(
             `Expected a positive integer in [1, 2^31), got: ${value}`,
           ),

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

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