ts-data-forge 4.1.0 → 5.0.1

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

@@ -2,8 +2,8 @@ import { expectType } from '../../expect-type.mjs';
 import { range } from '../../iterator/index.mjs';
 import { asPositiveInt, isPositiveInt, PositiveInt } from './positive-int.mjs';
 
-describe('PositiveInt', () => {
-  describe('asPositiveInt', () => {
+describe('PositiveInt test', () => {
+  describe(asPositiveInt, () => {
     test('accepts valid positive integers', () => {
       expect(() => asPositiveInt(1)).not.toThrow();
       expect(() => asPositiveInt(2)).not.toThrow();
@@ -55,7 +55,7 @@ describe('PositiveInt', () => {
     );
   });
 
-  describe('isPositiveInt', () => {
+  describe(isPositiveInt, () => {
     test('correctly identifies positive integers', () => {
       expect(isPositiveInt(1)).toBe(true);
       expect(isPositiveInt(2)).toBe(true);
@@ -146,6 +146,7 @@ describe('PositiveInt', () => {
 
       for (const _ of range(10)) {
         const result = PositiveInt.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(PositiveInt.is(result)).toBe(true);
@@ -160,6 +161,7 @@ describe('PositiveInt', () => {
 
       for (const _ of range(10)) {
         const result = PositiveInt.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(1);
         expect(result).toBeLessThanOrEqual(5);
         expect(result).toBeGreaterThan(0);

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

@@ -6,8 +6,8 @@ import {
   PositiveInt16,
 } from './positive-int16.mjs';
 
-describe('PositiveInt16', () => {
-  describe('asPositiveInt16', () => {
+describe('PositiveInt16 test', () => {
+  describe(asPositiveInt16, () => {
     test('accepts valid positive int16 values', () => {
       expect(() => asPositiveInt16(1)).not.toThrow();
       expect(() => asPositiveInt16(1000)).not.toThrow();
@@ -67,7 +67,7 @@ describe('PositiveInt16', () => {
     );
   });
 
-  describe('isPositiveInt16', () => {
+  describe(isPositiveInt16, () => {
     test('correctly identifies positive int16 values', () => {
       expect(isPositiveInt16(1)).toBe(true);
       expect(isPositiveInt16(1000)).toBe(true);
@@ -126,6 +126,7 @@ describe('PositiveInt16', () => {
         asPositiveInt16(32_000),
         asPositiveInt16(1000),
       );
+
       expect(result).toBe(32_767); // clamped to max
       expect(PositiveInt16.add(a, b)).toBe(150);
     });
@@ -140,6 +141,7 @@ describe('PositiveInt16', () => {
         asPositiveInt16(1000),
         asPositiveInt16(100),
       );
+
       expect(result).toBe(32_767); // clamped to max
       expect(PositiveInt16.mul(asPositiveInt16(10), asPositiveInt16(5))).toBe(
         50,
@@ -159,6 +161,7 @@ describe('PositiveInt16', () => {
         asPositiveInt16(200),
         asPositiveInt16(3),
       );
+
       expect(result).toBe(32_767); // clamped to max
       expect(PositiveInt16.pow(asPositiveInt16(2), asPositiveInt16(3))).toBe(8);
     });
@@ -171,6 +174,7 @@ describe('PositiveInt16', () => {
 
       for (const _ of range(10)) {
         const result = PositiveInt16.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(PositiveInt16.is(result)).toBe(true);
@@ -182,6 +186,7 @@ describe('PositiveInt16', () => {
     test('generates values within PositiveInt16 range', () => {
       for (const _ of range(10)) {
         const result = PositiveInt16.random(1, 30);
+
         expect(result).toBeGreaterThanOrEqual(1);
         expect(result).toBeLessThanOrEqual(32_767);
       }

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

@@ -6,8 +6,8 @@ import {
   PositiveInt32,
 } from './positive-int32.mjs';
 
-describe('PositiveInt32', () => {
-  describe('asPositiveInt32', () => {
+describe('PositiveInt32 test', () => {
+  describe(asPositiveInt32, () => {
     test('accepts valid positive int32 values', () => {
       expect(() => asPositiveInt32(1)).not.toThrow();
       expect(() => asPositiveInt32(1000)).not.toThrow();
@@ -67,7 +67,7 @@ describe('PositiveInt32', () => {
     );
   });
 
-  describe('isPositiveInt32', () => {
+  describe(isPositiveInt32, () => {
     test('correctly identifies positive int32 values', () => {
       expect(isPositiveInt32(1)).toBe(true);
       expect(isPositiveInt32(1000)).toBe(true);
@@ -126,6 +126,7 @@ describe('PositiveInt32', () => {
         asPositiveInt32(2_147_483_000),
         asPositiveInt32(1000),
       );
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(PositiveInt32.add(a, b)).toBe(1_500_000);
     });
@@ -140,6 +141,7 @@ describe('PositiveInt32', () => {
         asPositiveInt32(100_000),
         asPositiveInt32(100_000),
       );
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(PositiveInt32.mul(asPositiveInt32(1000), asPositiveInt32(5))).toBe(
         5000,
@@ -159,6 +161,7 @@ describe('PositiveInt32', () => {
         asPositiveInt32(10_000),
         asPositiveInt32(3),
       );
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(PositiveInt32.pow(asPositiveInt32(2), asPositiveInt32(3))).toBe(8);
     });
@@ -171,6 +174,7 @@ describe('PositiveInt32', () => {
 
       for (const _ of range(10)) {
         const result = PositiveInt32.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(PositiveInt32.is(result)).toBe(true);
@@ -182,6 +186,7 @@ describe('PositiveInt32', () => {
     test('generates values within PositiveInt32 range', () => {
       for (const _ of range(10)) {
         const result = PositiveInt32.random(1, 30);
+
         expect(result).toBeGreaterThanOrEqual(1);
         expect(result).toBeLessThanOrEqual(2_147_483_647);
       }

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

@@ -6,8 +6,8 @@ import {
   PositiveSafeInt,
 } from './positive-safe-int.mjs';
 
-describe('PositiveSafeInt', () => {
-  describe('asPositiveSafeInt', () => {
+describe('PositiveSafeInt test', () => {
+  describe(asPositiveSafeInt, () => {
     test('accepts valid positive safe integers', () => {
       expect(() => asPositiveSafeInt(1)).not.toThrow();
       expect(() => asPositiveSafeInt(2)).not.toThrow();
@@ -72,7 +72,7 @@ describe('PositiveSafeInt', () => {
     );
   });
 
-  describe('isPositiveSafeInt', () => {
+  describe(isPositiveSafeInt, () => {
     test('correctly identifies positive safe integers', () => {
       expect(isPositiveSafeInt(1)).toBe(true);
       expect(isPositiveSafeInt(2)).toBe(true);
@@ -136,6 +136,7 @@ describe('PositiveSafeInt', () => {
     test('add (clamped to positive safe int range)', () => {
       const largeValue = asPositiveSafeInt(Number.MAX_SAFE_INTEGER - 1);
       const result = PositiveSafeInt.add(largeValue, asPositiveSafeInt(10));
+
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
       expect(PositiveSafeInt.add(a, b)).toBe(7);
     });
@@ -151,6 +152,7 @@ describe('PositiveSafeInt', () => {
         Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER)),
       );
       const result = PositiveSafeInt.mul(largeValue, largeValue);
+
       expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       expect(
         PositiveSafeInt.mul(asPositiveSafeInt(10), asPositiveSafeInt(5)),
@@ -170,6 +172,7 @@ describe('PositiveSafeInt', () => {
         asPositiveSafeInt(1000),
         asPositiveSafeInt(10),
       );
+
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
       expect(
         PositiveSafeInt.pow(asPositiveSafeInt(2), asPositiveSafeInt(3)),
@@ -184,6 +187,7 @@ describe('PositiveSafeInt', () => {
 
       for (const _ of range(10)) {
         const result = PositiveSafeInt.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(PositiveSafeInt.is(result)).toBe(true);
@@ -195,6 +199,7 @@ describe('PositiveSafeInt', () => {
     test('generates values within positive safe int range', () => {
       for (const _ of range(10)) {
         const result = PositiveSafeInt.random(1, 30);
+
         expect(result).toBeGreaterThanOrEqual(1);
         expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       }

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

@@ -6,8 +6,8 @@ import {
   PositiveUint16,
 } from './positive-uint16.mjs';
 
-describe('PositiveUint16', () => {
-  describe('asPositiveUint16', () => {
+describe('PositiveUint16 test', () => {
+  describe(asPositiveUint16, () => {
     test('accepts valid positive uint16 values', () => {
       expect(() => asPositiveUint16(1)).not.toThrow();
       expect(() => asPositiveUint16(1000)).not.toThrow();
@@ -68,7 +68,7 @@ describe('PositiveUint16', () => {
     );
   });
 
-  describe('isPositiveUint16', () => {
+  describe(isPositiveUint16, () => {
     test('correctly identifies positive uint16 values', () => {
       expect(isPositiveUint16(1)).toBe(true);
       expect(isPositiveUint16(1000)).toBe(true);
@@ -128,6 +128,7 @@ describe('PositiveUint16', () => {
         asPositiveUint16(65_000),
         asPositiveUint16(1000),
       );
+
       expect(result).toBe(65_535); // clamped to max
       expect(PositiveUint16.add(a, b)).toBe(150);
     });
@@ -142,6 +143,7 @@ describe('PositiveUint16', () => {
         asPositiveUint16(1000),
         asPositiveUint16(100),
       );
+
       expect(result).toBe(65_535); // clamped to max
       expect(
         PositiveUint16.mul(asPositiveUint16(10), asPositiveUint16(5)),
@@ -163,6 +165,7 @@ describe('PositiveUint16', () => {
         asPositiveUint16(256),
         asPositiveUint16(3),
       );
+
       expect(result).toBe(65_535); // clamped to max
       expect(PositiveUint16.pow(asPositiveUint16(2), asPositiveUint16(3))).toBe(
         8,
@@ -177,6 +180,7 @@ describe('PositiveUint16', () => {
 
       for (const _ of range(10)) {
         const result = PositiveUint16.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(PositiveUint16.is(result)).toBe(true);
@@ -188,6 +192,7 @@ describe('PositiveUint16', () => {
     test('generates values within PositiveUint16 range', () => {
       for (const _ of range(10)) {
         const result = PositiveUint16.random(1, 30);
+
         expect(result).toBeGreaterThanOrEqual(1);
         expect(result).toBeLessThanOrEqual(65_535);
       }

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

@@ -6,8 +6,8 @@ import {
   PositiveUint32,
 } from './positive-uint32.mjs';
 
-describe('PositiveUint32', () => {
-  describe('asPositiveUint32', () => {
+describe('PositiveUint32 test', () => {
+  describe(asPositiveUint32, () => {
     test('accepts valid positive uint32 values', () => {
       expect(() => asPositiveUint32(1)).not.toThrow();
       expect(() => asPositiveUint32(1000)).not.toThrow();
@@ -68,7 +68,7 @@ describe('PositiveUint32', () => {
     );
   });
 
-  describe('isPositiveUint32', () => {
+  describe(isPositiveUint32, () => {
     test('correctly identifies positive uint32 values', () => {
       expect(isPositiveUint32(1)).toBe(true);
       expect(isPositiveUint32(1000)).toBe(true);
@@ -128,6 +128,7 @@ describe('PositiveUint32', () => {
         asPositiveUint32(4_294_967_000),
         asPositiveUint32(1000),
       );
+
       expect(result).toBe(4_294_967_295); // clamped to max
       expect(PositiveUint32.add(a, b)).toBe(1_500_000);
     });
@@ -142,6 +143,7 @@ describe('PositiveUint32', () => {
         asPositiveUint32(100_000),
         asPositiveUint32(100_000),
       );
+
       expect(result).toBe(4_294_967_295); // clamped to max
       expect(
         PositiveUint32.mul(asPositiveUint32(1000), asPositiveUint32(5)),
@@ -166,6 +168,7 @@ describe('PositiveUint32', () => {
         asPositiveUint32(10_000),
         asPositiveUint32(3),
       );
+
       expect(result).toBe(4_294_967_295); // clamped to max
       expect(PositiveUint32.pow(asPositiveUint32(2), asPositiveUint32(3))).toBe(
         8,
@@ -180,6 +183,7 @@ describe('PositiveUint32', () => {
 
       for (const _ of range(10)) {
         const result = PositiveUint32.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(PositiveUint32.is(result)).toBe(true);
@@ -191,6 +195,7 @@ describe('PositiveUint32', () => {
     test('generates values within PositiveUint32 range', () => {
       for (const _ of range(10)) {
         const result = PositiveUint32.random(1, 30);
+
         expect(result).toBeGreaterThanOrEqual(1);
         expect(result).toBeLessThanOrEqual(4_294_967_295);
       }

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

@@ -2,8 +2,8 @@ import { expectType } from '../../expect-type.mjs';
 import { range } from '../../iterator/index.mjs';
 import { asSafeInt, SafeInt } from './safe-int.mjs';
 
-describe('SafeInt', () => {
-  describe('asSafeInt', () => {
+describe('SafeInt test', () => {
+  describe(asSafeInt, () => {
     test('accepts valid safe integers', () => {
       expect(() => asSafeInt(0)).not.toThrow();
       expect(() => asSafeInt(1)).not.toThrow();
@@ -105,6 +105,7 @@ describe('SafeInt', () => {
     test('add (with clamping to safe integer range)', () => {
       const largeValue = asSafeInt(Number.MAX_SAFE_INTEGER - 1);
       const result = SafeInt.add(largeValue, asSafeInt(10));
+
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
       expect(SafeInt.add(a, b)).toBe(7);
     });
@@ -112,6 +113,7 @@ describe('SafeInt', () => {
     test('sub (with clamping to safe integer range)', () => {
       const smallValue = asSafeInt(Number.MIN_SAFE_INTEGER + 1);
       const result = SafeInt.sub(smallValue, asSafeInt(10));
+
       expect(result).toBe(Number.MIN_SAFE_INTEGER); // clamped to min
       expect(SafeInt.sub(a, b)).toBe(3);
     });
@@ -121,6 +123,7 @@ describe('SafeInt', () => {
         Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER)),
       );
       const result = SafeInt.mul(largeValue, largeValue);
+
       expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       expect(SafeInt.mul(asSafeInt(10), asSafeInt(5))).toBe(50);
     });
@@ -133,6 +136,7 @@ describe('SafeInt', () => {
 
     test('pow (with clamping to safe integer range)', () => {
       const result = SafeInt.pow(asSafeInt(1000), asSafeInt(10));
+
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
       expect(SafeInt.pow(asSafeInt(2), asSafeInt(3))).toBe(8);
     });
@@ -145,6 +149,7 @@ describe('SafeInt', () => {
 
       for (const _ of range(10)) {
         const result = SafeInt.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(SafeInt.is(result)).toBe(true);
@@ -155,6 +160,7 @@ describe('SafeInt', () => {
     test('generates values within safe integer range', () => {
       for (const _ of range(10)) {
         const result = SafeInt.random(-30, 30);
+
         expect(result).toBeGreaterThanOrEqual(Number.MIN_SAFE_INTEGER);
         expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       }

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

@@ -2,8 +2,8 @@ import { expectType } from '../../expect-type.mjs';
 import { range } from '../../iterator/index.mjs';
 import { asSafeUint, isSafeUint, SafeUint } from './safe-uint.mjs';
 
-describe('SafeUint', () => {
-  describe('asSafeUint', () => {
+describe('SafeUint test', () => {
+  describe(asSafeUint, () => {
     test('accepts valid safe unsigned integers', () => {
       expect(() => asSafeUint(0)).not.toThrow();
       expect(() => asSafeUint(1)).not.toThrow();
@@ -52,7 +52,7 @@ describe('SafeUint', () => {
     });
   });
 
-  describe('isSafeUint', () => {
+  describe(isSafeUint, () => {
     test('correctly identifies safe unsigned integers', () => {
       expect(isSafeUint(0)).toBe(true);
       expect(isSafeUint(1)).toBe(true);
@@ -111,6 +111,7 @@ describe('SafeUint', () => {
     test('add (clamped to safe uint range)', () => {
       const largeValue = asSafeUint(Number.MAX_SAFE_INTEGER - 1);
       const result = SafeUint.add(largeValue, asSafeUint(10));
+
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
       expect(SafeUint.add(a, b)).toBe(7);
     });
@@ -126,6 +127,7 @@ describe('SafeUint', () => {
         Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER)),
       );
       const result = SafeUint.mul(largeValue, largeValue);
+
       expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       expect(SafeUint.mul(asSafeUint(10), asSafeUint(5))).toBe(50);
     });
@@ -138,6 +140,7 @@ describe('SafeUint', () => {
 
     test('pow (clamped to safe uint range)', () => {
       const result = SafeUint.pow(asSafeUint(1000), asSafeUint(10));
+
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
       expect(SafeUint.pow(asSafeUint(2), asSafeUint(3))).toBe(8);
     });
@@ -150,6 +153,7 @@ describe('SafeUint', () => {
 
       for (const _ of range(10)) {
         const result = SafeUint.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(SafeUint.is(result)).toBe(true);
@@ -161,6 +165,7 @@ describe('SafeUint', () => {
     test('generates values within safe uint range', () => {
       for (const _ of range(10)) {
         const result = SafeUint.random(0, 30);
+
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       }

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

@@ -2,8 +2,8 @@ import { expectType } from '../../expect-type.mjs';
 import { range } from '../../iterator/index.mjs';
 import { asUint, isUint, Uint } from './uint.mjs';
 
-describe('Uint', () => {
-  describe('asUint', () => {
+describe('Uint test', () => {
+  describe(asUint, () => {
     test('accepts valid unsigned integers', () => {
       expect(() => asUint(0)).not.toThrow();
       expect(() => asUint(1)).not.toThrow();
@@ -46,7 +46,7 @@ describe('Uint', () => {
     });
   });
 
-  describe('isUint', () => {
+  describe(isUint, () => {
     test('correctly identifies unsigned integers', () => {
       expect(isUint(0)).toBe(true);
       expect(isUint(1)).toBe(true);
@@ -132,6 +132,7 @@ describe('Uint', () => {
 
       for (const _ of range(10)) {
         const result = Uint.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(Uint.is(result)).toBe(true);
@@ -143,6 +144,7 @@ describe('Uint', () => {
     test('generates values starting from 0', () => {
       for (const _ of range(10)) {
         const result = Uint.random(0, 30);
+
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(30);
       }

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

@@ -3,8 +3,8 @@ import { range } from '../../iterator/index.mjs';
 import { asNonZeroUint16 } from './non-zero-uint16.mjs';
 import { asUint16, isUint16, Uint16 } from './uint16.mjs';
 
-describe('Uint16', () => {
-  describe('asUint16', () => {
+describe('Uint16 test', () => {
+  describe(asUint16, () => {
     test('accepts valid uint16 values', () => {
       expect(() => asUint16(0)).not.toThrow();
       expect(() => asUint16(1)).not.toThrow();
@@ -52,7 +52,7 @@ describe('Uint16', () => {
     });
   });
 
-  describe('isUint16', () => {
+  describe(isUint16, () => {
     test('correctly identifies uint16 values', () => {
       expect(isUint16(0)).toBe(true);
       expect(isUint16(1)).toBe(true);
@@ -108,6 +108,7 @@ describe('Uint16', () => {
 
     test('add (with clamping to uint16 range)', () => {
       const result = Uint16.add(asUint16(65_000), asUint16(1000));
+
       expect(result).toBe(65_535); // clamped to max
       expect(Uint16.add(a, b)).toBe(150);
     });
@@ -120,6 +121,7 @@ describe('Uint16', () => {
 
     test('mul (with clamping to uint16 range)', () => {
       const result = Uint16.mul(asUint16(1000), asUint16(100));
+
       expect(result).toBe(65_535); // clamped to max
       expect(Uint16.mul(asUint16(10), asUint16(5))).toBe(50);
     });
@@ -132,6 +134,7 @@ describe('Uint16', () => {
 
     test('pow (with clamping to uint16 range)', () => {
       const result = Uint16.pow(asUint16(256), asUint16(3));
+
       expect(result).toBe(65_535); // clamped to max
       expect(Uint16.pow(asUint16(2), asUint16(3))).toBe(8);
     });
@@ -144,6 +147,7 @@ describe('Uint16', () => {
 
       for (const _ of range(10)) {
         const result = Uint16.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(Uint16.is(result)).toBe(true);
@@ -155,6 +159,7 @@ describe('Uint16', () => {
     test('generates values within Uint16 range', () => {
       for (const _ of range(10)) {
         const result = Uint16.random(0, 30);
+
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(65_535);
       }

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

@@ -3,8 +3,8 @@ import { range } from '../../iterator/index.mjs';
 import { asNonZeroUint32 } from './non-zero-uint32.mjs';
 import { asUint32, isUint32, Uint32 } from './uint32.mjs';
 
-describe('Uint32', () => {
-  describe('asUint32', () => {
+describe('Uint32 test', () => {
+  describe(asUint32, () => {
     test('accepts valid uint32 values', () => {
       expect(() => asUint32(0)).not.toThrow();
       expect(() => asUint32(1)).not.toThrow();
@@ -52,7 +52,7 @@ describe('Uint32', () => {
     });
   });
 
-  describe('isUint32', () => {
+  describe(isUint32, () => {
     test('correctly identifies uint32 values', () => {
       expect(isUint32(0)).toBe(true);
       expect(isUint32(1)).toBe(true);
@@ -108,6 +108,7 @@ describe('Uint32', () => {
 
     test('add (with clamping to uint32 range)', () => {
       const result = Uint32.add(asUint32(4_294_967_000), asUint32(1000));
+
       expect(result).toBe(4_294_967_295); // clamped to max
       expect(Uint32.add(a, b)).toBe(1_500_000);
     });
@@ -120,6 +121,7 @@ describe('Uint32', () => {
 
     test('mul (with clamping to uint32 range)', () => {
       const result = Uint32.mul(asUint32(100_000), asUint32(100_000));
+
       expect(result).toBe(4_294_967_295); // clamped to max
       expect(Uint32.mul(asUint32(1000), asUint32(5))).toBe(5000);
     });
@@ -132,6 +134,7 @@ describe('Uint32', () => {
 
     test('pow (with clamping to uint32 range)', () => {
       const result = Uint32.pow(asUint32(10_000), asUint32(3));
+
       expect(result).toBe(4_294_967_295); // clamped to max
       expect(Uint32.pow(asUint32(2), asUint32(3))).toBe(8);
     });
@@ -144,6 +147,7 @@ describe('Uint32', () => {
 
       for (const _ of range(10)) {
         const result = Uint32.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(Uint32.is(result)).toBe(true);
@@ -155,6 +159,7 @@ describe('Uint32', () => {
     test('generates values within Uint32 range', () => {
       for (const _ of range(10)) {
         const result = Uint32.random(0, 30);
+
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(4_294_967_295);
       }

package/src/number/enum/int8.test.mts

@@ -1,8 +1,8 @@
 import { expectType } from '../../expect-type.mjs';
 import { Int8, asInt8, isInt8 } from './int8.mjs';
 
-describe('Int8', () => {
-  describe('isInt8', () => {
+describe('Int8 test', () => {
+  describe(isInt8, () => {
     test.each([
       { value: -128, expected: true },
       { value: 0, expected: true },
@@ -18,7 +18,7 @@ describe('Int8', () => {
     });
   });
 
-  describe('asInt8', () => {
+  describe(asInt8, () => {
     test.each([
       { value: -128, expected: -128 },
       { value: 0, expected: 0 },
@@ -48,6 +48,7 @@ describe('Int8', () => {
   describe('Int8.MIN_VALUE', () => {
     test('should be -128', () => {
       expect(Int8.MIN_VALUE).toBe(-128);
+
       expectType<typeof Int8.MIN_VALUE, -128>('=');
     });
   });
@@ -55,6 +56,7 @@ describe('Int8', () => {
   describe('Int8.MAX_VALUE', () => {
     test('should be 127', () => {
       expect(Int8.MAX_VALUE).toBe(127);
+
       expectType<typeof Int8.MAX_VALUE, 127>('=');
     });
   });
@@ -96,7 +98,9 @@ describe('Int8', () => {
       'Int8.abs($value) should return $expected',
       ({ expected, value }) => {
         const result = Int8.abs(value);
+
         expect(result).toBe(expected);
+
         expectType<typeof result, typeof expected>('=');
       },
     );
@@ -172,6 +176,7 @@ describe('Int8', () => {
       const min = -10;
       const max = 10;
       const result = Int8.random(min, max);
+
       expect(result).toBeGreaterThanOrEqual(min);
       expect(result).toBeLessThanOrEqual(max);
       expect(Number.isInteger(result)).toBe(true);