ts-data-forge 5.0.0 → 5.1.0

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

@@ -10,8 +10,11 @@ describe('NonZeroInt32 test', () => {
   describe(asNonZeroInt32, () => {
     test('accepts valid non-zero int32 values', () => {
       expect(() => asNonZeroInt32(1)).not.toThrow();
+
       expect(() => asNonZeroInt32(-1)).not.toThrow();
+
       expect(() => asNonZeroInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
+
       expect(() => asNonZeroInt32(-2_147_483_648)).not.toThrow(); // -2^31
     });
 
@@ -21,23 +24,33 @@ describe('NonZeroInt32 test', () => {
 
     test('rejects values outside int32 range', () => {
       expect(() => asNonZeroInt32(2_147_483_648)).toThrow(TypeError); // 2^31
+
       expect(() => asNonZeroInt32(-2_147_483_649)).toThrow(TypeError); // -2^31 - 1
+
       expect(() => asNonZeroInt32(4_294_967_296)).toThrow(TypeError);
+
       expect(() => asNonZeroInt32(-4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroInt32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroInt32(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt32(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt32(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroInt32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroInt32(5)).toBe(5);
+
       expect(asNonZeroInt32(-10)).toBe(-10);
+
       expect(asNonZeroInt32(2_147_483_647)).toBe(2_147_483_647);
+
       expect(asNonZeroInt32(-2_147_483_648)).toBe(-2_147_483_648);
     });
 
@@ -65,8 +78,11 @@ describe('NonZeroInt32 test', () => {
   describe(isNonZeroInt32, () => {
     test('correctly identifies non-zero int32 values', () => {
       expect(isNonZeroInt32(1)).toBe(true);
+
       expect(isNonZeroInt32(-1)).toBe(true);
+
       expect(isNonZeroInt32(2_147_483_647)).toBe(true);
+
       expect(isNonZeroInt32(-2_147_483_648)).toBe(true);
     });
 
@@ -76,16 +92,23 @@ describe('NonZeroInt32 test', () => {
 
     test('correctly identifies values outside int32 range', () => {
       expect(isNonZeroInt32(2_147_483_648)).toBe(false);
+
       expect(isNonZeroInt32(-2_147_483_649)).toBe(false);
+
       expect(isNonZeroInt32(4_294_967_296)).toBe(false);
+
       expect(isNonZeroInt32(-4_294_967_296)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isNonZeroInt32(Number.NaN)).toBe(false);
+
       expect(isNonZeroInt32(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroInt32(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroInt32(1.2)).toBe(false);
+
       expect(isNonZeroInt32(-3.4)).toBe(false);
     });
   });
@@ -93,7 +116,9 @@ describe('NonZeroInt32 test', () => {
   describe('NonZeroInt32.is', () => {
     test('same as isNonZeroInt32 function', () => {
       expect(NonZeroInt32.is(5)).toBe(isNonZeroInt32(5));
+
       expect(NonZeroInt32.is(0)).toBe(isNonZeroInt32(0));
+
       expect(NonZeroInt32.is(-1)).toBe(isNonZeroInt32(-1));
     });
   });
@@ -101,24 +126,31 @@ describe('NonZeroInt32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroInt32.MIN_VALUE).toBe(-2_147_483_648);
+
       expect(NonZeroInt32.MAX_VALUE).toBe(2_147_483_647);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroInt32(1_000_000);
+
     const b = asNonZeroInt32(500_000);
+
     const c = asNonZeroInt32(-300_000);
 
     test('abs', () => {
       expect(NonZeroInt32.abs(a)).toBe(1_000_000);
+
       expect(NonZeroInt32.abs(c)).toBe(300_000);
     });
 
     test('min and max', () => {
       expect(NonZeroInt32.min(a, b)).toBe(500_000);
+
       expect(NonZeroInt32.max(a, b)).toBe(1_000_000);
+
       expect(NonZeroInt32.min(a, c)).toBe(-300_000);
+
       expect(NonZeroInt32.max(a, c)).toBe(1_000_000);
     });
 
@@ -129,6 +161,7 @@ describe('NonZeroInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(NonZeroInt32.add(a, b)).toBe(1_500_000);
     });
 
@@ -139,6 +172,7 @@ describe('NonZeroInt32 test', () => {
       );
 
       expect(result).toBe(-2_147_483_648); // clamped to min
+
       expect(NonZeroInt32.sub(a, b)).toBe(500_000);
     });
 
@@ -149,6 +183,7 @@ describe('NonZeroInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(NonZeroInt32.mul(asNonZeroInt32(1000), asNonZeroInt32(5))).toBe(
         5000,
       );
@@ -156,7 +191,9 @@ describe('NonZeroInt32 test', () => {
 
     test('div (floor division with clamping)', () => {
       expect(NonZeroInt32.div(a, asNonZeroInt32(500_000))).toBe(2);
+
       expect(NonZeroInt32.div(asNonZeroInt32(7), asNonZeroInt32(3))).toBe(2);
+
       expect(NonZeroInt32.div(asNonZeroInt32(-7), asNonZeroInt32(3))).toBe(-3);
     });
 
@@ -167,6 +204,7 @@ describe('NonZeroInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(NonZeroInt32.pow(asNonZeroInt32(2), asNonZeroInt32(3))).toBe(8);
     });
   });
@@ -174,15 +212,20 @@ describe('NonZeroInt32 test', () => {
   describe('random', () => {
     test('generates non-zero int32 values within specified range', () => {
       const min = -10;
+
       const max = 10;
 
       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);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });
@@ -192,6 +235,7 @@ describe('NonZeroInt32 test', () => {
         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.mts

@@ -27,9 +27,9 @@ const {
 >({
   integerOrSafeInteger: 'SafeInteger',
   nonZero: true,
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-min-safe-integer
   MIN_VALUE: Number.MIN_SAFE_INTEGER as SafeInt,
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-max-safe-integer
   MAX_VALUE: Number.MAX_SAFE_INTEGER as SafeUint,
   typeNameInMessage,
 } as const);

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

@@ -10,15 +10,21 @@ describe('NonZeroSafeInt test', () => {
   describe(asNonZeroSafeInt, () => {
     test('accepts valid non-zero safe integers', () => {
       expect(() => asNonZeroSafeInt(1)).not.toThrow();
+
       expect(() => asNonZeroSafeInt(-1)).not.toThrow();
+
       expect(() => asNonZeroSafeInt(42)).not.toThrow();
+
       expect(() => asNonZeroSafeInt(-42)).not.toThrow();
+
       expect(() => asNonZeroSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+
       expect(() => asNonZeroSafeInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects zero', () => {
       expect(() => asNonZeroSafeInt(0)).toThrow(TypeError);
+
       expect(() => asNonZeroSafeInt(-0)).toThrow(TypeError);
     });
 
@@ -26,28 +32,37 @@ describe('NonZeroSafeInt test', () => {
       expect(() => asNonZeroSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroSafeInt(Number.MIN_SAFE_INTEGER - 1)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroSafeInt(Number.MAX_VALUE)).toThrow(TypeError);
+
       expect(() => asNonZeroSafeInt(-Number.MAX_VALUE)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroSafeInt(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroSafeInt(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroSafeInt(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroSafeInt(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroSafeInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroSafeInt(5)).toBe(5);
+
       expect(asNonZeroSafeInt(-10)).toBe(-10);
+
       expect(asNonZeroSafeInt(1)).toBe(1);
     });
 
@@ -71,30 +86,43 @@ describe('NonZeroSafeInt test', () => {
   describe(isNonZeroSafeInt, () => {
     test('correctly identifies non-zero safe integers', () => {
       expect(isNonZeroSafeInt(1)).toBe(true);
+
       expect(isNonZeroSafeInt(-1)).toBe(true);
+
       expect(isNonZeroSafeInt(42)).toBe(true);
+
       expect(isNonZeroSafeInt(-42)).toBe(true);
+
       expect(isNonZeroSafeInt(Number.MAX_SAFE_INTEGER)).toBe(true);
+
       expect(isNonZeroSafeInt(Number.MIN_SAFE_INTEGER)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
       expect(isNonZeroSafeInt(0)).toBe(false);
+
       expect(isNonZeroSafeInt(-0)).toBe(false);
     });
 
     test('correctly identifies values outside safe integer range', () => {
       expect(isNonZeroSafeInt(Number.MAX_SAFE_INTEGER + 1)).toBe(false);
+
       expect(isNonZeroSafeInt(Number.MIN_SAFE_INTEGER - 1)).toBe(false);
+
       expect(isNonZeroSafeInt(Number.MAX_VALUE)).toBe(false);
+
       expect(isNonZeroSafeInt(-Number.MAX_VALUE)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isNonZeroSafeInt(Number.NaN)).toBe(false);
+
       expect(isNonZeroSafeInt(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroSafeInt(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroSafeInt(1.2)).toBe(false);
+
       expect(isNonZeroSafeInt(-3.4)).toBe(false);
     });
   });
@@ -102,7 +130,9 @@ describe('NonZeroSafeInt test', () => {
   describe('NonZeroSafeInt.is', () => {
     test('same as isNonZeroSafeInt function', () => {
       expect(NonZeroSafeInt.is(5)).toBe(isNonZeroSafeInt(5));
+
       expect(NonZeroSafeInt.is(0)).toBe(isNonZeroSafeInt(0));
+
       expect(NonZeroSafeInt.is(-10)).toBe(isNonZeroSafeInt(-10));
     });
   });
@@ -110,41 +140,53 @@ describe('NonZeroSafeInt test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroSafeInt.MIN_VALUE).toBe(Number.MIN_SAFE_INTEGER);
+
       expect(NonZeroSafeInt.MAX_VALUE).toBe(Number.MAX_SAFE_INTEGER);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroSafeInt(5);
+
     const b = asNonZeroSafeInt(2);
+
     const c = asNonZeroSafeInt(-3);
 
     test('abs', () => {
       expect(NonZeroSafeInt.abs(a)).toBe(5);
+
       expect(NonZeroSafeInt.abs(c)).toBe(3);
+
       expect(NonZeroSafeInt.abs(asNonZeroSafeInt(-1))).toBe(1);
     });
 
     test('min and max', () => {
       expect(NonZeroSafeInt.min(a, b)).toBe(2);
+
       expect(NonZeroSafeInt.max(a, b)).toBe(5);
+
       expect(NonZeroSafeInt.min(a, c)).toBe(-3);
+
       expect(NonZeroSafeInt.max(a, c)).toBe(5);
     });
 
     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);
     });
 
     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);
     });
 
@@ -152,9 +194,11 @@ describe('NonZeroSafeInt test', () => {
       const largeValue = asNonZeroSafeInt(
         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)),
       ).toBe(50);
@@ -162,9 +206,11 @@ describe('NonZeroSafeInt test', () => {
 
     test('div (floor division with clamping)', () => {
       expect(NonZeroSafeInt.div(a, b)).toBe(2);
+
       expect(NonZeroSafeInt.div(asNonZeroSafeInt(7), asNonZeroSafeInt(3))).toBe(
         2,
       );
+
       expect(
         NonZeroSafeInt.div(asNonZeroSafeInt(-7), asNonZeroSafeInt(3)),
       ).toBe(-3);
@@ -177,6 +223,7 @@ describe('NonZeroSafeInt test', () => {
       );
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(NonZeroSafeInt.pow(asNonZeroSafeInt(2), asNonZeroSafeInt(3))).toBe(
         8,
       );
@@ -186,45 +233,60 @@ describe('NonZeroSafeInt test', () => {
   describe('random', () => {
     test('generates non-zero safe integers within specified range (positive range)', () => {
       const min = 1;
+
       const max = 20;
 
       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);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero safe integers within specified range (negative range)', () => {
       const min = -20;
+
       const max = -1;
 
       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);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero safe integers within range that spans zero', () => {
       const min = -5;
+
       const max = 5;
 
       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);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });

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

@@ -10,8 +10,11 @@ describe('NonZeroUint16 test', () => {
   describe(asNonZeroUint16, () => {
     test('accepts valid non-zero uint16 values', () => {
       expect(() => asNonZeroUint16(1)).not.toThrow();
+
       expect(() => asNonZeroUint16(1000)).not.toThrow();
+
       expect(() => asNonZeroUint16(65_535)).not.toThrow(); // 2^16 - 1
+
       expect(() => asNonZeroUint16(32_768)).not.toThrow(); // 2^15
     });
 
@@ -21,29 +24,37 @@ describe('NonZeroUint16 test', () => {
 
     test('rejects values outside uint16 range', () => {
       expect(() => asNonZeroUint16(65_536)).toThrow(TypeError); // 2^16
+
       expect(() => asNonZeroUint16(100_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asNonZeroUint16(-1)).toThrow(TypeError);
+
       expect(() => asNonZeroUint16(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroUint16(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroUint16(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroUint16(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroUint16(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroUint16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroUint16(5)).toBe(5);
+
       expect(asNonZeroUint16(1)).toBe(1);
+
       expect(asNonZeroUint16(65_535)).toBe(65_535);
     });
 
@@ -71,8 +82,11 @@ describe('NonZeroUint16 test', () => {
   describe(isNonZeroUint16, () => {
     test('correctly identifies non-zero uint16 values', () => {
       expect(isNonZeroUint16(1)).toBe(true);
+
       expect(isNonZeroUint16(1000)).toBe(true);
+
       expect(isNonZeroUint16(65_535)).toBe(true);
+
       expect(isNonZeroUint16(32_768)).toBe(true);
     });
 
@@ -82,19 +96,25 @@ describe('NonZeroUint16 test', () => {
 
     test('correctly identifies values outside uint16 range', () => {
       expect(isNonZeroUint16(65_536)).toBe(false);
+
       expect(isNonZeroUint16(100_000)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isNonZeroUint16(-1)).toBe(false);
+
       expect(isNonZeroUint16(-42)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isNonZeroUint16(Number.NaN)).toBe(false);
+
       expect(isNonZeroUint16(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroUint16(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroUint16(1.2)).toBe(false);
+
       expect(isNonZeroUint16(-3.4)).toBe(false);
     });
   });
@@ -102,7 +122,9 @@ describe('NonZeroUint16 test', () => {
   describe('NonZeroUint16.is', () => {
     test('same as isNonZeroUint16 function', () => {
       expect(NonZeroUint16.is(5)).toBe(isNonZeroUint16(5));
+
       expect(NonZeroUint16.is(0)).toBe(isNonZeroUint16(0));
+
       expect(NonZeroUint16.is(-1)).toBe(isNonZeroUint16(-1));
     });
   });
@@ -110,16 +132,19 @@ describe('NonZeroUint16 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroUint16.MIN_VALUE).toBe(1);
+
       expect(NonZeroUint16.MAX_VALUE).toBe(65_535);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroUint16(100);
+
     const b = asNonZeroUint16(50);
 
     test('min and max', () => {
       expect(NonZeroUint16.min(a, b)).toBe(50);
+
       expect(NonZeroUint16.max(a, b)).toBe(100);
     });
 
@@ -130,11 +155,13 @@ describe('NonZeroUint16 test', () => {
       );
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(NonZeroUint16.add(a, b)).toBe(150);
     });
 
     test('sub (never goes below 1)', () => {
       expect(NonZeroUint16.sub(a, b)).toBe(50);
+
       expect(NonZeroUint16.sub(b, a)).toBe(1); // clamped to 1
     });
 
@@ -145,6 +172,7 @@ describe('NonZeroUint16 test', () => {
       );
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(NonZeroUint16.mul(asNonZeroUint16(10), asNonZeroUint16(5))).toBe(
         50,
       );
@@ -152,7 +180,9 @@ describe('NonZeroUint16 test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(NonZeroUint16.div(a, asNonZeroUint16(50))).toBe(2);
+
       expect(NonZeroUint16.div(asNonZeroUint16(7), asNonZeroUint16(3))).toBe(2);
+
       expect(NonZeroUint16.div(asNonZeroUint16(50), asNonZeroUint16(100))).toBe(
         1,
       ); // floor(50/100) = 0, clamped to 1
@@ -165,6 +195,7 @@ describe('NonZeroUint16 test', () => {
       );
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(NonZeroUint16.pow(asNonZeroUint16(2), asNonZeroUint16(3))).toBe(8);
     });
   });
@@ -172,15 +203,20 @@ describe('NonZeroUint16 test', () => {
   describe('random', () => {
     test('generates non-zero uint16 values within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       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);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });
@@ -190,6 +226,7 @@ describe('NonZeroUint16 test', () => {
         const result = NonZeroUint16.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(65_535);
       }
     });