ts-data-forge 4.0.0 → 5.0.0

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

@@ -3,8 +3,8 @@ import { range } from '../../iterator/index.mjs';
 import { asInt16, Int16, isInt16 } from './int16.mjs';
 import { asNonZeroInt16 } from './non-zero-int16.mjs';
 
-describe('Int16', () => {
-  describe('asInt16', () => {
+describe('Int16 test', () => {
+  describe(asInt16, () => {
     test('accepts valid int16 values', () => {
       expect(() => asInt16(0)).not.toThrow();
       expect(() => asInt16(1)).not.toThrow();
@@ -49,7 +49,7 @@ describe('Int16', () => {
     });
   });
 
-  describe('isInt16', () => {
+  describe(isInt16, () => {
     test('correctly identifies int16 values', () => {
       expect(isInt16(0)).toBe(true);
       expect(isInt16(1)).toBe(true);
@@ -109,18 +109,21 @@ describe('Int16', () => {
 
     test('add (with clamping)', () => {
       const result = Int16.add(asInt16(32_000), asInt16(1000));
+
       expect(result).toBe(32_767); // clamped to max
       expect(Int16.add(a, b)).toBe(150);
     });
 
     test('sub (with clamping)', () => {
       const result = Int16.sub(asInt16(-32_000), asInt16(1000));
+
       expect(result).toBe(-32_768); // clamped to min
       expect(Int16.sub(a, b)).toBe(50);
     });
 
     test('mul (with clamping)', () => {
       const result = Int16.mul(asInt16(1000), asInt16(100));
+
       expect(result).toBe(32_767); // clamped to max
       expect(Int16.mul(asInt16(10), asInt16(5))).toBe(50);
     });
@@ -133,6 +136,7 @@ describe('Int16', () => {
 
     test('pow (with clamping)', () => {
       const result = Int16.pow(asInt16(200), asInt16(3));
+
       expect(result).toBe(32_767); // clamped to max
       expect(Int16.pow(asInt16(2), asInt16(3))).toBe(8);
     });
@@ -145,6 +149,7 @@ describe('Int16', () => {
 
       for (const _ of range(10)) {
         const result = Int16.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(Int16.is(result)).toBe(true);
@@ -155,6 +160,7 @@ describe('Int16', () => {
     test('generates values within Int16 range', () => {
       for (const _ of range(10)) {
         const result = Int16.random(-20, 20);
+
         expect(result).toBeGreaterThanOrEqual(Int16.MIN_VALUE);
         expect(result).toBeLessThanOrEqual(Int16.MAX_VALUE);
       }

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

@@ -3,8 +3,8 @@ import { range } from '../../iterator/index.mjs';
 import { asInt32, Int32, isInt32 } from './int32.mjs';
 import { asNonZeroInt32 } from './non-zero-int32.mjs';
 
-describe('Int32', () => {
-  describe('asInt32', () => {
+describe('Int32 test', () => {
+  describe(asInt32, () => {
     test('accepts valid int32 values', () => {
       expect(() => asInt32(0)).not.toThrow();
       expect(() => asInt32(1)).not.toThrow();
@@ -49,7 +49,7 @@ describe('Int32', () => {
     });
   });
 
-  describe('isInt32', () => {
+  describe(isInt32, () => {
     test('correctly identifies int32 values', () => {
       expect(isInt32(0)).toBe(true);
       expect(isInt32(1)).toBe(true);
@@ -109,18 +109,21 @@ describe('Int32', () => {
 
     test('add (with clamping)', () => {
       const result = Int32.add(asInt32(2_147_483_000), asInt32(1000));
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(Int32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (with clamping)', () => {
       const result = Int32.sub(asInt32(-2_147_483_000), asInt32(1000));
+
       expect(result).toBe(-2_147_483_648); // clamped to min
       expect(Int32.sub(a, b)).toBe(500_000);
     });
 
     test('mul (with clamping)', () => {
       const result = Int32.mul(asInt32(100_000), asInt32(100_000));
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(Int32.mul(asInt32(1000), asInt32(5))).toBe(5000);
     });
@@ -133,6 +136,7 @@ describe('Int32', () => {
 
     test('pow (with clamping)', () => {
       const result = Int32.pow(asInt32(10_000), asInt32(3));
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(Int32.pow(asInt32(2), asInt32(3))).toBe(8);
     });
@@ -145,6 +149,7 @@ describe('Int32', () => {
 
       for (const _ of range(10)) {
         const result = Int32.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(Int32.is(result)).toBe(true);
@@ -155,6 +160,7 @@ describe('Int32', () => {
     test('generates values within Int32 range', () => {
       for (const _ of range(10)) {
         const result = Int32.random(-20, 20);
+
         expect(result).toBeGreaterThanOrEqual(Int32.MIN_VALUE);
         expect(result).toBeLessThanOrEqual(Int32.MAX_VALUE);
       }

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

@@ -6,8 +6,8 @@ import {
   NonNegativeFiniteNumber,
 } from './non-negative-finite-number.mjs';
 
-describe('NonNegativeFiniteNumber', () => {
-  describe('asNonNegativeFiniteNumber', () => {
+describe('NonNegativeFiniteNumber test', () => {
+  describe(asNonNegativeFiniteNumber, () => {
     test('accepts valid non-negative finite numbers', () => {
       expect(() => asNonNegativeFiniteNumber(0)).not.toThrow();
       expect(() => asNonNegativeFiniteNumber(1)).not.toThrow();
@@ -55,7 +55,7 @@ describe('NonNegativeFiniteNumber', () => {
     );
   });
 
-  describe('isNonNegativeFiniteNumber', () => {
+  describe(isNonNegativeFiniteNumber, () => {
     test('correctly identifies non-negative finite numbers', () => {
       expect(isNonNegativeFiniteNumber(0)).toBe(true);
       expect(isNonNegativeFiniteNumber(1)).toBe(true);
@@ -131,7 +131,7 @@ describe('NonNegativeFiniteNumber', () => {
 
     test('div method exists', () => {
       // Test that the div function exists and is of the right type
-      expect(typeof NonNegativeFiniteNumber.div).toBe('function');
+      expectTypeOf(NonNegativeFiniteNumber.div).toBeFunction();
       // Note: Cannot test division without type assertions due to strict type requirements
     });
 
@@ -158,6 +158,7 @@ describe('NonNegativeFiniteNumber', () => {
 
       for (const _ of range(10)) {
         const result = NonNegativeFiniteNumber.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonNegativeFiniteNumber.is(result)).toBe(true);
@@ -171,6 +172,7 @@ describe('NonNegativeFiniteNumber', () => {
 
       for (const _ of range(10)) {
         const result = NonNegativeFiniteNumber.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(5);
       }

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

@@ -7,8 +7,8 @@ import {
 } from './non-negative-int16.mjs';
 import { asPositiveInt16 } from './positive-int16.mjs';
 
-describe('NonNegativeInt16', () => {
-  describe('asNonNegativeInt16', () => {
+describe('NonNegativeInt16 test', () => {
+  describe(asNonNegativeInt16, () => {
     test('accepts valid non-negative int16 values', () => {
       expect(() => asNonNegativeInt16(0)).not.toThrow();
       expect(() => asNonNegativeInt16(1)).not.toThrow();
@@ -65,7 +65,7 @@ describe('NonNegativeInt16', () => {
     );
   });
 
-  describe('isNonNegativeInt16', () => {
+  describe(isNonNegativeInt16, () => {
     test('correctly identifies non-negative int16 values', () => {
       expect(isNonNegativeInt16(0)).toBe(true);
       expect(isNonNegativeInt16(1)).toBe(true);
@@ -125,6 +125,7 @@ describe('NonNegativeInt16', () => {
         asNonNegativeInt16(32_000),
         asNonNegativeInt16(1000),
       );
+
       expect(result).toBe(32_767); // clamped to max
       expect(NonNegativeInt16.add(a, b)).toBe(150);
     });
@@ -140,6 +141,7 @@ describe('NonNegativeInt16', () => {
         asNonNegativeInt16(1000),
         asNonNegativeInt16(100),
       );
+
       expect(result).toBe(32_767); // clamped to max
       expect(
         NonNegativeInt16.mul(asNonNegativeInt16(10), asNonNegativeInt16(5)),
@@ -161,6 +163,7 @@ describe('NonNegativeInt16', () => {
         asNonNegativeInt16(200),
         asNonNegativeInt16(3),
       );
+
       expect(result).toBe(32_767); // clamped to max
       expect(
         NonNegativeInt16.pow(asNonNegativeInt16(2), asNonNegativeInt16(3)),
@@ -175,6 +178,7 @@ describe('NonNegativeInt16', () => {
 
       for (const _ of range(10)) {
         const result = NonNegativeInt16.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonNegativeInt16.is(result)).toBe(true);
@@ -186,6 +190,7 @@ describe('NonNegativeInt16', () => {
     test('generates values within NonNegativeInt16 range', () => {
       for (const _ of range(10)) {
         const result = NonNegativeInt16.random(0, 30);
+
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(32_767);
       }

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

@@ -7,8 +7,8 @@ import {
 } from './non-negative-int32.mjs';
 import { asPositiveInt32 } from './positive-int32.mjs';
 
-describe('NonNegativeInt32', () => {
-  describe('asNonNegativeInt32', () => {
+describe('NonNegativeInt32 test', () => {
+  describe(asNonNegativeInt32, () => {
     test('accepts valid non-negative int32 values', () => {
       expect(() => asNonNegativeInt32(0)).not.toThrow();
       expect(() => asNonNegativeInt32(1)).not.toThrow();
@@ -65,7 +65,7 @@ describe('NonNegativeInt32', () => {
     );
   });
 
-  describe('isNonNegativeInt32', () => {
+  describe(isNonNegativeInt32, () => {
     test('correctly identifies non-negative int32 values', () => {
       expect(isNonNegativeInt32(0)).toBe(true);
       expect(isNonNegativeInt32(1)).toBe(true);
@@ -125,6 +125,7 @@ describe('NonNegativeInt32', () => {
         asNonNegativeInt32(2_147_483_000),
         asNonNegativeInt32(1000),
       );
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(NonNegativeInt32.add(a, b)).toBe(1_500_000);
     });
@@ -140,6 +141,7 @@ describe('NonNegativeInt32', () => {
         asNonNegativeInt32(100_000),
         asNonNegativeInt32(100_000),
       );
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(
         NonNegativeInt32.mul(asNonNegativeInt32(1000), asNonNegativeInt32(5)),
@@ -164,6 +166,7 @@ describe('NonNegativeInt32', () => {
         asNonNegativeInt32(10_000),
         asNonNegativeInt32(3),
       );
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(
         NonNegativeInt32.pow(asNonNegativeInt32(2), asNonNegativeInt32(3)),
@@ -178,6 +181,7 @@ describe('NonNegativeInt32', () => {
 
       for (const _ of range(10)) {
         const result = NonNegativeInt32.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonNegativeInt32.is(result)).toBe(true);
@@ -189,6 +193,7 @@ describe('NonNegativeInt32', () => {
     test('generates values within NonNegativeInt32 range', () => {
       for (const _ of range(10)) {
         const result = NonNegativeInt32.random(0, 30);
+
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(2_147_483_647);
       }

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

@@ -6,8 +6,8 @@ import {
   NonZeroFiniteNumber,
 } from './non-zero-finite-number.mjs';
 
-describe('NonZeroFiniteNumber', () => {
-  describe('asNonZeroFiniteNumber', () => {
+describe('NonZeroFiniteNumber test', () => {
+  describe(asNonZeroFiniteNumber, () => {
     test('accepts valid non-zero finite numbers', () => {
       expect(() => asNonZeroFiniteNumber(1)).not.toThrow();
       expect(() => asNonZeroFiniteNumber(-1)).not.toThrow();
@@ -55,7 +55,7 @@ describe('NonZeroFiniteNumber', () => {
     );
   });
 
-  describe('isNonZeroFiniteNumber', () => {
+  describe(isNonZeroFiniteNumber, () => {
     test('correctly identifies non-zero finite numbers', () => {
       expect(isNonZeroFiniteNumber(1)).toBe(true);
       expect(isNonZeroFiniteNumber(-1)).toBe(true);
@@ -155,6 +155,7 @@ describe('NonZeroFiniteNumber', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroFiniteNumber.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroFiniteNumber.is(result)).toBe(true);
@@ -168,6 +169,7 @@ describe('NonZeroFiniteNumber', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroFiniteNumber.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroFiniteNumber.is(result)).toBe(true);
@@ -181,6 +183,7 @@ describe('NonZeroFiniteNumber', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroFiniteNumber.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroFiniteNumber.is(result)).toBe(true);

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

@@ -2,8 +2,8 @@ import { expectType } from '../../expect-type.mjs';
 import { range } from '../../iterator/index.mjs';
 import { asNonZeroInt, isNonZeroInt, NonZeroInt } from './non-zero-int.mjs';
 
-describe('NonZeroInt', () => {
-  describe('asNonZeroInt', () => {
+describe('NonZeroInt test', () => {
+  describe(asNonZeroInt, () => {
     test('accepts valid non-zero integers', () => {
       expect(() => asNonZeroInt(1)).not.toThrow();
       expect(() => asNonZeroInt(-1)).not.toThrow();
@@ -46,7 +46,7 @@ describe('NonZeroInt', () => {
     });
   });
 
-  describe('isNonZeroInt', () => {
+  describe(isNonZeroInt, () => {
     test('correctly identifies non-zero integers', () => {
       expect(isNonZeroInt(1)).toBe(true);
       expect(isNonZeroInt(-1)).toBe(true);
@@ -131,6 +131,7 @@ describe('NonZeroInt', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroInt.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroInt.is(result)).toBe(true);
@@ -145,6 +146,7 @@ describe('NonZeroInt', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroInt.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroInt.is(result)).toBe(true);
@@ -159,6 +161,7 @@ describe('NonZeroInt', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroInt.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroInt.is(result)).toBe(true);

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

@@ -6,8 +6,8 @@ import {
   NonZeroInt16,
 } from './non-zero-int16.mjs';
 
-describe('NonZeroInt16', () => {
-  describe('asNonZeroInt16', () => {
+describe('NonZeroInt16 test', () => {
+  describe(asNonZeroInt16, () => {
     test('accepts valid non-zero int16 values', () => {
       expect(() => asNonZeroInt16(1)).not.toThrow();
       expect(() => asNonZeroInt16(-1)).not.toThrow();
@@ -62,7 +62,7 @@ describe('NonZeroInt16', () => {
     );
   });
 
-  describe('isNonZeroInt16', () => {
+  describe(isNonZeroInt16, () => {
     test('correctly identifies non-zero int16 values', () => {
       expect(isNonZeroInt16(1)).toBe(true);
       expect(isNonZeroInt16(-1)).toBe(true);
@@ -127,6 +127,7 @@ describe('NonZeroInt16', () => {
         asNonZeroInt16(32_000),
         asNonZeroInt16(1000),
       );
+
       expect(result).toBe(32_767); // clamped to max
       expect(NonZeroInt16.add(a, b)).toBe(150);
     });
@@ -136,6 +137,7 @@ describe('NonZeroInt16', () => {
         asNonZeroInt16(-32_000),
         asNonZeroInt16(1000),
       );
+
       expect(result).toBe(-32_768); // clamped to min
       expect(NonZeroInt16.sub(a, b)).toBe(50);
     });
@@ -145,6 +147,7 @@ describe('NonZeroInt16', () => {
         asNonZeroInt16(1000),
         asNonZeroInt16(100),
       );
+
       expect(result).toBe(32_767); // clamped to max
       expect(NonZeroInt16.mul(asNonZeroInt16(10), asNonZeroInt16(5))).toBe(50);
     });
@@ -157,6 +160,7 @@ describe('NonZeroInt16', () => {
 
     test('pow (with clamping)', () => {
       const result = NonZeroInt16.pow(asNonZeroInt16(200), asNonZeroInt16(3));
+
       expect(result).toBe(32_767); // clamped to max
       expect(NonZeroInt16.pow(asNonZeroInt16(2), asNonZeroInt16(3))).toBe(8);
     });
@@ -169,6 +173,7 @@ describe('NonZeroInt16', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroInt16.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroInt16.is(result)).toBe(true);
@@ -180,6 +185,7 @@ describe('NonZeroInt16', () => {
     test('generates values within NonZeroInt16 range', () => {
       for (const _ of range(10)) {
         const result = NonZeroInt16.random(-20, 20);
+
         expect(result).toBeGreaterThanOrEqual(-32_768);
         expect(result).toBeLessThanOrEqual(32_767);
       }

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

@@ -6,8 +6,8 @@ import {
   NonZeroInt32,
 } from './non-zero-int32.mjs';
 
-describe('NonZeroInt32', () => {
-  describe('asNonZeroInt32', () => {
+describe('NonZeroInt32 test', () => {
+  describe(asNonZeroInt32, () => {
     test('accepts valid non-zero int32 values', () => {
       expect(() => asNonZeroInt32(1)).not.toThrow();
       expect(() => asNonZeroInt32(-1)).not.toThrow();
@@ -62,7 +62,7 @@ describe('NonZeroInt32', () => {
     );
   });
 
-  describe('isNonZeroInt32', () => {
+  describe(isNonZeroInt32, () => {
     test('correctly identifies non-zero int32 values', () => {
       expect(isNonZeroInt32(1)).toBe(true);
       expect(isNonZeroInt32(-1)).toBe(true);
@@ -127,6 +127,7 @@ describe('NonZeroInt32', () => {
         asNonZeroInt32(2_147_483_000),
         asNonZeroInt32(1000),
       );
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(NonZeroInt32.add(a, b)).toBe(1_500_000);
     });
@@ -136,6 +137,7 @@ describe('NonZeroInt32', () => {
         asNonZeroInt32(-2_147_483_000),
         asNonZeroInt32(1000),
       );
+
       expect(result).toBe(-2_147_483_648); // clamped to min
       expect(NonZeroInt32.sub(a, b)).toBe(500_000);
     });
@@ -145,6 +147,7 @@ describe('NonZeroInt32', () => {
         asNonZeroInt32(100_000),
         asNonZeroInt32(100_000),
       );
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(NonZeroInt32.mul(asNonZeroInt32(1000), asNonZeroInt32(5))).toBe(
         5000,
@@ -162,6 +165,7 @@ describe('NonZeroInt32', () => {
         asNonZeroInt32(10_000),
         asNonZeroInt32(3),
       );
+
       expect(result).toBe(2_147_483_647); // clamped to max
       expect(NonZeroInt32.pow(asNonZeroInt32(2), asNonZeroInt32(3))).toBe(8);
     });
@@ -174,6 +178,7 @@ describe('NonZeroInt32', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroInt32.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroInt32.is(result)).toBe(true);
@@ -185,6 +190,7 @@ describe('NonZeroInt32', () => {
     test('generates values within NonZeroInt32 range', () => {
       for (const _ of range(10)) {
         const result = NonZeroInt32.random(-20, 20);
+
         expect(result).toBeGreaterThanOrEqual(-2_147_483_648);
         expect(result).toBeLessThanOrEqual(2_147_483_647);
       }

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

@@ -6,8 +6,8 @@ import {
   NonZeroSafeInt,
 } from './non-zero-safe-int.mjs';
 
-describe('NonZeroSafeInt', () => {
-  describe('asNonZeroSafeInt', () => {
+describe('NonZeroSafeInt test', () => {
+  describe(asNonZeroSafeInt, () => {
     test('accepts valid non-zero safe integers', () => {
       expect(() => asNonZeroSafeInt(1)).not.toThrow();
       expect(() => asNonZeroSafeInt(-1)).not.toThrow();
@@ -68,7 +68,7 @@ describe('NonZeroSafeInt', () => {
     );
   });
 
-  describe('isNonZeroSafeInt', () => {
+  describe(isNonZeroSafeInt, () => {
     test('correctly identifies non-zero safe integers', () => {
       expect(isNonZeroSafeInt(1)).toBe(true);
       expect(isNonZeroSafeInt(-1)).toBe(true);
@@ -135,6 +135,7 @@ describe('NonZeroSafeInt', () => {
     test('add (with clamping to safe integer range)', () => {
       const largeValue = asNonZeroSafeInt(Number.MAX_SAFE_INTEGER - 1);
       const result = NonZeroSafeInt.add(largeValue, asNonZeroSafeInt(10));
+
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
       expect(NonZeroSafeInt.add(a, b)).toBe(7);
     });
@@ -142,6 +143,7 @@ describe('NonZeroSafeInt', () => {
     test('sub (with clamping to safe integer range)', () => {
       const smallValue = asNonZeroSafeInt(Number.MIN_SAFE_INTEGER + 1);
       const result = NonZeroSafeInt.sub(smallValue, asNonZeroSafeInt(10));
+
       expect(result).toBe(Number.MIN_SAFE_INTEGER); // clamped to min
       expect(NonZeroSafeInt.sub(a, b)).toBe(3);
     });
@@ -151,6 +153,7 @@ describe('NonZeroSafeInt', () => {
         Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER)),
       );
       const result = NonZeroSafeInt.mul(largeValue, largeValue);
+
       expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       expect(
         NonZeroSafeInt.mul(asNonZeroSafeInt(10), asNonZeroSafeInt(5)),
@@ -172,6 +175,7 @@ describe('NonZeroSafeInt', () => {
         asNonZeroSafeInt(1000),
         asNonZeroSafeInt(10),
       );
+
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
       expect(NonZeroSafeInt.pow(asNonZeroSafeInt(2), asNonZeroSafeInt(3))).toBe(
         8,
@@ -186,6 +190,7 @@ describe('NonZeroSafeInt', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroSafeInt.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroSafeInt.is(result)).toBe(true);
@@ -200,6 +205,7 @@ describe('NonZeroSafeInt', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroSafeInt.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroSafeInt.is(result)).toBe(true);
@@ -214,6 +220,7 @@ describe('NonZeroSafeInt', () => {
 
       for (const _ of range(10)) {
         const result = NonZeroSafeInt.random(min, max);
+
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
         expect(NonZeroSafeInt.is(result)).toBe(true);

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

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