ts-data-forge 3.3.0 → 4.0.0

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

@@ -7,16 +7,16 @@ const typeNameInMessage = 'a non-zero finite number';
 
 const {
   abs,
-  min: min_,
-  max: max_,
-  pow,
   add,
-  sub,
-  mul,
+  castType,
   div,
-  randomNonZero: random,
   is,
-  castType,
+  max: max_,
+  min: min_,
+  mul,
+  pow,
+  randomNonZero: random,
+  sub,
 } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
   ElementType,
   number,
@@ -33,19 +33,19 @@ const {
 const floor = (
   x: ElementType,
 ): TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType> =>
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   Math.floor(x) as TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
 
 const ceil = (
   x: ElementType,
 ): TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType> =>
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   Math.ceil(x) as TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
 
 const round = (
   x: ElementType,
 ): TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType> =>
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   Math.round(x) as TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
 
 expectType<
@@ -62,6 +62,7 @@ expectType<
 
 /**
  * Checks if a number is a NonZeroFiniteNumber (a finite number that is not 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroFiniteNumber, `false` otherwise.
  */
@@ -69,61 +70,34 @@ export const isNonZeroFiniteNumber = is;
 
 /**
  * Casts a number to a NonZeroFiniteNumber type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroFiniteNumber type.
  * @throws {TypeError} If the value is not a non-zero finite number.
- * @example
- * ```typescript
- * const x = asNonZeroFiniteNumber(5.5); // NonZeroFiniteNumber
- * const y = asNonZeroFiniteNumber(-3.2); // NonZeroFiniteNumber
- * // asNonZeroFiniteNumber(0); // throws TypeError
- * // asNonZeroFiniteNumber(Infinity); // throws TypeError
- * ```
  */
 export const asNonZeroFiniteNumber = castType;
 
 /**
- * Namespace providing type-safe arithmetic operations for non-zero finite numbers.
- *
- * All operations maintain the non-zero constraint while ensuring results remain finite
- * (excluding NaN and Infinity). This type is useful for values that must never be zero,
- * such as denominators, scaling factors, and ratios.
- *
- * @example
- * ```typescript
- * const factor = asNonZeroFiniteNumber(2.5);
- * const multiplier = asNonZeroFiniteNumber(-1.5);
- *
- * // Arithmetic operations that preserve non-zero constraint
- * const result = NonZeroFiniteNumber.add(factor, multiplier);        // NonZeroFiniteNumber (1.0)
- * const difference = NonZeroFiniteNumber.sub(factor, multiplier);    // NonZeroFiniteNumber (4.0)
- * const product = NonZeroFiniteNumber.mul(factor, multiplier);       // NonZeroFiniteNumber (-3.75)
- * const quotient = NonZeroFiniteNumber.div(factor, multiplier);      // NonZeroFiniteNumber (-1.666...)
- *
- * // Utility operations
- * const absolute = NonZeroFiniteNumber.abs(multiplier);              // NonZeroFiniteNumber (1.5)
- * const minimum = NonZeroFiniteNumber.min(factor, multiplier);       // NonZeroFiniteNumber (-1.5)
- * const maximum = NonZeroFiniteNumber.max(factor, multiplier);       // NonZeroFiniteNumber (2.5)
- *
- * // Rounding operations (return NonZeroInt)
- * const rounded = NonZeroFiniteNumber.round(factor);                 // NonZeroInt (3)
- * const floored = NonZeroFiniteNumber.floor(factor);                 // NonZeroInt (2)
- * const ceiled = NonZeroFiniteNumber.ceil(factor);                   // NonZeroInt (3)
+ * Namespace providing type-safe arithmetic operations for non-zero finite
+ * numbers.
  *
- * // Random generation
- * const randomValue = NonZeroFiniteNumber.random();                  // NonZeroFiniteNumber (random non-zero value)
- * ```
+ * All operations maintain the non-zero constraint while ensuring results remain
+ * finite (excluding NaN and Infinity). This type is useful for values that must
+ * never be zero, such as denominators, scaling factors, and ratios.
  */
 export const NonZeroFiniteNumber = {
   /**
    * Type guard to check if a value is a NonZeroFiniteNumber.
+   *
    * @param value The value to check.
-   * @returns `true` if the value is a non-zero finite number, `false` otherwise.
+   * @returns `true` if the value is a non-zero finite number, `false`
+   *   otherwise.
    */
   is,
 
   /**
    * Returns the absolute value of a non-zero finite number.
+   *
    * @param a The NonZeroFiniteNumber.
    * @returns The absolute value as a NonZeroFiniteNumber.
    */
@@ -131,6 +105,7 @@ export const NonZeroFiniteNumber = {
 
   /**
    * Returns the smaller of two NonZeroFiniteNumber values.
+   *
    * @param a The first NonZeroFiniteNumber.
    * @param b The second NonZeroFiniteNumber.
    * @returns The minimum value as a NonZeroFiniteNumber.
@@ -139,6 +114,7 @@ export const NonZeroFiniteNumber = {
 
   /**
    * Returns the larger of two NonZeroFiniteNumber values.
+   *
    * @param a The first NonZeroFiniteNumber.
    * @param b The second NonZeroFiniteNumber.
    * @returns The maximum value as a NonZeroFiniteNumber.
@@ -147,6 +123,7 @@ export const NonZeroFiniteNumber = {
 
   /**
    * Rounds down a NonZeroFiniteNumber to the nearest integer.
+   *
    * @param x The NonZeroFiniteNumber to round down.
    * @returns The floor value as a NonZeroInt.
    */
@@ -154,6 +131,7 @@ export const NonZeroFiniteNumber = {
 
   /**
    * Rounds up a NonZeroFiniteNumber to the nearest integer.
+   *
    * @param x The NonZeroFiniteNumber to round up.
    * @returns The ceiling value as a NonZeroInt.
    */
@@ -161,6 +139,7 @@ export const NonZeroFiniteNumber = {
 
   /**
    * Rounds a NonZeroFiniteNumber to the nearest integer.
+   *
    * @param x The NonZeroFiniteNumber to round.
    * @returns The rounded value as a NonZeroInt.
    */
@@ -168,12 +147,14 @@ export const NonZeroFiniteNumber = {
 
   /**
    * Generates a random NonZeroFiniteNumber value.
+   *
    * @returns A random non-zero finite number.
    */
   random,
 
   /**
    * Raises a NonZeroFiniteNumber to the power of another NonZeroFiniteNumber.
+   *
    * @param a The base NonZeroFiniteNumber.
    * @param b The exponent NonZeroFiniteNumber.
    * @returns `a ** b` as a NonZeroFiniteNumber.
@@ -182,6 +163,7 @@ export const NonZeroFiniteNumber = {
 
   /**
    * Adds two NonZeroFiniteNumber values.
+   *
    * @param a The first NonZeroFiniteNumber.
    * @param b The second NonZeroFiniteNumber.
    * @returns `a + b` as a NonZeroFiniteNumber.
@@ -190,6 +172,7 @@ export const NonZeroFiniteNumber = {
 
   /**
    * Subtracts one NonZeroFiniteNumber from another.
+   *
    * @param a The minuend NonZeroFiniteNumber.
    * @param b The subtrahend NonZeroFiniteNumber.
    * @returns `a - b` as a NonZeroFiniteNumber.
@@ -198,6 +181,7 @@ export const NonZeroFiniteNumber = {
 
   /**
    * Multiplies two NonZeroFiniteNumber values.
+   *
    * @param a The first NonZeroFiniteNumber.
    * @param b The second NonZeroFiniteNumber.
    * @returns `a * b` as a NonZeroFiniteNumber.
@@ -206,6 +190,7 @@ export const NonZeroFiniteNumber = {
 
   /**
    * Divides one NonZeroFiniteNumber by another.
+   *
    * @param a The dividend NonZeroFiniteNumber.
    * @param b The divisor NonZeroFiniteNumber.
    * @returns `a / b` as a NonZeroFiniteNumber.

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

@@ -7,16 +7,16 @@ const typeNameInMessage = 'a non-zero integer';
 
 const {
   abs,
-  min: min_,
-  max: max_,
-  pow,
   add,
-  sub,
-  mul,
+  castType,
   div,
-  randomNonZero: random,
   is,
-  castType,
+  max: max_,
+  min: min_,
+  mul,
+  pow,
+  randomNonZero: random,
+  sub,
 } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
   ElementType,
   number,
@@ -31,6 +31,7 @@ const {
 
 /**
  * Checks if a number is a NonZeroInt.
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt, `false` otherwise.
  */
@@ -38,49 +39,24 @@ export const isNonZeroInt = is;
 
 /**
  * Casts a number to a NonZeroInt type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroInt type.
  * @throws {TypeError} If the value is not a non-zero integer.
- * @example
- * ```typescript
- * const x = asNonZeroInt(5); // NonZeroInt
- * const y = asNonZeroInt(-3); // NonZeroInt
- * // asNonZeroInt(0); // throws TypeError
- * // asNonZeroInt(1.5); // throws TypeError
- * ```
  */
 export const asNonZeroInt = castType;
 
 /**
  * Namespace providing type-safe arithmetic operations for non-zero integers.
  *
- * All operations maintain the non-zero constraint, ensuring that results are always valid NonZeroInt values.
- * Division operations return floor division results, and all arithmetic maintains integer precision.
- *
- * @example
- * ```typescript
- * const a = asNonZeroInt(10);
- * const b = asNonZeroInt(-5);
- *
- * // Arithmetic operations
- * const sum = NonZeroInt.add(a, b);     // NonZeroInt (5)
- * const diff = NonZeroInt.sub(a, b);    // NonZeroInt (15)
- * const product = NonZeroInt.mul(a, b); // NonZeroInt (-50)
- * const quotient = NonZeroInt.div(a, b); // NonZeroInt (-2)
- *
- * // Utility operations
- * const absolute = NonZeroInt.abs(b);   // NonZeroInt (5)
- * const power = NonZeroInt.pow(a, asNonZeroInt(2)); // NonZeroInt (100)
- * const minimum = NonZeroInt.min(a, b); // NonZeroInt (-5)
- * const maximum = NonZeroInt(a, b); // NonZeroInt (10)
- *
- * // Random generation
- * const randomInt = NonZeroInt.random(); // NonZeroInt (random non-zero integer)
- * ```
+ * All operations maintain the non-zero constraint, ensuring that results are
+ * always valid NonZeroInt values. Division operations return floor division
+ * results, and all arithmetic maintains integer precision.
  */
 export const NonZeroInt = {
   /**
    * Type guard to check if a value is a NonZeroInt.
+   *
    * @param value The value to check.
    * @returns `true` if the value is a non-zero integer, `false` otherwise.
    */
@@ -88,6 +64,7 @@ export const NonZeroInt = {
 
   /**
    * Returns the absolute value of a non-zero integer.
+   *
    * @param a The non-zero integer.
    * @returns The absolute value as a NonZeroInt.
    */
@@ -95,6 +72,7 @@ export const NonZeroInt = {
 
   /**
    * Returns the smaller of two non-zero integers.
+   *
    * @param a The first non-zero integer.
    * @param b The second non-zero integer.
    * @returns The minimum value as a NonZeroInt.
@@ -103,6 +81,7 @@ export const NonZeroInt = {
 
   /**
    * Returns the larger of two non-zero integers.
+   *
    * @param a The first non-zero integer.
    * @param b The second non-zero integer.
    * @returns The maximum value as a NonZeroInt.
@@ -111,12 +90,14 @@ export const NonZeroInt = {
 
   /**
    * Generates a random non-zero integer.
+   *
    * @returns A random NonZeroInt value.
    */
   random,
 
   /**
    * Raises a non-zero integer to the power of another non-zero integer.
+   *
    * @param a The base non-zero integer.
    * @param b The exponent non-zero integer.
    * @returns `a ** b` as a NonZeroInt.
@@ -125,6 +106,7 @@ export const NonZeroInt = {
 
   /**
    * Adds two non-zero integers.
+   *
    * @param a The first non-zero integer.
    * @param b The second non-zero integer.
    * @returns `a + b` as a NonZeroInt.
@@ -133,6 +115,7 @@ export const NonZeroInt = {
 
   /**
    * Subtracts one non-zero integer from another.
+   *
    * @param a The minuend non-zero integer.
    * @param b The subtrahend non-zero integer.
    * @returns `a - b` as a NonZeroInt.
@@ -141,6 +124,7 @@ export const NonZeroInt = {
 
   /**
    * Multiplies two non-zero integers.
+   *
    * @param a The first non-zero integer.
    * @param b The second non-zero integer.
    * @returns `a * b` as a NonZeroInt.
@@ -149,6 +133,7 @@ export const NonZeroInt = {
 
   /**
    * Divides one non-zero integer by another using floor division.
+   *
    * @param a The dividend non-zero integer.
    * @param b The divisor non-zero integer.
    * @returns `⌊a / b⌋` as a NonZeroInt.

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

@@ -6,20 +6,20 @@ type ElementType = NonZeroInt16;
 const typeNameInMessage = 'a non-zero integer in [-2^15, 2^15)';
 
 const {
-  MIN_VALUE,
   MAX_VALUE,
+  MIN_VALUE,
   abs,
-  min: min_,
-  max: max_,
-  pow,
   add,
-  sub,
-  mul,
-  div,
-  randomNonZero: random,
-  is,
   castType,
   clamp,
+  div,
+  is,
+  max: max_,
+  min: min_,
+  mul,
+  pow,
+  randomNonZero: random,
+  sub,
 } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
   ElementType,
   number,
@@ -33,7 +33,9 @@ const {
 } as const);
 
 /**
- * Checks if a number is a NonZeroInt16 (16-bit non-zero signed integer in the range [-2^15, 2^15) excluding 0).
+ * Checks if a number is a NonZeroInt16 (16-bit non-zero signed integer in the
+ * range [-2^15, 2^15) excluding 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt16, `false` otherwise.
  */
@@ -41,69 +43,49 @@ export const isNonZeroInt16 = is;
 
 /**
  * Casts a number to a NonZeroInt16 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroInt16 type.
  * @throws {TypeError} If the value is not a non-zero integer in [-2^15, 2^15).
- * @example
- * ```typescript
- * const x = asNonZeroInt16(1000); // NonZeroInt16
- * const y = asNonZeroInt16(-1000); // NonZeroInt16
- * // asNonZeroInt16(0); // throws TypeError
- * // asNonZeroInt16(32768); // throws TypeError
- * ```
  */
 export const asNonZeroInt16 = castType;
 
 /**
- * Namespace providing type-safe arithmetic operations for 16-bit non-zero signed integers.
- *
- * All operations automatically clamp results to the valid NonZeroInt16 range [-32768, 32767]
- * excluding 0. This ensures that all arithmetic maintains the 16-bit non-zero signed integer
- * constraint, preventing zero results and overflow.
- *
- * @example
- * ```typescript
- * const a = asNonZeroInt16(30000);
- * const b = asNonZeroInt16(-10000);
- *
- * // Arithmetic operations with automatic clamping and non-zero constraint
- * const sum = NonZeroInt16.add(a, b);       // NonZeroInt16 (20000)
- * const diff = NonZeroInt16.sub(a, b);      // NonZeroInt16 (32767 - clamped to MAX_VALUE)
- * const product = NonZeroInt16.mul(a, b);   // NonZeroInt16 (-32768 - clamped to MIN_VALUE)
- *
- * // Utility operations
- * const absolute = NonZeroInt16.abs(b);         // NonZeroInt16 (10000)
- * const minimum = NonZeroInt16.min(a, b);       // NonZeroInt16 (-10000)
- * const maximum = NonZeroInt16.max(a, b);       // NonZeroInt16 (30000)
+ * Namespace providing type-safe arithmetic operations for 16-bit non-zero
+ * signed integers.
  *
- * // Range operations (avoiding zero)
- * const clamped = NonZeroInt16.clamp(0);        // NonZeroInt16 (1 or -1, avoiding zero)
- * const random = NonZeroInt16.random();         // NonZeroInt16 (random non-zero value in range)
- * const power = NonZeroInt16.pow(asNonZeroInt16(2), asNonZeroInt16(10)); // NonZeroInt16 (1024)
- * ```
+ * All operations automatically clamp results to the valid NonZeroInt16 range
+ * [-32768, 32767] excluding 0. This ensures that all arithmetic maintains the
+ * 16-bit non-zero signed integer constraint, preventing zero results and
+ * overflow.
  */
 export const NonZeroInt16 = {
   /**
    * Type guard to check if a value is a NonZeroInt16.
+   *
    * @param value The value to check.
-   * @returns `true` if the value is a 16-bit non-zero signed integer, `false` otherwise.
+   * @returns `true` if the value is a 16-bit non-zero signed integer, `false`
+   *   otherwise.
    */
   is,
 
   /**
    * The minimum value for a 16-bit non-zero signed integer.
+   *
    * @readonly
    */
   MIN_VALUE,
 
   /**
    * The maximum value for a 16-bit non-zero signed integer.
+   *
    * @readonly
    */
   MAX_VALUE,
 
   /**
    * Returns the absolute value of a 16-bit non-zero signed integer.
+   *
    * @param a The NonZeroInt16 value.
    * @returns The absolute value as a NonZeroInt16, clamped to valid range.
    */
@@ -111,6 +93,7 @@ export const NonZeroInt16 = {
 
   /**
    * Returns the smaller of two NonZeroInt16 values.
+   *
    * @param a The first NonZeroInt16.
    * @param b The second NonZeroInt16.
    * @returns The minimum value as a NonZeroInt16.
@@ -119,6 +102,7 @@ export const NonZeroInt16 = {
 
   /**
    * Returns the larger of two NonZeroInt16 values.
+   *
    * @param a The first NonZeroInt16.
    * @param b The second NonZeroInt16.
    * @returns The maximum value as a NonZeroInt16.
@@ -127,6 +111,7 @@ export const NonZeroInt16 = {
 
   /**
    * Clamps a number to the NonZeroInt16 range (avoiding zero).
+   *
    * @param value The number to clamp.
    * @returns The value clamped to [-32768, 32767] \ {0} as a NonZeroInt16.
    */
@@ -134,12 +119,15 @@ export const NonZeroInt16 = {
 
   /**
    * Generates a random NonZeroInt16 value within the valid range.
-   * @returns A random NonZeroInt16 between MIN_VALUE and MAX_VALUE (excluding 0).
+   *
+   * @returns A random NonZeroInt16 between MIN_VALUE and MAX_VALUE (excluding
+   *   0).
    */
   random,
 
   /**
    * Raises a NonZeroInt16 to the power of another NonZeroInt16.
+   *
    * @param a The base NonZeroInt16.
    * @param b The exponent NonZeroInt16.
    * @returns `a ** b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -148,6 +136,7 @@ export const NonZeroInt16 = {
 
   /**
    * Adds two NonZeroInt16 values.
+   *
    * @param a The first NonZeroInt16.
    * @param b The second NonZeroInt16.
    * @returns `a + b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -156,6 +145,7 @@ export const NonZeroInt16 = {
 
   /**
    * Subtracts one NonZeroInt16 from another.
+   *
    * @param a The minuend NonZeroInt16.
    * @param b The subtrahend NonZeroInt16.
    * @returns `a - b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -164,6 +154,7 @@ export const NonZeroInt16 = {
 
   /**
    * Multiplies two NonZeroInt16 values.
+   *
    * @param a The first NonZeroInt16.
    * @param b The second NonZeroInt16.
    * @returns `a * b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -172,6 +163,7 @@ export const NonZeroInt16 = {
 
   /**
    * Divides one NonZeroInt16 by another using floor division.
+   *
    * @param a The dividend NonZeroInt16.
    * @param b The divisor NonZeroInt16.
    * @returns `⌊a / b⌋` clamped to [-32768, 32767] as a NonZeroInt16.

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

@@ -11,8 +11,8 @@ describe('NonZeroInt16', () => {
     test('accepts valid non-zero int16 values', () => {
       expect(() => asNonZeroInt16(1)).not.toThrow();
       expect(() => asNonZeroInt16(-1)).not.toThrow();
-      expect(() => asNonZeroInt16(32767)).not.toThrow(); // 2^15 - 1
-      expect(() => asNonZeroInt16(-32768)).not.toThrow(); // -2^15
+      expect(() => asNonZeroInt16(32_767)).not.toThrow(); // 2^15 - 1
+      expect(() => asNonZeroInt16(-32_768)).not.toThrow(); // -2^15
     });
 
     test('rejects zero', () => {
@@ -20,10 +20,10 @@ describe('NonZeroInt16', () => {
     });
 
     test('rejects values outside int16 range', () => {
-      expect(() => asNonZeroInt16(32768)).toThrow(TypeError); // 2^15
-      expect(() => asNonZeroInt16(-32769)).toThrow(TypeError); // -2^15 - 1
-      expect(() => asNonZeroInt16(65536)).toThrow(TypeError);
-      expect(() => asNonZeroInt16(-65536)).toThrow(TypeError);
+      expect(() => asNonZeroInt16(32_768)).toThrow(TypeError); // 2^15
+      expect(() => asNonZeroInt16(-32_769)).toThrow(TypeError); // -2^15 - 1
+      expect(() => asNonZeroInt16(65_536)).toThrow(TypeError);
+      expect(() => asNonZeroInt16(-65_536)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
@@ -37,8 +37,8 @@ describe('NonZeroInt16', () => {
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroInt16(5)).toBe(5);
       expect(asNonZeroInt16(-10)).toBe(-10);
-      expect(asNonZeroInt16(32767)).toBe(32767);
-      expect(asNonZeroInt16(-32768)).toBe(-32768);
+      expect(asNonZeroInt16(32_767)).toBe(32_767);
+      expect(asNonZeroInt16(-32_768)).toBe(-32_768);
     });
 
     test.each([
@@ -48,8 +48,8 @@ describe('NonZeroInt16', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
       { name: '0', value: 0 },
-      { name: '32768', value: 32768 },
-      { name: '-32769', value: -32769 },
+      { name: '32768', value: 32_768 },
+      { name: '-32769', value: -32_769 },
     ] as const)(
       `asNonZeroInt16($name) should throw a TypeError`,
       ({ value }) => {
@@ -66,8 +66,8 @@ describe('NonZeroInt16', () => {
     test('correctly identifies non-zero int16 values', () => {
       expect(isNonZeroInt16(1)).toBe(true);
       expect(isNonZeroInt16(-1)).toBe(true);
-      expect(isNonZeroInt16(32767)).toBe(true);
-      expect(isNonZeroInt16(-32768)).toBe(true);
+      expect(isNonZeroInt16(32_767)).toBe(true);
+      expect(isNonZeroInt16(-32_768)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
@@ -75,10 +75,10 @@ describe('NonZeroInt16', () => {
     });
 
     test('correctly identifies values outside int16 range', () => {
-      expect(isNonZeroInt16(32768)).toBe(false);
-      expect(isNonZeroInt16(-32769)).toBe(false);
-      expect(isNonZeroInt16(65536)).toBe(false);
-      expect(isNonZeroInt16(-65536)).toBe(false);
+      expect(isNonZeroInt16(32_768)).toBe(false);
+      expect(isNonZeroInt16(-32_769)).toBe(false);
+      expect(isNonZeroInt16(65_536)).toBe(false);
+      expect(isNonZeroInt16(-65_536)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
@@ -100,8 +100,8 @@ describe('NonZeroInt16', () => {
 
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
-      expect(NonZeroInt16.MIN_VALUE).toBe(-32768);
-      expect(NonZeroInt16.MAX_VALUE).toBe(32767);
+      expect(NonZeroInt16.MIN_VALUE).toBe(-32_768);
+      expect(NonZeroInt16.MAX_VALUE).toBe(32_767);
     });
   });
 
@@ -124,19 +124,19 @@ describe('NonZeroInt16', () => {
 
     test('add (with clamping)', () => {
       const result = NonZeroInt16.add(
-        asNonZeroInt16(32000),
+        asNonZeroInt16(32_000),
         asNonZeroInt16(1000),
       );
-      expect(result).toBe(32767); // clamped to max
+      expect(result).toBe(32_767); // clamped to max
       expect(NonZeroInt16.add(a, b)).toBe(150);
     });
 
     test('sub (with clamping)', () => {
       const result = NonZeroInt16.sub(
-        asNonZeroInt16(-32000),
+        asNonZeroInt16(-32_000),
         asNonZeroInt16(1000),
       );
-      expect(result).toBe(-32768); // clamped to min
+      expect(result).toBe(-32_768); // clamped to min
       expect(NonZeroInt16.sub(a, b)).toBe(50);
     });
 
@@ -145,7 +145,7 @@ describe('NonZeroInt16', () => {
         asNonZeroInt16(1000),
         asNonZeroInt16(100),
       );
-      expect(result).toBe(32767); // clamped to max
+      expect(result).toBe(32_767); // clamped to max
       expect(NonZeroInt16.mul(asNonZeroInt16(10), asNonZeroInt16(5))).toBe(50);
     });
 
@@ -157,7 +157,7 @@ describe('NonZeroInt16', () => {
 
     test('pow (with clamping)', () => {
       const result = NonZeroInt16.pow(asNonZeroInt16(200), asNonZeroInt16(3));
-      expect(result).toBe(32767); // clamped to max
+      expect(result).toBe(32_767); // clamped to max
       expect(NonZeroInt16.pow(asNonZeroInt16(2), asNonZeroInt16(3))).toBe(8);
     });
   });
@@ -180,8 +180,8 @@ describe('NonZeroInt16', () => {
     test('generates values within NonZeroInt16 range', () => {
       for (const _ of range(10)) {
         const result = NonZeroInt16.random(-20, 20);
-        expect(result).toBeGreaterThanOrEqual(-32768);
-        expect(result).toBeLessThanOrEqual(32767);
+        expect(result).toBeGreaterThanOrEqual(-32_768);
+        expect(result).toBeLessThanOrEqual(32_767);
       }
     });
   });