ts-data-forge 6.0.0 → 6.1.1

package/src/functional/optional.test.mts

@@ -218,7 +218,7 @@ describe('Optional test', () => {
     });
 
     test('should throw for None', () => {
-      expect(() => Optional.unwrapThrow(Optional.none)).toThrow(
+      expect(() => Optional.unwrapThrow(Optional.none)).toThrowError(
         '`unwrapThrow()` has failed because it is `None`',
       );
     });
@@ -300,7 +300,9 @@ describe('Optional test', () => {
     test('should throw with custom message for None', () => {
       const expectNumber = Optional.expectToBe<number>('Expected a number');
 
-      expect(() => expectNumber(Optional.none)).toThrow('Expected a number');
+      expect(() => expectNumber(Optional.none)).toThrowError(
+        'Expected a number',
+      );
     });
 
     test('should be curried', () => {
@@ -312,7 +314,7 @@ describe('Optional test', () => {
 
       expect(expectValidId(id1)).toBe('user-123');
 
-      expect(() => expectValidId(id2)).toThrow('ID is required');
+      expect(() => expectValidId(id2)).toThrowError('ID is required');
     });
 
     test('should support curried form', () => {
@@ -326,7 +328,7 @@ describe('Optional test', () => {
 
       const noneValue = Optional.none;
 
-      expect(() => getValue(noneValue)).toThrow('Value must exist');
+      expect(() => getValue(noneValue)).toThrowError('Value must exist');
     });
 
     test('should work with pipe when curried', () => {
@@ -338,7 +340,7 @@ describe('Optional test', () => {
 
       assert.deepStrictEqual(someResult, { name: 'Alice', age: 30 });
 
-      expect(() => pipe(Optional.none).map(expectUser).value).toThrow(
+      expect(() => pipe(Optional.none).map(expectUser).value).toThrowError(
         'User not found',
       );
     });

package/src/functional/result.test.mts

@@ -248,7 +248,7 @@ describe('Result test', () => {
     test('throws on Err result', () => {
       const result = Result.err('error message');
 
-      expect(() => Result.unwrapThrow(result)).toThrow('error message');
+      expect(() => Result.unwrapThrow(result)).toThrowError('error message');
     });
   });
 
@@ -589,7 +589,7 @@ describe('Result test', () => {
     test('should throw for Ok', () => {
       const result = Result.ok(42);
 
-      expect(() => Result.unwrapErrThrow(result)).toThrow(
+      expect(() => Result.unwrapErrThrow(result)).toThrowError(
         'Expected Err but got Ok: 42',
       );
     });
@@ -599,7 +599,7 @@ describe('Result test', () => {
 
       expect(() =>
         Result.unwrapErrThrow(result, (obj) => `Object(id=${obj.id})`),
-      ).toThrow('Expected Err but got Ok: Object(id=1)');
+      ).toThrowError('Expected Err but got Ok: Object(id=1)');
     });
   });
 
@@ -665,9 +665,9 @@ describe('Result test', () => {
     test('should throw custom error for Err result', () => {
       const result = Result.err('failed');
 
-      expect(() => Result.expectToBe(result, 'Operation must succeed')).toThrow(
-        'Operation must succeed',
-      );
+      expect(() =>
+        Result.expectToBe(result, 'Operation must succeed'),
+      ).toThrowError('Operation must succeed');
     });
 
     test('should support curried form', () => {
@@ -681,7 +681,9 @@ describe('Result test', () => {
 
       const errResult: Result<string, string> = Result.err('failed');
 
-      expect(() => mustBeOk(errResult)).toThrow('Expected successful result');
+      expect(() => mustBeOk(errResult)).toThrowError(
+        'Expected successful result',
+      );
     });
 
     test('should work with pipe when curried', () => {
@@ -693,7 +695,7 @@ describe('Result test', () => {
 
       expect(
         () => pipe(Result.err('validation error')).map(mustBeOk).value,
-      ).toThrow('Validation failed');
+      ).toThrowError('Validation failed');
     });
   });
 

package/src/functional/ternary-result.test.mts

@@ -171,15 +171,15 @@ describe('TernaryResult test', () => {
   test('throwing unwrap variants provide descriptive errors', () => {
     expect(() =>
       TernaryResult.unwrapThrow(TernaryResult.warn('notice', 'warned')),
-    ).toThrow(/Warn/u);
+    ).toThrowError(/Warn/u);
 
     expect(() =>
       TernaryResult.unwrapWarnThrow(TernaryResult.err('no warn')),
-    ).toThrow(/Err/u);
+    ).toThrowError(/Err/u);
 
     expect(() =>
       TernaryResult.unwrapErrThrow(TernaryResult.ok('no err')),
-    ).toThrow(/Ok/u);
+    ).toThrowError(/Ok/u);
   });
 
   test('expectToBe unwraps Ok values', () => {
@@ -187,7 +187,7 @@ describe('TernaryResult test', () => {
 
     expect(() =>
       TernaryResult.expectToBe(TernaryResult.err('x'), 'missing'),
-    ).toThrow(/missing/u);
+    ).toThrowError(/missing/u);
   });
 
   test('zip prefers Err over Warn or Ok.', () => {

package/src/globals.d.mts

@@ -13,8 +13,7 @@ type ArgArrayIndex<Ar extends readonly unknown[]> =
 
 type ArgArrayIndexWithNegative<Ar extends readonly unknown[]> =
   IsFixedLengthList<Ar> extends true
-    ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-        IndexOfTuple<[...Ar, 0]> | NegativeIndexOfTuple<Ar>
+    ? IndexOfTuple<[...Ar, 0]> | NegativeIndexOfTuple<Ar>
     : SizeType.ArgArrWithNegative;
 
 // https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/length

package/src/guard/has-key.mts

@@ -58,14 +58,11 @@ export type HasKeyReturnType<
 > = R extends R // union distribution
   ? K extends keyof R
     ? string extends keyof R
-      ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-        ReadonlyRecord<K, R[keyof R]> & R
+      ? ReadonlyRecord<K, R[keyof R]> & R
       : number extends keyof R
-        ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-          ReadonlyRecord<K, R[keyof R]> & R
+        ? ReadonlyRecord<K, R[keyof R]> & R
         : symbol extends keyof R
-          ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-            ReadonlyRecord<K, R[keyof R]> & R
+          ? ReadonlyRecord<K, R[keyof R]> & R
           : R
     : never // omit union member that does not have key K
   : never; // dummy case for union distribution

package/src/guard/has-key.test.mts

@@ -1,223 +1,126 @@
 import { expectType } from '../expect-type.mjs';
 import { hasKey, type HasKeyReturnType } from './has-key.mjs';
 
-{
-  expectType<
-    HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'a'>,
-    Readonly<{ a: 0 }>
-  >('=');
-
-  expectType<
-    HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'b'>,
-    Readonly<{ b: 1 }>
-  >('=');
-
-  expectType<
-    HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'd'>,
-    never
-  >('=');
-
-  expectType<
-    HasKeyReturnType<
-      | Readonly<{ a: 0 }>
-      | Readonly<{ a: 1; b: 1 }>
-      | Readonly<{ b: 2 }>
-      | Readonly<{ c: 3 }>,
-      'a'
-    >,
-    Readonly<{ a: 0 }> | Readonly<{ a: 1; b: 1 }>
-  >('=');
-
-  expectType<
-    HasKeyReturnType<
-      | Readonly<{ a: 0 }>
-      | Readonly<{ a: 1; b: 1 }>
-      | Readonly<{ b: 2 }>
-      | Readonly<{ c: 3 }>,
-      'b'
-    >,
-    Readonly<{ a: 1; b: 1 }> | Readonly<{ b: 2 }>
-  >('=');
-
-  expectType<
-    HasKeyReturnType<
-      | ReadonlyRecord<string, number>
-      | Readonly<{ a: 0 }>
-      | Readonly<{ a: 1; b: 1 }>
-      | Readonly<{ b: 2 }>,
-      'a'
-    >,
-    | Readonly<{ a: 0 }>
-    | Readonly<{ a: 1; b: 1 }>
-    | (ReadonlyRecord<'a', number> & ReadonlyRecord<string, number>)
-  >('=');
-
-  expectType<
-    HasKeyReturnType<ReadonlyRecord<string, unknown>, 'a'>,
-    ReadonlyRecord<'a', unknown> & ReadonlyRecord<string, unknown>
-  >('=');
-}
-
-{
-  type R = Readonly<{ a: 0 }> | Readonly<{ b: 1 }>;
-
-  const obj: R = { a: 0 } as R;
-
-  if (hasKey(obj, 'a')) {
-    expectType<typeof obj.a, 0>('=');
-
-    expectType<typeof obj, Readonly<{ a: 0 }>>('=');
-  }
-
-  if (hasKey(obj, 'c')) {
-    expectType<typeof obj, never>('=');
-  }
-}
-
-{
-  type R =
-    | Readonly<{ a: 0 }>
-    | Readonly<{ a: 1; b: 1 }>
-    | Readonly<{ b: 2 }>
-    | Readonly<{ c: 3 }>;
-
-  const obj: R = { a: 0 } as R;
-
-  if (hasKey(obj, 'a') && hasKey(obj, 'b')) {
-    expectType<typeof obj.a, 1>('=');
-
-    expectType<typeof obj.b, 1>('=');
-
-    expectType<typeof obj, Readonly<{ a: 1; b: 1 }>>('=');
-  }
-}
+test('hasKey type inferences', () => {
+  {
+    expectType<
+      HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'a'>,
+      Readonly<{ a: 0 }>
+    >('=');
 
-{
-  type R =
-    | ReadonlyRecord<string, number>
-    | Readonly<{ a: 0 }>
-    | Readonly<{ a: 1; b: 1 }>
-    | Readonly<{ b: 2 }>;
+    expectType<
+      HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'b'>,
+      Readonly<{ b: 1 }>
+    >('=');
 
-  const obj: R = { a: 0 } as R;
+    expectType<
+      HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'd'>,
+      never
+    >('=');
 
-  expectType<
-    R,
-    | ReadonlyRecord<string, number>
-    | Readonly<{ a: 0 }>
-    | Readonly<{ a: 1; b: 1 }>
-    | Readonly<{ b: 2 }>
-  >('=');
+    expectType<
+      HasKeyReturnType<
+        | Readonly<{ a: 0 }>
+        | Readonly<{ a: 1; b: 1 }>
+        | Readonly<{ b: 2 }>
+        | Readonly<{ c: 3 }>,
+        'a'
+      >,
+      Readonly<{ a: 0 }> | Readonly<{ a: 1; b: 1 }>
+    >('=');
 
-  if (hasKey(obj, 'a')) {
-    expectType<typeof obj.a, number>('=');
+    expectType<
+      HasKeyReturnType<
+        | Readonly<{ a: 0 }>
+        | Readonly<{ a: 1; b: 1 }>
+        | Readonly<{ b: 2 }>
+        | Readonly<{ c: 3 }>,
+        'b'
+      >,
+      Readonly<{ a: 1; b: 1 }> | Readonly<{ b: 2 }>
+    >('=');
 
     expectType<
-      typeof obj,
+      HasKeyReturnType<
+        | ReadonlyRecord<string, number>
+        | Readonly<{ a: 0 }>
+        | Readonly<{ a: 1; b: 1 }>
+        | Readonly<{ b: 2 }>,
+        'a'
+      >,
       | Readonly<{ a: 0 }>
       | Readonly<{ a: 1; b: 1 }>
       | (ReadonlyRecord<'a', number> & ReadonlyRecord<string, number>)
     >('=');
-  }
-
-  if (hasKey(obj, 'a') && hasKey(obj, 'b')) {
-    expectType<typeof obj.a, number>('=');
-
-    expectType<typeof obj.b, number>('=');
 
     expectType<
-      typeof obj,
-      | Readonly<{ a: 1; b: 1 }>
-      | (ReadonlyRecord<'a', number> &
-          ReadonlyRecord<'b', number> &
-          ReadonlyRecord<string, number>)
+      HasKeyReturnType<ReadonlyRecord<string, unknown>, 'a'>,
+      ReadonlyRecord<'a', unknown> & ReadonlyRecord<string, unknown>
     >('=');
   }
-}
 
-{
-  const o: ReadonlyRecord<string, unknown> = { a: 0, b: 1 };
+  {
+    type R = Readonly<{ a: 0 }> | Readonly<{ b: 1 }>;
 
-  if (hasKey(o, 'a')) {
-    expectType<typeof o.a, unknown>('=');
+    const obj: R = { a: 0 } as R;
 
-    expectType<
-      typeof o,
-      ReadonlyRecord<'a', unknown> & ReadonlyRecord<string, unknown>
-    >('=');
-  }
+    if (hasKey(obj, 'a')) {
+      expectType<typeof obj.a, 0>('=');
 
-  if (hasKey(o, 'c')) {
-    expectType<typeof o.c, unknown>('=');
+      expectType<typeof obj, Readonly<{ a: 0 }>>('=');
+    }
 
-    expectType<
-      typeof o,
-      ReadonlyRecord<'c', unknown> & ReadonlyRecord<string, unknown>
-    >('=');
+    if (hasKey(obj, 'c')) {
+      expectType<typeof obj, never>('=');
+    }
   }
 
-  if (hasKey(o, 'a') && hasKey(o, 'b')) {
-    expectType<typeof o.a, unknown>('=');
+  {
+    type R =
+      | Readonly<{ a: 0 }>
+      | Readonly<{ a: 1; b: 1 }>
+      | Readonly<{ b: 2 }>
+      | Readonly<{ c: 3 }>;
 
-    expectType<typeof o.b, unknown>('=');
+    const obj: R = { a: 0 } as R;
 
-    expectType<
-      typeof o,
-      ReadonlyRecord<'a', unknown> &
-        ReadonlyRecord<'b', unknown> &
-        ReadonlyRecord<string, unknown>
-    >('=');
+    if (hasKey(obj, 'a') && hasKey(obj, 'b')) {
+      expectType<typeof obj.a, 1>('=');
+
+      expectType<typeof obj.b, 1>('=');
+
+      expectType<typeof obj, Readonly<{ a: 1; b: 1 }>>('=');
+    }
   }
 
   {
-    /**
-     * @note Simply using `R & Record<K, R[K]>` as the return type of hasKey may seem good enough
-     * since it works as intended for cases like `obj: Record<string, unknown>`.
-     * However, for finite-sized types like `obj: { a: 0 } | { b: 1 }`,
-     * filtering with `hasKey(obj, 'a')` causes `obj.a` to widen to `unknown` instead of `0`,
-     * which doesn't work well.
-     */
-
-    const hasOwnNaive = <R extends UnknownRecord, K extends string>(
-      obj: R,
-      key: K,
-    ): obj is R & Record<K, R[K]> => hasKey(obj, key);
-
-    {
-      type O =
-        | Readonly<{ a: 0 }>
-        | Readonly<{ a: 1; b: 1 }>
-        | Readonly<{ b: 2 }>
-        | Record<string, number>;
+    type R =
+      | ReadonlyRecord<string, number>
+      | Readonly<{ a: 0 }>
+      | Readonly<{ a: 1; b: 1 }>
+      | Readonly<{ b: 2 }>;
 
-      const o2 = { b: 2 } as O;
+    const obj: R = { a: 0 } as R;
 
-      if (hasOwnNaive(o2, 'a')) {
-        expectType<typeof o2.a, unknown>('=');
-      }
+    expectType<
+      R,
+      | ReadonlyRecord<string, number>
+      | Readonly<{ a: 0 }>
+      | Readonly<{ a: 1; b: 1 }>
+      | Readonly<{ b: 2 }>
+    >('=');
 
-      // eslint-disable-next-line no-restricted-syntax
-      if ('a' in o2) {
-        expectType<typeof o2.a, number>('=');
-      }
-    }
+    if (hasKey(obj, 'a')) {
+      expectType<typeof obj.a, number>('=');
 
-    {
-      type O =
+      expectType<
+        typeof obj,
         | Readonly<{ a: 0 }>
         | Readonly<{ a: 1; b: 1 }>
-        | Readonly<{ b: 2 }>;
-
-      const o2 = { b: 2 } as O;
-
-      if (hasOwnNaive(o2, 'a')) {
-        expectType<typeof o2.a, unknown>('=');
-      }
-
-      // eslint-disable-next-line no-restricted-syntax
-      if ('a' in o2) {
-        expectType<typeof o2.a, 0 | 1>('=');
-      }
+        | (ReadonlyRecord<'a', number> & ReadonlyRecord<string, number>)
+      >('=');
     }
   }
-}
+
+  assert.strictEqual(true, true);
+});

package/src/json/json.test.mts

@@ -118,11 +118,11 @@ describe('parse', () => {
   });
 
   test('should not throw errors', () => {
-    expect(() => Json.parse('{{{')).not.toThrow();
+    expect(() => Json.parse('{{{')).not.toThrowError();
 
-    expect(() => Json.parse('null null')).not.toThrow();
+    expect(() => Json.parse('null null')).not.toThrowError();
 
-    expect(() => Json.parse(String(undefined))).not.toThrow();
+    expect(() => Json.parse(String(undefined))).not.toThrowError();
   });
 
   test('should use reviver function to transform values', () => {
@@ -323,9 +323,9 @@ describe('stringify', () => {
 
     mut_circularArray.push(mut_circularArray);
 
-    expect(() => Json.stringify(mut_circularArray)).not.toThrow();
+    expect(() => Json.stringify(mut_circularArray)).not.toThrowError();
 
-    expect(() => Json.stringify({ fn: () => {} })).not.toThrow();
+    expect(() => Json.stringify({ fn: () => {} })).not.toThrowError();
   });
 
   test('should use replacer function to filter values', () => {

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

@@ -6,27 +6,31 @@ import { asNonZeroFiniteNumber } from './non-zero-finite-number.mjs';
 describe('FiniteNumber test', () => {
   describe(asFiniteNumber, () => {
     test('accepts valid finite numbers', () => {
-      expect(() => asFiniteNumber(0)).not.toThrow();
+      expect(() => asFiniteNumber(0)).not.toThrowError();
 
-      expect(() => asFiniteNumber(1)).not.toThrow();
+      expect(() => asFiniteNumber(1)).not.toThrowError();
 
-      expect(() => asFiniteNumber(-1)).not.toThrow();
+      expect(() => asFiniteNumber(-1)).not.toThrowError();
 
-      expect(() => asFiniteNumber(3.14)).not.toThrow();
+      expect(() => asFiniteNumber(3.14)).not.toThrowError();
 
-      expect(() => asFiniteNumber(-2.5)).not.toThrow();
+      expect(() => asFiniteNumber(-2.5)).not.toThrowError();
 
-      expect(() => asFiniteNumber(Number.MAX_VALUE)).not.toThrow();
+      expect(() => asFiniteNumber(Number.MAX_VALUE)).not.toThrowError();
 
-      expect(() => asFiniteNumber(-Number.MAX_VALUE)).not.toThrow();
+      expect(() => asFiniteNumber(-Number.MAX_VALUE)).not.toThrowError();
     });
 
     test('rejects non-finite numbers', () => {
-      expect(() => asFiniteNumber(Number.NaN)).toThrow(TypeError);
+      expect(() => asFiniteNumber(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asFiniteNumber(Number.POSITIVE_INFINITY)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asFiniteNumber(Number.NEGATIVE_INFINITY)).toThrowError(
+        TypeError,
+      );
     });
 
     test('returns the same value for valid inputs', () => {
@@ -44,7 +48,7 @@ describe('FiniteNumber test', () => {
     ] as const)(
       `asFiniteNumber($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asFiniteNumber(value)).toThrow(
+        expect(() => asFiniteNumber(value)).toThrowError(
           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.toThrow();
+      expect(() => asInt(0)).not.toThrowError();
 
-      expect(() => asInt(1)).not.toThrow();
+      expect(() => asInt(1)).not.toThrowError();
 
-      expect(() => asInt(-1)).not.toThrow();
+      expect(() => asInt(-1)).not.toThrowError();
 
-      expect(() => asInt(42)).not.toThrow();
+      expect(() => asInt(42)).not.toThrowError();
 
-      expect(() => asInt(-42)).not.toThrow();
+      expect(() => asInt(-42)).not.toThrowError();
 
-      expect(() => asInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+      expect(() => asInt(Number.MAX_SAFE_INTEGER)).not.toThrowError();
 
-      expect(() => asInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
+      expect(() => asInt(Number.MIN_SAFE_INTEGER)).not.toThrowError();
     });
 
     test('rejects non-integers', () => {
-      expect(() => asInt(Number.NaN)).toThrow(TypeError);
+      expect(() => asInt(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asInt(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asInt(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asInt(1.2)).toThrow(TypeError);
+      expect(() => asInt(1.2)).toThrowError(TypeError);
 
-      expect(() => asInt(-3.4)).toThrow(TypeError);
+      expect(() => asInt(-3.4)).toThrowError(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)).toThrow(
+      expect(() => asInt(value)).toThrowError(
         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.toThrow();
+      expect(() => asInt16(0)).not.toThrowError();
 
-      expect(() => asInt16(1)).not.toThrow();
+      expect(() => asInt16(1)).not.toThrowError();
 
-      expect(() => asInt16(-1)).not.toThrow();
+      expect(() => asInt16(-1)).not.toThrowError();
 
-      expect(() => asInt16(32_767)).not.toThrow(); // 2^15 - 1
+      expect(() => asInt16(32_767)).not.toThrowError(); // 2^15 - 1
 
-      expect(() => asInt16(-32_768)).not.toThrow(); // -2^15
+      expect(() => asInt16(-32_768)).not.toThrowError(); // -2^15
     });
 
     test('rejects values outside int16 range', () => {
-      expect(() => asInt16(32_768)).toThrow(TypeError); // 2^15
+      expect(() => asInt16(32_768)).toThrowError(TypeError); // 2^15
 
-      expect(() => asInt16(-32_769)).toThrow(TypeError); // -2^15 - 1
+      expect(() => asInt16(-32_769)).toThrowError(TypeError); // -2^15 - 1
 
-      expect(() => asInt16(65_536)).toThrow(TypeError);
+      expect(() => asInt16(65_536)).toThrowError(TypeError);
 
-      expect(() => asInt16(-65_536)).toThrow(TypeError);
+      expect(() => asInt16(-65_536)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asInt16(Number.NaN)).toThrow(TypeError);
+      expect(() => asInt16(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asInt16(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asInt16(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asInt16(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asInt16(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asInt16(1.2)).toThrow(TypeError);
+      expect(() => asInt16(1.2)).toThrowError(TypeError);
 
-      expect(() => asInt16(-3.4)).toThrow(TypeError);
+      expect(() => asInt16(-3.4)).toThrowError(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)).toThrow(
+      expect(() => asInt16(value)).toThrowError(
         new TypeError(`Expected an integer in [-2^15, 2^15), got: ${value}`),
       );
     });