ts-data-forge 3.3.0 → 4.0.0

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

@@ -6,19 +6,19 @@ type ElementType = PositiveInt16;
 const typeNameInMessage = 'a positive integer in [1, 2^15)';
 
 const {
-  MIN_VALUE,
   MAX_VALUE,
-  min: min_,
-  max: max_,
-  pow,
+  MIN_VALUE,
   add,
-  sub,
-  mul,
-  div,
-  random,
-  is,
   castType,
   clamp,
+  div,
+  is,
+  max: max_,
+  min: min_,
+  mul,
+  pow,
+  random,
+  sub,
 } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
   ElementType,
   1,
@@ -31,7 +31,9 @@ const {
 } as const);
 
 /**
- * Checks if a number is a PositiveInt16 (16-bit positive signed integer in the range [1, 2^15)).
+ * Checks if a number is a PositiveInt16 (16-bit positive signed integer in the
+ * range [1, 2^15)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a PositiveInt16, `false` otherwise.
  */
@@ -39,70 +41,49 @@ export const isPositiveInt16 = is;
 
 /**
  * Casts a number to a PositiveInt16 type.
+ *
  * @param value The value to cast.
  * @returns The value as a PositiveInt16 type.
  * @throws {TypeError} If the value is not a positive integer in [1, 2^15).
- * @example
- * ```typescript
- * const x = asPositiveInt16(1000); // PositiveInt16
- * const y = asPositiveInt16(32767); // PositiveInt16
- * // asPositiveInt16(0); // throws TypeError
- * // asPositiveInt16(-1); // throws TypeError
- * // asPositiveInt16(32768); // throws TypeError
- * ```
  */
 export const asPositiveInt16 = castType;
 
 /**
- * Namespace providing type-safe arithmetic operations for 16-bit positive integers.
- *
- * All operations automatically clamp results to the valid PositiveInt16 range [1, 32767].
- * This ensures that all arithmetic maintains the 16-bit positive integer constraint,
- * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
- *
- * @example
- * ```typescript
- * const a = asPositiveInt16(30000);
- * const b = asPositiveInt16(5000);
- *
- * // Arithmetic operations with automatic clamping
- * const sum = PositiveInt16.add(a, b);       // PositiveInt16 (32767 - clamped to MAX_VALUE)
- * const diff = PositiveInt16.sub(a, b);      // PositiveInt16 (25000)
- * const reverseDiff = PositiveInt16.sub(b, a); // PositiveInt16 (1 - clamped to MIN_VALUE)
- * const product = PositiveInt16.mul(a, b);   // PositiveInt16 (32767 - clamped due to overflow)
- *
- * // Range operations
- * const clamped = PositiveInt16.clamp(0);        // PositiveInt16 (1)
- * const minimum = PositiveInt16.min(a, b);       // PositiveInt16 (5000)
- * const maximum = PositiveInt16.max(a, b);       // PositiveInt16 (30000)
+ * Namespace providing type-safe arithmetic operations for 16-bit positive
+ * integers.
  *
- * // Utility operations
- * const random = PositiveInt16.random();         // PositiveInt16 (random value in [1, 32767])
- * const power = PositiveInt16.pow(asPositiveInt16(2), asPositiveInt16(10)); // PositiveInt16 (1024)
- * ```
+ * All operations automatically clamp results to the valid PositiveInt16 range
+ * [1, 32767]. This ensures that all arithmetic maintains the 16-bit positive
+ * integer constraint, with results below 1 clamped to MIN_VALUE and overflow
+ * results clamped to MAX_VALUE.
  */
 export const PositiveInt16 = {
   /**
    * Type guard to check if a value is a PositiveInt16.
+   *
    * @param value The value to check.
-   * @returns `true` if the value is a 16-bit positive integer, `false` otherwise.
+   * @returns `true` if the value is a 16-bit positive integer, `false`
+   *   otherwise.
    */
   is,
 
   /**
    * The minimum value for a 16-bit positive integer.
+   *
    * @readonly
    */
   MIN_VALUE,
 
   /**
    * The maximum value for a 16-bit positive integer.
+   *
    * @readonly
    */
   MAX_VALUE,
 
   /**
    * Returns the smaller of two PositiveInt16 values.
+   *
    * @param a The first PositiveInt16.
    * @param b The second PositiveInt16.
    * @returns The minimum value as a PositiveInt16.
@@ -111,6 +92,7 @@ export const PositiveInt16 = {
 
   /**
    * Returns the larger of two PositiveInt16 values.
+   *
    * @param a The first PositiveInt16.
    * @param b The second PositiveInt16.
    * @returns The maximum value as a PositiveInt16.
@@ -119,6 +101,7 @@ export const PositiveInt16 = {
 
   /**
    * Clamps a number to the PositiveInt16 range.
+   *
    * @param value The number to clamp.
    * @returns The value clamped to [1, 32767] as a PositiveInt16.
    */
@@ -126,12 +109,14 @@ export const PositiveInt16 = {
 
   /**
    * Generates a random PositiveInt16 value within the valid range.
+   *
    * @returns A random PositiveInt16 between 1 and 32767.
    */
   random,
 
   /**
    * Raises a PositiveInt16 to the power of another PositiveInt16.
+   *
    * @param a The base PositiveInt16.
    * @param b The exponent PositiveInt16.
    * @returns `a ** b` clamped to [1, 32767] as a PositiveInt16.
@@ -140,6 +125,7 @@ export const PositiveInt16 = {
 
   /**
    * Adds two PositiveInt16 values.
+   *
    * @param a The first PositiveInt16.
    * @param b The second PositiveInt16.
    * @returns `a + b` clamped to [1, 32767] as a PositiveInt16.
@@ -148,6 +134,7 @@ export const PositiveInt16 = {
 
   /**
    * Subtracts one PositiveInt16 from another.
+   *
    * @param a The minuend PositiveInt16.
    * @param b The subtrahend PositiveInt16.
    * @returns `a - b` clamped to [1, 32767] as a PositiveInt16 (minimum 1).
@@ -156,6 +143,7 @@ export const PositiveInt16 = {
 
   /**
    * Multiplies two PositiveInt16 values.
+   *
    * @param a The first PositiveInt16.
    * @param b The second PositiveInt16.
    * @returns `a * b` clamped to [1, 32767] as a PositiveInt16.
@@ -164,6 +152,7 @@ export const PositiveInt16 = {
 
   /**
    * Divides one PositiveInt16 by another using floor division.
+   *
    * @param a The dividend PositiveInt16.
    * @param b The divisor PositiveInt16.
    * @returns `⌊a / b⌋` clamped to [1, 32767] as a PositiveInt16.

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

@@ -11,7 +11,7 @@ describe('PositiveInt16', () => {
     test('accepts valid positive int16 values', () => {
       expect(() => asPositiveInt16(1)).not.toThrow();
       expect(() => asPositiveInt16(1000)).not.toThrow();
-      expect(() => asPositiveInt16(32767)).not.toThrow(); // 2^15 - 1
+      expect(() => asPositiveInt16(32_767)).not.toThrow(); // 2^15 - 1
     });
 
     test('rejects zero', () => {
@@ -19,8 +19,8 @@ describe('PositiveInt16', () => {
     });
 
     test('rejects values outside int16 range', () => {
-      expect(() => asPositiveInt16(32768)).toThrow(TypeError); // 2^15
-      expect(() => asPositiveInt16(65536)).toThrow(TypeError);
+      expect(() => asPositiveInt16(32_768)).toThrow(TypeError); // 2^15
+      expect(() => asPositiveInt16(65_536)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
@@ -43,7 +43,7 @@ describe('PositiveInt16', () => {
     test('returns the same value for valid inputs', () => {
       expect(asPositiveInt16(5)).toBe(5);
       expect(asPositiveInt16(1)).toBe(1);
-      expect(asPositiveInt16(32767)).toBe(32767);
+      expect(asPositiveInt16(32_767)).toBe(32_767);
     });
 
     test.each([
@@ -54,7 +54,7 @@ describe('PositiveInt16', () => {
       { name: '-3.4', value: -3.4 },
       { name: '0', value: 0 },
       { name: '-1', value: -1 },
-      { name: '32768', value: 32768 },
+      { name: '32768', value: 32_768 },
     ] as const)(
       `asPositiveInt16($name) should throw a TypeError`,
       ({ value }) => {
@@ -71,7 +71,7 @@ describe('PositiveInt16', () => {
     test('correctly identifies positive int16 values', () => {
       expect(isPositiveInt16(1)).toBe(true);
       expect(isPositiveInt16(1000)).toBe(true);
-      expect(isPositiveInt16(32767)).toBe(true);
+      expect(isPositiveInt16(32_767)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
@@ -79,8 +79,8 @@ describe('PositiveInt16', () => {
     });
 
     test('correctly identifies values outside int16 range', () => {
-      expect(isPositiveInt16(32768)).toBe(false);
-      expect(isPositiveInt16(65536)).toBe(false);
+      expect(isPositiveInt16(32_768)).toBe(false);
+      expect(isPositiveInt16(65_536)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
@@ -108,7 +108,7 @@ describe('PositiveInt16', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(PositiveInt16.MIN_VALUE).toBe(1);
-      expect(PositiveInt16.MAX_VALUE).toBe(32767);
+      expect(PositiveInt16.MAX_VALUE).toBe(32_767);
     });
   });
 
@@ -123,10 +123,10 @@ describe('PositiveInt16', () => {
 
     test('add (with clamping to positive int16 range)', () => {
       const result = PositiveInt16.add(
-        asPositiveInt16(32000),
+        asPositiveInt16(32_000),
         asPositiveInt16(1000),
       );
-      expect(result).toBe(32767); // clamped to max
+      expect(result).toBe(32_767); // clamped to max
       expect(PositiveInt16.add(a, b)).toBe(150);
     });
 
@@ -140,7 +140,7 @@ describe('PositiveInt16', () => {
         asPositiveInt16(1000),
         asPositiveInt16(100),
       );
-      expect(result).toBe(32767); // clamped to max
+      expect(result).toBe(32_767); // clamped to max
       expect(PositiveInt16.mul(asPositiveInt16(10), asPositiveInt16(5))).toBe(
         50,
       );
@@ -159,7 +159,7 @@ describe('PositiveInt16', () => {
         asPositiveInt16(200),
         asPositiveInt16(3),
       );
-      expect(result).toBe(32767); // clamped to max
+      expect(result).toBe(32_767); // clamped to max
       expect(PositiveInt16.pow(asPositiveInt16(2), asPositiveInt16(3))).toBe(8);
     });
   });
@@ -183,7 +183,7 @@ describe('PositiveInt16', () => {
       for (const _ of range(10)) {
         const result = PositiveInt16.random(1, 30);
         expect(result).toBeGreaterThanOrEqual(1);
-        expect(result).toBeLessThanOrEqual(32767);
+        expect(result).toBeLessThanOrEqual(32_767);
       }
     });
   });

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

@@ -6,19 +6,19 @@ type ElementType = PositiveInt32;
 const typeNameInMessage = 'a positive integer in [1, 2^31)';
 
 const {
-  MIN_VALUE,
   MAX_VALUE,
-  min: min_,
-  max: max_,
-  pow,
+  MIN_VALUE,
   add,
-  sub,
-  mul,
-  div,
-  random,
-  is,
   castType,
   clamp,
+  div,
+  is,
+  max: max_,
+  min: min_,
+  mul,
+  pow,
+  random,
+  sub,
 } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
   ElementType,
   1,
@@ -31,7 +31,9 @@ const {
 } as const);
 
 /**
- * Checks if a number is a PositiveInt32 (32-bit positive signed integer in the range [1, 2^31)).
+ * Checks if a number is a PositiveInt32 (32-bit positive signed integer in the
+ * range [1, 2^31)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a PositiveInt32, `false` otherwise.
  */
@@ -39,70 +41,49 @@ export const isPositiveInt32 = is;
 
 /**
  * Casts a number to a PositiveInt32 type.
+ *
  * @param value The value to cast.
  * @returns The value as a PositiveInt32 type.
  * @throws {TypeError} If the value is not a positive integer in [1, 2^31).
- * @example
- * ```typescript
- * const x = asPositiveInt32(1000); // PositiveInt32
- * const y = asPositiveInt32(2147483647); // PositiveInt32
- * // asPositiveInt32(0); // throws TypeError
- * // asPositiveInt32(-1); // throws TypeError
- * // asPositiveInt32(2147483648); // throws TypeError
- * ```
  */
 export const asPositiveInt32 = castType;
 
 /**
- * Namespace providing type-safe arithmetic operations for 32-bit positive integers.
- *
- * All operations automatically clamp results to the valid PositiveInt32 range [1, 2147483647].
- * This ensures that all arithmetic maintains the 32-bit positive integer constraint,
- * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
- *
- * @example
- * ```typescript
- * const a = asPositiveInt32(2000000000);
- * const b = asPositiveInt32(500000000);
- *
- * // Arithmetic operations with automatic clamping and positive constraint
- * const sum = PositiveInt32.add(a, b);       // PositiveInt32 (2147483647 - clamped to MAX_VALUE)
- * const diff = PositiveInt32.sub(a, b);      // PositiveInt32 (1500000000)
- * const reverseDiff = PositiveInt32.sub(b, a); // PositiveInt32 (1 - clamped to MIN_VALUE)
- * const product = PositiveInt32.mul(a, b);   // PositiveInt32 (2147483647 - clamped due to overflow)
- *
- * // Range operations (maintaining positive constraint)
- * const clamped = PositiveInt32.clamp(-1000);     // PositiveInt32 (1)
- * const minimum = PositiveInt32.min(a, b);        // PositiveInt32 (500000000)
- * const maximum = PositiveInt32.max(a, b);        // PositiveInt32 (2000000000)
+ * Namespace providing type-safe arithmetic operations for 32-bit positive
+ * integers.
  *
- * // Utility operations
- * const random = PositiveInt32.random();          // PositiveInt32 (random value in [1, 2147483647])
- * const power = PositiveInt32.pow(asPositiveInt32(2), asPositiveInt32(20)); // PositiveInt32 (1048576)
- * ```
+ * All operations automatically clamp results to the valid PositiveInt32 range
+ * [1, 2147483647]. This ensures that all arithmetic maintains the 32-bit
+ * positive integer constraint, with results below 1 clamped to MIN_VALUE and
+ * overflow results clamped to MAX_VALUE.
  */
 export const PositiveInt32 = {
   /**
    * Type guard to check if a value is a PositiveInt32.
+   *
    * @param value The value to check.
-   * @returns `true` if the value is a 32-bit positive integer, `false` otherwise.
+   * @returns `true` if the value is a 32-bit positive integer, `false`
+   *   otherwise.
    */
   is,
 
   /**
    * The minimum value for a 32-bit positive integer.
+   *
    * @readonly
    */
   MIN_VALUE,
 
   /**
    * The maximum value for a 32-bit positive integer.
+   *
    * @readonly
    */
   MAX_VALUE,
 
   /**
    * Returns the smaller of two PositiveInt32 values.
+   *
    * @param a The first PositiveInt32.
    * @param b The second PositiveInt32.
    * @returns The minimum value as a PositiveInt32.
@@ -111,6 +92,7 @@ export const PositiveInt32 = {
 
   /**
    * Returns the larger of two PositiveInt32 values.
+   *
    * @param a The first PositiveInt32.
    * @param b The second PositiveInt32.
    * @returns The maximum value as a PositiveInt32.
@@ -119,6 +101,7 @@ export const PositiveInt32 = {
 
   /**
    * Clamps a number to the PositiveInt32 range.
+   *
    * @param value The number to clamp.
    * @returns The value clamped to [1, 2147483647] as a PositiveInt32.
    */
@@ -126,12 +109,14 @@ export const PositiveInt32 = {
 
   /**
    * Generates a random PositiveInt32 value within the valid range.
+   *
    * @returns A random PositiveInt32 between 1 and 2147483647.
    */
   random,
 
   /**
    * Raises a PositiveInt32 to the power of another PositiveInt32.
+   *
    * @param a The base PositiveInt32.
    * @param b The exponent PositiveInt32.
    * @returns `a ** b` clamped to [1, 2147483647] as a PositiveInt32.
@@ -140,6 +125,7 @@ export const PositiveInt32 = {
 
   /**
    * Adds two PositiveInt32 values.
+   *
    * @param a The first PositiveInt32.
    * @param b The second PositiveInt32.
    * @returns `a + b` clamped to [1, 2147483647] as a PositiveInt32.
@@ -148,6 +134,7 @@ export const PositiveInt32 = {
 
   /**
    * Subtracts one PositiveInt32 from another.
+   *
    * @param a The minuend PositiveInt32.
    * @param b The subtrahend PositiveInt32.
    * @returns `a - b` clamped to [1, 2147483647] as a PositiveInt32 (minimum 1).
@@ -156,6 +143,7 @@ export const PositiveInt32 = {
 
   /**
    * Multiplies two PositiveInt32 values.
+   *
    * @param a The first PositiveInt32.
    * @param b The second PositiveInt32.
    * @returns `a * b` clamped to [1, 2147483647] as a PositiveInt32.
@@ -164,6 +152,7 @@ export const PositiveInt32 = {
 
   /**
    * Divides one PositiveInt32 by another using floor division.
+   *
    * @param a The dividend PositiveInt32.
    * @param b The divisor PositiveInt32.
    * @returns `⌊a / b⌋` clamped to [1, 2147483647] as a PositiveInt32.

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

@@ -11,7 +11,7 @@ describe('PositiveInt32', () => {
     test('accepts valid positive int32 values', () => {
       expect(() => asPositiveInt32(1)).not.toThrow();
       expect(() => asPositiveInt32(1000)).not.toThrow();
-      expect(() => asPositiveInt32(2147483647)).not.toThrow(); // 2^31 - 1
+      expect(() => asPositiveInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
     });
 
     test('rejects zero', () => {
@@ -19,8 +19,8 @@ describe('PositiveInt32', () => {
     });
 
     test('rejects values outside int32 range', () => {
-      expect(() => asPositiveInt32(2147483648)).toThrow(TypeError); // 2^31
-      expect(() => asPositiveInt32(4294967296)).toThrow(TypeError);
+      expect(() => asPositiveInt32(2_147_483_648)).toThrow(TypeError); // 2^31
+      expect(() => asPositiveInt32(4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
@@ -43,7 +43,7 @@ describe('PositiveInt32', () => {
     test('returns the same value for valid inputs', () => {
       expect(asPositiveInt32(5)).toBe(5);
       expect(asPositiveInt32(1)).toBe(1);
-      expect(asPositiveInt32(2147483647)).toBe(2147483647);
+      expect(asPositiveInt32(2_147_483_647)).toBe(2_147_483_647);
     });
 
     test.each([
@@ -54,7 +54,7 @@ describe('PositiveInt32', () => {
       { name: '-3.4', value: -3.4 },
       { name: '0', value: 0 },
       { name: '-1', value: -1 },
-      { name: '2147483648', value: 2147483648 },
+      { name: '2147483648', value: 2_147_483_648 },
     ] as const)(
       `asPositiveInt32($name) should throw a TypeError`,
       ({ value }) => {
@@ -71,7 +71,7 @@ describe('PositiveInt32', () => {
     test('correctly identifies positive int32 values', () => {
       expect(isPositiveInt32(1)).toBe(true);
       expect(isPositiveInt32(1000)).toBe(true);
-      expect(isPositiveInt32(2147483647)).toBe(true);
+      expect(isPositiveInt32(2_147_483_647)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
@@ -79,8 +79,8 @@ describe('PositiveInt32', () => {
     });
 
     test('correctly identifies values outside int32 range', () => {
-      expect(isPositiveInt32(2147483648)).toBe(false);
-      expect(isPositiveInt32(4294967296)).toBe(false);
+      expect(isPositiveInt32(2_147_483_648)).toBe(false);
+      expect(isPositiveInt32(4_294_967_296)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
@@ -108,58 +108,58 @@ describe('PositiveInt32', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(PositiveInt32.MIN_VALUE).toBe(1);
-      expect(PositiveInt32.MAX_VALUE).toBe(2147483647);
+      expect(PositiveInt32.MAX_VALUE).toBe(2_147_483_647);
     });
   });
 
   describe('mathematical operations', () => {
-    const a = asPositiveInt32(1000000);
-    const b = asPositiveInt32(500000);
+    const a = asPositiveInt32(1_000_000);
+    const b = asPositiveInt32(500_000);
 
     test('min and max', () => {
-      expect(PositiveInt32.min(a, b)).toBe(500000);
-      expect(PositiveInt32.max(a, b)).toBe(1000000);
+      expect(PositiveInt32.min(a, b)).toBe(500_000);
+      expect(PositiveInt32.max(a, b)).toBe(1_000_000);
     });
 
     test('add (with clamping to positive int32 range)', () => {
       const result = PositiveInt32.add(
-        asPositiveInt32(2147483000),
+        asPositiveInt32(2_147_483_000),
         asPositiveInt32(1000),
       );
-      expect(result).toBe(2147483647); // clamped to max
-      expect(PositiveInt32.add(a, b)).toBe(1500000);
+      expect(result).toBe(2_147_483_647); // clamped to max
+      expect(PositiveInt32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (never goes below 1)', () => {
-      expect(PositiveInt32.sub(a, b)).toBe(500000);
+      expect(PositiveInt32.sub(a, b)).toBe(500_000);
       expect(PositiveInt32.sub(b, a)).toBe(1); // clamped to 1
     });
 
     test('mul (with clamping to positive int32 range)', () => {
       const result = PositiveInt32.mul(
-        asPositiveInt32(100000),
-        asPositiveInt32(100000),
+        asPositiveInt32(100_000),
+        asPositiveInt32(100_000),
       );
-      expect(result).toBe(2147483647); // clamped to max
+      expect(result).toBe(2_147_483_647); // clamped to max
       expect(PositiveInt32.mul(asPositiveInt32(1000), asPositiveInt32(5))).toBe(
         5000,
       );
     });
 
     test('div (floor division, never goes below 1)', () => {
-      expect(PositiveInt32.div(a, asPositiveInt32(500000))).toBe(2);
+      expect(PositiveInt32.div(a, asPositiveInt32(500_000))).toBe(2);
       expect(PositiveInt32.div(asPositiveInt32(7), asPositiveInt32(3))).toBe(2);
       expect(
-        PositiveInt32.div(asPositiveInt32(500000), asPositiveInt32(1000000)),
+        PositiveInt32.div(asPositiveInt32(500_000), asPositiveInt32(1_000_000)),
       ).toBe(1); // floor(500000/1000000) = 0, clamped to 1
     });
 
     test('pow (with clamping to positive int32 range)', () => {
       const result = PositiveInt32.pow(
-        asPositiveInt32(10000),
+        asPositiveInt32(10_000),
         asPositiveInt32(3),
       );
-      expect(result).toBe(2147483647); // clamped to max
+      expect(result).toBe(2_147_483_647); // clamped to max
       expect(PositiveInt32.pow(asPositiveInt32(2), asPositiveInt32(3))).toBe(8);
     });
   });
@@ -183,7 +183,7 @@ describe('PositiveInt32', () => {
       for (const _ of range(10)) {
         const result = PositiveInt32.random(1, 30);
         expect(result).toBeGreaterThanOrEqual(1);
-        expect(result).toBeLessThanOrEqual(2147483647);
+        expect(result).toBeLessThanOrEqual(2_147_483_647);
       }
     });
   });
@@ -192,7 +192,7 @@ describe('PositiveInt32', () => {
     test('type relationships', () => {
       expectType<PositiveInt32, number>('<=');
 
-      expectTypeOf(asPositiveInt32(1000000)).toExtend<PositiveInt32>();
+      expectTypeOf(asPositiveInt32(1_000_000)).toExtend<PositiveInt32>();
     });
   });
 });