ts-data-forge 3.3.0 → 4.0.0

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

@@ -6,19 +6,19 @@ type ElementType = NonZeroUint16;
 const typeNameInMessage = 'a non-zero integer in [1, 2^16)';
 
 const {
-  MIN_VALUE,
   MAX_VALUE,
-  min: min_,
-  max: max_,
-  pow,
+  MIN_VALUE,
   add,
-  sub,
-  mul,
-  div,
-  randomNonZero: random,
-  is,
   castType,
   clamp,
+  div,
+  is,
+  max: max_,
+  min: min_,
+  mul,
+  pow,
+  randomNonZero: random,
+  sub,
 } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
   ElementType,
   1,
@@ -32,7 +32,9 @@ const {
 } as const);
 
 /**
- * Checks if a number is a NonZeroUint16 (16-bit non-zero unsigned integer in the range [1, 2^16)).
+ * Checks if a number is a NonZeroUint16 (16-bit non-zero unsigned integer in
+ * the range [1, 2^16)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroUint16, `false` otherwise.
  */
@@ -40,70 +42,49 @@ export const isNonZeroUint16 = is;
 
 /**
  * Casts a number to a NonZeroUint16 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroUint16 type.
  * @throws {TypeError} If the value is not a non-zero integer in [1, 2^16).
- * @example
- * ```typescript
- * const x = asNonZeroUint16(1000); // NonZeroUint16
- * const y = asNonZeroUint16(65535); // NonZeroUint16
- * // asNonZeroUint16(0); // throws TypeError
- * // asNonZeroUint16(-1); // throws TypeError
- * // asNonZeroUint16(65536); // throws TypeError
- * ```
  */
 export const asNonZeroUint16 = castType;
 
 /**
- * Namespace providing type-safe arithmetic operations for 16-bit non-zero unsigned integers.
- *
- * All operations automatically clamp results to the valid NonZeroUint16 range [1, 65535].
- * This ensures that all arithmetic maintains the 16-bit non-zero unsigned integer constraint,
- * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
- *
- * @example
- * ```typescript
- * const a = asNonZeroUint16(60000);
- * const b = asNonZeroUint16(10000);
- *
- * // Arithmetic operations with automatic clamping and non-zero constraint
- * const sum = NonZeroUint16.add(a, b);       // NonZeroUint16 (65535 - clamped to MAX_VALUE)
- * const diff = NonZeroUint16.sub(a, b);      // NonZeroUint16 (50000)
- * const reverseDiff = NonZeroUint16.sub(b, a); // NonZeroUint16 (1 - clamped to MIN_VALUE)
- * const product = NonZeroUint16.mul(a, b);   // NonZeroUint16 (65535 - clamped due to overflow)
- *
- * // Range operations (maintaining non-zero constraint)
- * const clamped = NonZeroUint16.clamp(-100);     // NonZeroUint16 (1)
- * const minimum = NonZeroUint16.min(a, b);       // NonZeroUint16 (10000)
- * const maximum = NonZeroUint16.max(a, b);       // NonZeroUint16 (60000)
+ * Namespace providing type-safe arithmetic operations for 16-bit non-zero
+ * unsigned integers.
  *
- * // Utility operations
- * const random = NonZeroUint16.random();         // NonZeroUint16 (random value in [1, 65535])
- * const power = NonZeroUint16.pow(asNonZeroUint16(2), asNonZeroUint16(10)); // NonZeroUint16 (1024)
- * ```
+ * All operations automatically clamp results to the valid NonZeroUint16 range
+ * [1, 65535]. This ensures that all arithmetic maintains the 16-bit non-zero
+ * unsigned integer constraint, with results below 1 clamped to MIN_VALUE and
+ * overflow results clamped to MAX_VALUE.
  */
 export const NonZeroUint16 = {
   /**
    * Type guard to check if a value is a NonZeroUint16.
+   *
    * @param value The value to check.
-   * @returns `true` if the value is a 16-bit non-zero unsigned integer, `false` otherwise.
+   * @returns `true` if the value is a 16-bit non-zero unsigned integer, `false`
+   *   otherwise.
    */
   is,
 
   /**
    * The minimum value for a 16-bit non-zero unsigned integer.
+   *
    * @readonly
    */
   MIN_VALUE,
 
   /**
    * The maximum value for a 16-bit non-zero unsigned integer.
+   *
    * @readonly
    */
   MAX_VALUE,
 
   /**
    * Returns the smaller of two NonZeroUint16 values.
+   *
    * @param a The first NonZeroUint16.
    * @param b The second NonZeroUint16.
    * @returns The minimum value as a NonZeroUint16.
@@ -112,6 +93,7 @@ export const NonZeroUint16 = {
 
   /**
    * Returns the larger of two NonZeroUint16 values.
+   *
    * @param a The first NonZeroUint16.
    * @param b The second NonZeroUint16.
    * @returns The maximum value as a NonZeroUint16.
@@ -120,6 +102,7 @@ export const NonZeroUint16 = {
 
   /**
    * Clamps a number to the NonZeroUint16 range.
+   *
    * @param value The number to clamp.
    * @returns The value clamped to [1, 65535] as a NonZeroUint16.
    */
@@ -127,12 +110,14 @@ export const NonZeroUint16 = {
 
   /**
    * Generates a random NonZeroUint16 value within the valid range.
+   *
    * @returns A random NonZeroUint16 between 1 and 65535.
    */
   random,
 
   /**
    * Raises a NonZeroUint16 to the power of another NonZeroUint16.
+   *
    * @param a The base NonZeroUint16.
    * @param b The exponent NonZeroUint16.
    * @returns `a ** b` clamped to [1, 65535] as a NonZeroUint16.
@@ -141,6 +126,7 @@ export const NonZeroUint16 = {
 
   /**
    * Adds two NonZeroUint16 values.
+   *
    * @param a The first NonZeroUint16.
    * @param b The second NonZeroUint16.
    * @returns `a + b` clamped to [1, 65535] as a NonZeroUint16.
@@ -149,6 +135,7 @@ export const NonZeroUint16 = {
 
   /**
    * Subtracts one NonZeroUint16 from another.
+   *
    * @param a The minuend NonZeroUint16.
    * @param b The subtrahend NonZeroUint16.
    * @returns `a - b` clamped to [1, 65535] as a NonZeroUint16 (minimum 1).
@@ -157,6 +144,7 @@ export const NonZeroUint16 = {
 
   /**
    * Multiplies two NonZeroUint16 values.
+   *
    * @param a The first NonZeroUint16.
    * @param b The second NonZeroUint16.
    * @returns `a * b` clamped to [1, 65535] as a NonZeroUint16.
@@ -165,6 +153,7 @@ export const NonZeroUint16 = {
 
   /**
    * Divides one NonZeroUint16 by another using floor division.
+   *
    * @param a The dividend NonZeroUint16.
    * @param b The divisor NonZeroUint16.
    * @returns `⌊a / b⌋` clamped to [1, 65535] as a NonZeroUint16.

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

@@ -11,8 +11,8 @@ describe('NonZeroUint16', () => {
     test('accepts valid non-zero uint16 values', () => {
       expect(() => asNonZeroUint16(1)).not.toThrow();
       expect(() => asNonZeroUint16(1000)).not.toThrow();
-      expect(() => asNonZeroUint16(65535)).not.toThrow(); // 2^16 - 1
-      expect(() => asNonZeroUint16(32768)).not.toThrow(); // 2^15
+      expect(() => asNonZeroUint16(65_535)).not.toThrow(); // 2^16 - 1
+      expect(() => asNonZeroUint16(32_768)).not.toThrow(); // 2^15
     });
 
     test('rejects zero', () => {
@@ -20,8 +20,8 @@ describe('NonZeroUint16', () => {
     });
 
     test('rejects values outside uint16 range', () => {
-      expect(() => asNonZeroUint16(65536)).toThrow(TypeError); // 2^16
-      expect(() => asNonZeroUint16(100000)).toThrow(TypeError);
+      expect(() => asNonZeroUint16(65_536)).toThrow(TypeError); // 2^16
+      expect(() => asNonZeroUint16(100_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
@@ -44,7 +44,7 @@ describe('NonZeroUint16', () => {
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroUint16(5)).toBe(5);
       expect(asNonZeroUint16(1)).toBe(1);
-      expect(asNonZeroUint16(65535)).toBe(65535);
+      expect(asNonZeroUint16(65_535)).toBe(65_535);
     });
 
     test.each([
@@ -55,7 +55,7 @@ describe('NonZeroUint16', () => {
       { name: '-3.4', value: -3.4 },
       { name: '0', value: 0 },
       { name: '-1', value: -1 },
-      { name: '65536', value: 65536 },
+      { name: '65536', value: 65_536 },
     ] as const)(
       `asNonZeroUint16($name) should throw a TypeError`,
       ({ value }) => {
@@ -72,8 +72,8 @@ describe('NonZeroUint16', () => {
     test('correctly identifies non-zero uint16 values', () => {
       expect(isNonZeroUint16(1)).toBe(true);
       expect(isNonZeroUint16(1000)).toBe(true);
-      expect(isNonZeroUint16(65535)).toBe(true);
-      expect(isNonZeroUint16(32768)).toBe(true);
+      expect(isNonZeroUint16(65_535)).toBe(true);
+      expect(isNonZeroUint16(32_768)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
@@ -81,8 +81,8 @@ describe('NonZeroUint16', () => {
     });
 
     test('correctly identifies values outside uint16 range', () => {
-      expect(isNonZeroUint16(65536)).toBe(false);
-      expect(isNonZeroUint16(100000)).toBe(false);
+      expect(isNonZeroUint16(65_536)).toBe(false);
+      expect(isNonZeroUint16(100_000)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
@@ -110,7 +110,7 @@ describe('NonZeroUint16', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroUint16.MIN_VALUE).toBe(1);
-      expect(NonZeroUint16.MAX_VALUE).toBe(65535);
+      expect(NonZeroUint16.MAX_VALUE).toBe(65_535);
     });
   });
 
@@ -125,10 +125,10 @@ describe('NonZeroUint16', () => {
 
     test('add (with clamping to non-zero uint16 range)', () => {
       const result = NonZeroUint16.add(
-        asNonZeroUint16(65000),
+        asNonZeroUint16(65_000),
         asNonZeroUint16(1000),
       );
-      expect(result).toBe(65535); // clamped to max
+      expect(result).toBe(65_535); // clamped to max
       expect(NonZeroUint16.add(a, b)).toBe(150);
     });
 
@@ -142,7 +142,7 @@ describe('NonZeroUint16', () => {
         asNonZeroUint16(1000),
         asNonZeroUint16(100),
       );
-      expect(result).toBe(65535); // clamped to max
+      expect(result).toBe(65_535); // clamped to max
       expect(NonZeroUint16.mul(asNonZeroUint16(10), asNonZeroUint16(5))).toBe(
         50,
       );
@@ -161,7 +161,7 @@ describe('NonZeroUint16', () => {
         asNonZeroUint16(256),
         asNonZeroUint16(3),
       );
-      expect(result).toBe(65535); // clamped to max
+      expect(result).toBe(65_535); // clamped to max
       expect(NonZeroUint16.pow(asNonZeroUint16(2), asNonZeroUint16(3))).toBe(8);
     });
   });
@@ -185,7 +185,7 @@ describe('NonZeroUint16', () => {
       for (const _ of range(10)) {
         const result = NonZeroUint16.random(1, 30);
         expect(result).toBeGreaterThanOrEqual(1);
-        expect(result).toBeLessThanOrEqual(65535);
+        expect(result).toBeLessThanOrEqual(65_535);
       }
     });
   });

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

@@ -6,19 +6,19 @@ type ElementType = NonZeroUint32;
 const typeNameInMessage = 'a non-zero integer in [1, 2^32)';
 
 const {
-  MIN_VALUE,
   MAX_VALUE,
-  min: min_,
-  max: max_,
-  pow,
+  MIN_VALUE,
   add,
-  sub,
-  mul,
-  div,
-  randomNonZero: random,
-  is,
   castType,
   clamp,
+  div,
+  is,
+  max: max_,
+  min: min_,
+  mul,
+  pow,
+  randomNonZero: random,
+  sub,
 } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
   ElementType,
   1,
@@ -32,7 +32,9 @@ const {
 } as const);
 
 /**
- * Checks if a number is a NonZeroUint32 (32-bit non-zero unsigned integer in the range [1, 2^32)).
+ * Checks if a number is a NonZeroUint32 (32-bit non-zero unsigned integer in
+ * the range [1, 2^32)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroUint32, `false` otherwise.
  */
@@ -40,70 +42,49 @@ export const isNonZeroUint32 = is;
 
 /**
  * Casts a number to a NonZeroUint32 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroUint32 type.
  * @throws {TypeError} If the value is not a non-zero integer in [1, 2^32).
- * @example
- * ```typescript
- * const x = asNonZeroUint32(1000); // NonZeroUint32
- * const y = asNonZeroUint32(4294967295); // NonZeroUint32
- * // asNonZeroUint32(0); // throws TypeError
- * // asNonZeroUint32(-1); // throws TypeError
- * // asNonZeroUint32(4294967296); // throws TypeError
- * ```
  */
 export const asNonZeroUint32 = castType;
 
 /**
- * Namespace providing type-safe arithmetic operations for 32-bit non-zero unsigned integers.
- *
- * All operations automatically clamp results to the valid NonZeroUint32 range [1, 4294967295].
- * This ensures that all arithmetic maintains the 32-bit non-zero unsigned integer constraint,
- * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
- *
- * @example
- * ```typescript
- * const a = asNonZeroUint32(4000000000);
- * const b = asNonZeroUint32(1000000000);
- *
- * // Arithmetic operations with automatic clamping and non-zero constraint
- * const sum = NonZeroUint32.add(a, b);       // NonZeroUint32 (4294967295 - clamped to MAX_VALUE)
- * const diff = NonZeroUint32.sub(a, b);      // NonZeroUint32 (3000000000)
- * const reverseDiff = NonZeroUint32.sub(b, a); // NonZeroUint32 (1 - clamped to MIN_VALUE)
- * const product = NonZeroUint32.mul(a, b);   // NonZeroUint32 (4294967295 - clamped due to overflow)
- *
- * // Range operations (maintaining non-zero constraint)
- * const clamped = NonZeroUint32.clamp(-100);     // NonZeroUint32 (1)
- * const minimum = NonZeroUint32.min(a, b);       // NonZeroUint32 (1000000000)
- * const maximum = NonZeroUint32.max(a, b);       // NonZeroUint32 (4000000000)
+ * Namespace providing type-safe arithmetic operations for 32-bit non-zero
+ * unsigned integers.
  *
- * // Utility operations
- * const random = NonZeroUint32.random();         // NonZeroUint32 (random value in [1, 4294967295])
- * const power = NonZeroUint32.pow(asNonZeroUint32(2), asNonZeroUint32(20)); // NonZeroUint32 (1048576)
- * ```
+ * All operations automatically clamp results to the valid NonZeroUint32 range
+ * [1, 4294967295]. This ensures that all arithmetic maintains the 32-bit
+ * non-zero unsigned integer constraint, with results below 1 clamped to
+ * MIN_VALUE and overflow results clamped to MAX_VALUE.
  */
 export const NonZeroUint32 = {
   /**
    * Type guard to check if a value is a NonZeroUint32.
+   *
    * @param value The value to check.
-   * @returns `true` if the value is a 32-bit non-zero unsigned integer, `false` otherwise.
+   * @returns `true` if the value is a 32-bit non-zero unsigned integer, `false`
+   *   otherwise.
    */
   is,
 
   /**
    * The minimum value for a 32-bit non-zero unsigned integer.
+   *
    * @readonly
    */
   MIN_VALUE,
 
   /**
    * The maximum value for a 32-bit non-zero unsigned integer.
+   *
    * @readonly
    */
   MAX_VALUE,
 
   /**
    * Returns the smaller of two NonZeroUint32 values.
+   *
    * @param a The first NonZeroUint32.
    * @param b The second NonZeroUint32.
    * @returns The minimum value as a NonZeroUint32.
@@ -112,6 +93,7 @@ export const NonZeroUint32 = {
 
   /**
    * Returns the larger of two NonZeroUint32 values.
+   *
    * @param a The first NonZeroUint32.
    * @param b The second NonZeroUint32.
    * @returns The maximum value as a NonZeroUint32.
@@ -120,6 +102,7 @@ export const NonZeroUint32 = {
 
   /**
    * Clamps a number to the NonZeroUint32 range.
+   *
    * @param value The number to clamp.
    * @returns The value clamped to [1, 4294967295] as a NonZeroUint32.
    */
@@ -127,12 +110,14 @@ export const NonZeroUint32 = {
 
   /**
    * Generates a random NonZeroUint32 value within the valid range.
+   *
    * @returns A random NonZeroUint32 between 1 and 4294967295.
    */
   random,
 
   /**
    * Raises a NonZeroUint32 to the power of another NonZeroUint32.
+   *
    * @param a The base NonZeroUint32.
    * @param b The exponent NonZeroUint32.
    * @returns `a ** b` clamped to [1, 4294967295] as a NonZeroUint32.
@@ -141,6 +126,7 @@ export const NonZeroUint32 = {
 
   /**
    * Adds two NonZeroUint32 values.
+   *
    * @param a The first NonZeroUint32.
    * @param b The second NonZeroUint32.
    * @returns `a + b` clamped to [1, 4294967295] as a NonZeroUint32.
@@ -149,6 +135,7 @@ export const NonZeroUint32 = {
 
   /**
    * Subtracts one NonZeroUint32 from another.
+   *
    * @param a The minuend NonZeroUint32.
    * @param b The subtrahend NonZeroUint32.
    * @returns `a - b` clamped to [1, 4294967295] as a NonZeroUint32 (minimum 1).
@@ -157,6 +144,7 @@ export const NonZeroUint32 = {
 
   /**
    * Multiplies two NonZeroUint32 values.
+   *
    * @param a The first NonZeroUint32.
    * @param b The second NonZeroUint32.
    * @returns `a * b` clamped to [1, 4294967295] as a NonZeroUint32.
@@ -165,6 +153,7 @@ export const NonZeroUint32 = {
 
   /**
    * Divides one NonZeroUint32 by another using floor division.
+   *
    * @param a The dividend NonZeroUint32.
    * @param b The divisor NonZeroUint32.
    * @returns `⌊a / b⌋` clamped to [1, 4294967295] as a NonZeroUint32.

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

@@ -11,8 +11,8 @@ describe('NonZeroUint32', () => {
     test('accepts valid non-zero uint32 values', () => {
       expect(() => asNonZeroUint32(1)).not.toThrow();
       expect(() => asNonZeroUint32(1000)).not.toThrow();
-      expect(() => asNonZeroUint32(4294967295)).not.toThrow(); // 2^32 - 1
-      expect(() => asNonZeroUint32(2147483648)).not.toThrow(); // 2^31
+      expect(() => asNonZeroUint32(4_294_967_295)).not.toThrow(); // 2^32 - 1
+      expect(() => asNonZeroUint32(2_147_483_648)).not.toThrow(); // 2^31
     });
 
     test('rejects zero', () => {
@@ -20,8 +20,8 @@ describe('NonZeroUint32', () => {
     });
 
     test('rejects values outside uint32 range', () => {
-      expect(() => asNonZeroUint32(4294967296)).toThrow(TypeError); // 2^32
-      expect(() => asNonZeroUint32(10000000000)).toThrow(TypeError);
+      expect(() => asNonZeroUint32(4_294_967_296)).toThrow(TypeError); // 2^32
+      expect(() => asNonZeroUint32(10_000_000_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
@@ -44,7 +44,7 @@ describe('NonZeroUint32', () => {
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroUint32(5)).toBe(5);
       expect(asNonZeroUint32(1)).toBe(1);
-      expect(asNonZeroUint32(4294967295)).toBe(4294967295);
+      expect(asNonZeroUint32(4_294_967_295)).toBe(4_294_967_295);
     });
 
     test.each([
@@ -55,7 +55,7 @@ describe('NonZeroUint32', () => {
       { name: '-3.4', value: -3.4 },
       { name: '0', value: 0 },
       { name: '-1', value: -1 },
-      { name: '4294967296', value: 4294967296 },
+      { name: '4294967296', value: 4_294_967_296 },
     ] as const)(
       `asNonZeroUint32($name) should throw a TypeError`,
       ({ value }) => {
@@ -72,8 +72,8 @@ describe('NonZeroUint32', () => {
     test('correctly identifies non-zero uint32 values', () => {
       expect(isNonZeroUint32(1)).toBe(true);
       expect(isNonZeroUint32(1000)).toBe(true);
-      expect(isNonZeroUint32(4294967295)).toBe(true);
-      expect(isNonZeroUint32(2147483648)).toBe(true);
+      expect(isNonZeroUint32(4_294_967_295)).toBe(true);
+      expect(isNonZeroUint32(2_147_483_648)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
@@ -81,8 +81,8 @@ describe('NonZeroUint32', () => {
     });
 
     test('correctly identifies values outside uint32 range', () => {
-      expect(isNonZeroUint32(4294967296)).toBe(false);
-      expect(isNonZeroUint32(10000000000)).toBe(false);
+      expect(isNonZeroUint32(4_294_967_296)).toBe(false);
+      expect(isNonZeroUint32(10_000_000_000)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
@@ -110,58 +110,58 @@ describe('NonZeroUint32', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroUint32.MIN_VALUE).toBe(1);
-      expect(NonZeroUint32.MAX_VALUE).toBe(4294967295);
+      expect(NonZeroUint32.MAX_VALUE).toBe(4_294_967_295);
     });
   });
 
   describe('mathematical operations', () => {
-    const a = asNonZeroUint32(1000000);
-    const b = asNonZeroUint32(500000);
+    const a = asNonZeroUint32(1_000_000);
+    const b = asNonZeroUint32(500_000);
 
     test('min and max', () => {
-      expect(NonZeroUint32.min(a, b)).toBe(500000);
-      expect(NonZeroUint32.max(a, b)).toBe(1000000);
+      expect(NonZeroUint32.min(a, b)).toBe(500_000);
+      expect(NonZeroUint32.max(a, b)).toBe(1_000_000);
     });
 
     test('add (with clamping to non-zero uint32 range)', () => {
       const result = NonZeroUint32.add(
-        asNonZeroUint32(4294967000),
+        asNonZeroUint32(4_294_967_000),
         asNonZeroUint32(1000),
       );
-      expect(result).toBe(4294967295); // clamped to max
-      expect(NonZeroUint32.add(a, b)).toBe(1500000);
+      expect(result).toBe(4_294_967_295); // clamped to max
+      expect(NonZeroUint32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (never goes below 1)', () => {
-      expect(NonZeroUint32.sub(a, b)).toBe(500000);
+      expect(NonZeroUint32.sub(a, b)).toBe(500_000);
       expect(NonZeroUint32.sub(b, a)).toBe(1); // clamped to 1
     });
 
     test('mul (with clamping to non-zero uint32 range)', () => {
       const result = NonZeroUint32.mul(
-        asNonZeroUint32(100000),
-        asNonZeroUint32(100000),
+        asNonZeroUint32(100_000),
+        asNonZeroUint32(100_000),
       );
-      expect(result).toBe(4294967295); // clamped to max
+      expect(result).toBe(4_294_967_295); // clamped to max
       expect(NonZeroUint32.mul(asNonZeroUint32(1000), asNonZeroUint32(5))).toBe(
         5000,
       );
     });
 
     test('div (floor division, never goes below 1)', () => {
-      expect(NonZeroUint32.div(a, asNonZeroUint32(500000))).toBe(2);
+      expect(NonZeroUint32.div(a, asNonZeroUint32(500_000))).toBe(2);
       expect(NonZeroUint32.div(asNonZeroUint32(7), asNonZeroUint32(3))).toBe(2);
       expect(
-        NonZeroUint32.div(asNonZeroUint32(500000), asNonZeroUint32(1000000)),
+        NonZeroUint32.div(asNonZeroUint32(500_000), asNonZeroUint32(1_000_000)),
       ).toBe(1); // floor(500000/1000000) = 0, clamped to 1
     });
 
     test('pow (with clamping to non-zero uint32 range)', () => {
       const result = NonZeroUint32.pow(
-        asNonZeroUint32(10000),
+        asNonZeroUint32(10_000),
         asNonZeroUint32(3),
       );
-      expect(result).toBe(4294967295); // clamped to max
+      expect(result).toBe(4_294_967_295); // clamped to max
       expect(NonZeroUint32.pow(asNonZeroUint32(2), asNonZeroUint32(3))).toBe(8);
     });
   });
@@ -185,7 +185,7 @@ describe('NonZeroUint32', () => {
       for (const _ of range(10)) {
         const result = NonZeroUint32.random(1, 30);
         expect(result).toBeGreaterThanOrEqual(1);
-        expect(result).toBeLessThanOrEqual(4294967295);
+        expect(result).toBeLessThanOrEqual(4_294_967_295);
       }
     });
   });
@@ -194,7 +194,7 @@ describe('NonZeroUint32', () => {
     test('type relationships', () => {
       expectType<NonZeroUint32, number>('<=');
 
-      expectTypeOf(asNonZeroUint32(1000000)).toExtend<NonZeroUint32>();
+      expectTypeOf(asNonZeroUint32(1_000_000)).toExtend<NonZeroUint32>();
     });
   });
 });