ts-data-forge 5.1.0 → 5.1.1

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

@@ -60,35 +60,35 @@ describe('NonZeroInt test', () => {
 
   describe(isNonZeroInt, () => {
     test('correctly identifies non-zero integers', () => {
-      expect(isNonZeroInt(1)).toBe(true);
+      assert.isTrue(isNonZeroInt(1));
 
-      expect(isNonZeroInt(-1)).toBe(true);
+      assert.isTrue(isNonZeroInt(-1));
 
-      expect(isNonZeroInt(42)).toBe(true);
+      assert.isTrue(isNonZeroInt(42));
 
-      expect(isNonZeroInt(-42)).toBe(true);
+      assert.isTrue(isNonZeroInt(-42));
 
-      expect(isNonZeroInt(Number.MAX_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isNonZeroInt(Number.MAX_SAFE_INTEGER));
 
-      expect(isNonZeroInt(Number.MIN_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isNonZeroInt(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroInt(0)).toBe(false);
+      assert.isFalse(isNonZeroInt(0));
 
-      expect(isNonZeroInt(-0)).toBe(false);
+      assert.isFalse(isNonZeroInt(-0));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroInt(Number.NaN)).toBe(false);
+      assert.isFalse(isNonZeroInt(Number.NaN));
 
-      expect(isNonZeroInt(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroInt(Number.POSITIVE_INFINITY));
 
-      expect(isNonZeroInt(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroInt(Number.NEGATIVE_INFINITY));
 
-      expect(isNonZeroInt(1.2)).toBe(false);
+      assert.isFalse(isNonZeroInt(1.2));
 
-      expect(isNonZeroInt(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroInt(-3.4));
     });
   });
 
@@ -175,9 +175,9 @@ describe('NonZeroInt test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroInt.is(result)).toBe(true);
+        assert.isTrue(NonZeroInt.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).not.toBe(0);
       }
@@ -195,9 +195,9 @@ describe('NonZeroInt test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroInt.is(result)).toBe(true);
+        assert.isTrue(NonZeroInt.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).not.toBe(0);
       }
@@ -215,9 +215,9 @@ describe('NonZeroInt test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroInt.is(result)).toBe(true);
+        assert.isTrue(NonZeroInt.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).not.toBe(0);
       }

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

@@ -77,39 +77,39 @@ describe('NonZeroInt16 test', () => {
 
   describe(isNonZeroInt16, () => {
     test('correctly identifies non-zero int16 values', () => {
-      expect(isNonZeroInt16(1)).toBe(true);
+      assert.isTrue(isNonZeroInt16(1));
 
-      expect(isNonZeroInt16(-1)).toBe(true);
+      assert.isTrue(isNonZeroInt16(-1));
 
-      expect(isNonZeroInt16(32_767)).toBe(true);
+      assert.isTrue(isNonZeroInt16(32_767));
 
-      expect(isNonZeroInt16(-32_768)).toBe(true);
+      assert.isTrue(isNonZeroInt16(-32_768));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroInt16(0)).toBe(false);
+      assert.isFalse(isNonZeroInt16(0));
     });
 
     test('correctly identifies values outside int16 range', () => {
-      expect(isNonZeroInt16(32_768)).toBe(false);
+      assert.isFalse(isNonZeroInt16(32_768));
 
-      expect(isNonZeroInt16(-32_769)).toBe(false);
+      assert.isFalse(isNonZeroInt16(-32_769));
 
-      expect(isNonZeroInt16(65_536)).toBe(false);
+      assert.isFalse(isNonZeroInt16(65_536));
 
-      expect(isNonZeroInt16(-65_536)).toBe(false);
+      assert.isFalse(isNonZeroInt16(-65_536));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroInt16(Number.NaN)).toBe(false);
+      assert.isFalse(isNonZeroInt16(Number.NaN));
 
-      expect(isNonZeroInt16(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroInt16(Number.POSITIVE_INFINITY));
 
-      expect(isNonZeroInt16(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroInt16(Number.NEGATIVE_INFINITY));
 
-      expect(isNonZeroInt16(1.2)).toBe(false);
+      assert.isFalse(isNonZeroInt16(1.2));
 
-      expect(isNonZeroInt16(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroInt16(-3.4));
     });
   });
 
@@ -217,9 +217,9 @@ describe('NonZeroInt16 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroInt16.is(result)).toBe(true);
+        assert.isTrue(NonZeroInt16.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).not.toBe(0);
       }

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

@@ -77,39 +77,39 @@ describe('NonZeroInt32 test', () => {
 
   describe(isNonZeroInt32, () => {
     test('correctly identifies non-zero int32 values', () => {
-      expect(isNonZeroInt32(1)).toBe(true);
+      assert.isTrue(isNonZeroInt32(1));
 
-      expect(isNonZeroInt32(-1)).toBe(true);
+      assert.isTrue(isNonZeroInt32(-1));
 
-      expect(isNonZeroInt32(2_147_483_647)).toBe(true);
+      assert.isTrue(isNonZeroInt32(2_147_483_647));
 
-      expect(isNonZeroInt32(-2_147_483_648)).toBe(true);
+      assert.isTrue(isNonZeroInt32(-2_147_483_648));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroInt32(0)).toBe(false);
+      assert.isFalse(isNonZeroInt32(0));
     });
 
     test('correctly identifies values outside int32 range', () => {
-      expect(isNonZeroInt32(2_147_483_648)).toBe(false);
+      assert.isFalse(isNonZeroInt32(2_147_483_648));
 
-      expect(isNonZeroInt32(-2_147_483_649)).toBe(false);
+      assert.isFalse(isNonZeroInt32(-2_147_483_649));
 
-      expect(isNonZeroInt32(4_294_967_296)).toBe(false);
+      assert.isFalse(isNonZeroInt32(4_294_967_296));
 
-      expect(isNonZeroInt32(-4_294_967_296)).toBe(false);
+      assert.isFalse(isNonZeroInt32(-4_294_967_296));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroInt32(Number.NaN)).toBe(false);
+      assert.isFalse(isNonZeroInt32(Number.NaN));
 
-      expect(isNonZeroInt32(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroInt32(Number.POSITIVE_INFINITY));
 
-      expect(isNonZeroInt32(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroInt32(Number.NEGATIVE_INFINITY));
 
-      expect(isNonZeroInt32(1.2)).toBe(false);
+      assert.isFalse(isNonZeroInt32(1.2));
 
-      expect(isNonZeroInt32(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroInt32(-3.4));
     });
   });
 
@@ -222,9 +222,9 @@ describe('NonZeroInt32 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroInt32.is(result)).toBe(true);
+        assert.isTrue(NonZeroInt32.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).not.toBe(0);
       }

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

@@ -85,45 +85,45 @@ describe('NonZeroSafeInt test', () => {
 
   describe(isNonZeroSafeInt, () => {
     test('correctly identifies non-zero safe integers', () => {
-      expect(isNonZeroSafeInt(1)).toBe(true);
+      assert.isTrue(isNonZeroSafeInt(1));
 
-      expect(isNonZeroSafeInt(-1)).toBe(true);
+      assert.isTrue(isNonZeroSafeInt(-1));
 
-      expect(isNonZeroSafeInt(42)).toBe(true);
+      assert.isTrue(isNonZeroSafeInt(42));
 
-      expect(isNonZeroSafeInt(-42)).toBe(true);
+      assert.isTrue(isNonZeroSafeInt(-42));
 
-      expect(isNonZeroSafeInt(Number.MAX_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isNonZeroSafeInt(Number.MAX_SAFE_INTEGER));
 
-      expect(isNonZeroSafeInt(Number.MIN_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isNonZeroSafeInt(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroSafeInt(0)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(0));
 
-      expect(isNonZeroSafeInt(-0)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(-0));
     });
 
     test('correctly identifies values outside safe integer range', () => {
-      expect(isNonZeroSafeInt(Number.MAX_SAFE_INTEGER + 1)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(Number.MAX_SAFE_INTEGER + 1));
 
-      expect(isNonZeroSafeInt(Number.MIN_SAFE_INTEGER - 1)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(Number.MIN_SAFE_INTEGER - 1));
 
-      expect(isNonZeroSafeInt(Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(Number.MAX_VALUE));
 
-      expect(isNonZeroSafeInt(-Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(-Number.MAX_VALUE));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroSafeInt(Number.NaN)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(Number.NaN));
 
-      expect(isNonZeroSafeInt(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(Number.POSITIVE_INFINITY));
 
-      expect(isNonZeroSafeInt(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(Number.NEGATIVE_INFINITY));
 
-      expect(isNonZeroSafeInt(1.2)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(1.2));
 
-      expect(isNonZeroSafeInt(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroSafeInt(-3.4));
     });
   });
 
@@ -243,9 +243,9 @@ describe('NonZeroSafeInt test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroSafeInt.is(result)).toBe(true);
+        assert.isTrue(NonZeroSafeInt.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).not.toBe(0);
       }
@@ -263,9 +263,9 @@ describe('NonZeroSafeInt test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroSafeInt.is(result)).toBe(true);
+        assert.isTrue(NonZeroSafeInt.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).not.toBe(0);
       }
@@ -283,9 +283,9 @@ describe('NonZeroSafeInt test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroSafeInt.is(result)).toBe(true);
+        assert.isTrue(NonZeroSafeInt.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).not.toBe(0);
       }

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

@@ -81,41 +81,41 @@ describe('NonZeroUint16 test', () => {
 
   describe(isNonZeroUint16, () => {
     test('correctly identifies non-zero uint16 values', () => {
-      expect(isNonZeroUint16(1)).toBe(true);
+      assert.isTrue(isNonZeroUint16(1));
 
-      expect(isNonZeroUint16(1000)).toBe(true);
+      assert.isTrue(isNonZeroUint16(1000));
 
-      expect(isNonZeroUint16(65_535)).toBe(true);
+      assert.isTrue(isNonZeroUint16(65_535));
 
-      expect(isNonZeroUint16(32_768)).toBe(true);
+      assert.isTrue(isNonZeroUint16(32_768));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroUint16(0)).toBe(false);
+      assert.isFalse(isNonZeroUint16(0));
     });
 
     test('correctly identifies values outside uint16 range', () => {
-      expect(isNonZeroUint16(65_536)).toBe(false);
+      assert.isFalse(isNonZeroUint16(65_536));
 
-      expect(isNonZeroUint16(100_000)).toBe(false);
+      assert.isFalse(isNonZeroUint16(100_000));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isNonZeroUint16(-1)).toBe(false);
+      assert.isFalse(isNonZeroUint16(-1));
 
-      expect(isNonZeroUint16(-42)).toBe(false);
+      assert.isFalse(isNonZeroUint16(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroUint16(Number.NaN)).toBe(false);
+      assert.isFalse(isNonZeroUint16(Number.NaN));
 
-      expect(isNonZeroUint16(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroUint16(Number.POSITIVE_INFINITY));
 
-      expect(isNonZeroUint16(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroUint16(Number.NEGATIVE_INFINITY));
 
-      expect(isNonZeroUint16(1.2)).toBe(false);
+      assert.isFalse(isNonZeroUint16(1.2));
 
-      expect(isNonZeroUint16(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroUint16(-3.4));
     });
   });
 
@@ -213,9 +213,9 @@ describe('NonZeroUint16 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroUint16.is(result)).toBe(true);
+        assert.isTrue(NonZeroUint16.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).not.toBe(0);
       }

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

@@ -81,41 +81,41 @@ describe('NonZeroUint32 test', () => {
 
   describe(isNonZeroUint32, () => {
     test('correctly identifies non-zero uint32 values', () => {
-      expect(isNonZeroUint32(1)).toBe(true);
+      assert.isTrue(isNonZeroUint32(1));
 
-      expect(isNonZeroUint32(1000)).toBe(true);
+      assert.isTrue(isNonZeroUint32(1000));
 
-      expect(isNonZeroUint32(4_294_967_295)).toBe(true);
+      assert.isTrue(isNonZeroUint32(4_294_967_295));
 
-      expect(isNonZeroUint32(2_147_483_648)).toBe(true);
+      assert.isTrue(isNonZeroUint32(2_147_483_648));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroUint32(0)).toBe(false);
+      assert.isFalse(isNonZeroUint32(0));
     });
 
     test('correctly identifies values outside uint32 range', () => {
-      expect(isNonZeroUint32(4_294_967_296)).toBe(false);
+      assert.isFalse(isNonZeroUint32(4_294_967_296));
 
-      expect(isNonZeroUint32(10_000_000_000)).toBe(false);
+      assert.isFalse(isNonZeroUint32(10_000_000_000));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isNonZeroUint32(-1)).toBe(false);
+      assert.isFalse(isNonZeroUint32(-1));
 
-      expect(isNonZeroUint32(-42)).toBe(false);
+      assert.isFalse(isNonZeroUint32(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroUint32(Number.NaN)).toBe(false);
+      assert.isFalse(isNonZeroUint32(Number.NaN));
 
-      expect(isNonZeroUint32(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroUint32(Number.POSITIVE_INFINITY));
 
-      expect(isNonZeroUint32(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroUint32(Number.NEGATIVE_INFINITY));
 
-      expect(isNonZeroUint32(1.2)).toBe(false);
+      assert.isFalse(isNonZeroUint32(1.2));
 
-      expect(isNonZeroUint32(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroUint32(-3.4));
     });
   });
 
@@ -213,9 +213,9 @@ describe('NonZeroUint32 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroUint32.is(result)).toBe(true);
+        assert.isTrue(NonZeroUint32.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).not.toBe(0);
       }

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

@@ -73,37 +73,37 @@ describe('PositiveFiniteNumber test', () => {
 
   describe(isPositiveFiniteNumber, () => {
     test('correctly identifies positive finite numbers', () => {
-      expect(isPositiveFiniteNumber(1)).toBe(true);
+      assert.isTrue(isPositiveFiniteNumber(1));
 
-      expect(isPositiveFiniteNumber(3.14)).toBe(true);
+      assert.isTrue(isPositiveFiniteNumber(3.14));
 
-      expect(isPositiveFiniteNumber(0.5)).toBe(true);
+      assert.isTrue(isPositiveFiniteNumber(0.5));
 
-      expect(isPositiveFiniteNumber(Number.MIN_VALUE)).toBe(true);
+      assert.isTrue(isPositiveFiniteNumber(Number.MIN_VALUE));
 
-      expect(isPositiveFiniteNumber(Number.MAX_VALUE)).toBe(true);
+      assert.isTrue(isPositiveFiniteNumber(Number.MAX_VALUE));
     });
 
     test('correctly identifies zero', () => {
-      expect(isPositiveFiniteNumber(0)).toBe(false);
+      assert.isFalse(isPositiveFiniteNumber(0));
 
-      expect(isPositiveFiniteNumber(-0)).toBe(false);
+      assert.isFalse(isPositiveFiniteNumber(-0));
     });
 
     test('correctly identifies negative numbers', () => {
-      expect(isPositiveFiniteNumber(-1)).toBe(false);
+      assert.isFalse(isPositiveFiniteNumber(-1));
 
-      expect(isPositiveFiniteNumber(-0.1)).toBe(false);
+      assert.isFalse(isPositiveFiniteNumber(-0.1));
 
-      expect(isPositiveFiniteNumber(-Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(isPositiveFiniteNumber(-Number.MAX_VALUE));
     });
 
     test('correctly identifies non-finite numbers', () => {
-      expect(isPositiveFiniteNumber(Number.NaN)).toBe(false);
+      assert.isFalse(isPositiveFiniteNumber(Number.NaN));
 
-      expect(isPositiveFiniteNumber(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveFiniteNumber(Number.POSITIVE_INFINITY));
 
-      expect(isPositiveFiniteNumber(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveFiniteNumber(Number.NEGATIVE_INFINITY));
     });
   });
 
@@ -219,7 +219,7 @@ describe('PositiveFiniteNumber test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(PositiveFiniteNumber.is(result)).toBe(true);
+        assert.isTrue(PositiveFiniteNumber.is(result));
 
         expect(result).toBeGreaterThan(0);
       }

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

@@ -38,11 +38,11 @@ const {
  * @example
  *
  * ```ts
- * assert.ok(isPositiveInt(5));
+ * assert.isTrue(isPositiveInt(5));
  *
- * assert.notOk(isPositiveInt(0));
+ * assert.isFalse(isPositiveInt(0));
  *
- * assert.ok(PositiveInt.is(10));
+ * assert.isTrue(PositiveInt.is(10));
  * ```
  *
  * @param value - The value to check
@@ -62,9 +62,9 @@ export const isPositiveInt = is;
  * ```ts
  * const branded = asPositiveInt(7);
  *
- * assert(branded === 7);
+ * assert.isTrue(branded === 7);
  *
- * assert.ok(PositiveInt.is(branded));
+ * assert.isTrue(PositiveInt.is(branded));
  * ```
  *
  * @param value - The value to cast
@@ -96,11 +96,11 @@ export const PositiveInt = {
    * @example
    *
    * ```ts
-   * assert.ok(isPositiveInt(5));
+   * assert.isTrue(isPositiveInt(5));
    *
-   * assert.notOk(isPositiveInt(0));
+   * assert.isFalse(isPositiveInt(0));
    *
-   * assert.ok(PositiveInt.is(10));
+   * assert.isTrue(PositiveInt.is(10));
    * ```
    *
    * @param value - The value to check
@@ -131,7 +131,7 @@ export const PositiveInt = {
    *   asPositiveInt(12),
    * );
    *
-   * assert(smallest === 3);
+   * assert.isTrue(smallest === 3);
    * ```
    *
    * @param values - The positive integers to compare (at least one required)
@@ -151,7 +151,7 @@ export const PositiveInt = {
    *   asPositiveInt(12),
    * );
    *
-   * assert(largest === 12);
+   * assert.isTrue(largest === 12);
    * ```
    *
    * @param values - The positive integers to compare (at least one required)
@@ -172,9 +172,9 @@ export const PositiveInt = {
    *
    * const withinRange = PositiveInt.clamp(10);
    *
-   * assert(belowRange === 1);
+   * assert.isTrue(belowRange === 1);
    *
-   * assert(withinRange === 10);
+   * assert.isTrue(withinRange === 10);
    * ```
    *
    * @param value - The number to clamp
@@ -197,9 +197,9 @@ export const PositiveInt = {
    *
    * const randomValue = PositiveInt.random(min, max);
    *
-   * assert.ok(PositiveInt.is(randomValue));
+   * assert.isTrue(PositiveInt.is(randomValue));
    *
-   * assert.ok(randomValue >= 3 && randomValue <= 6);
+   * assert.isTrue(randomValue >= 3 && randomValue <= 6);
    * ```
    *
    * @param min - The minimum value (inclusive, must be >= 1)
@@ -221,7 +221,7 @@ export const PositiveInt = {
    *
    * const power = PositiveInt.pow(base, exponent);
    *
-   * assert(power === 16);
+   * assert.isTrue(power === 16);
    * ```
    *
    * @param a - The base positive integer
@@ -238,7 +238,7 @@ export const PositiveInt = {
    * ```ts
    * const sum = PositiveInt.add(asPositiveInt(4), asPositiveInt(5));
    *
-   * assert(sum === 9);
+   * assert.isTrue(sum === 9);
    * ```
    *
    * @param a - First positive integer
@@ -258,7 +258,7 @@ export const PositiveInt = {
    * ```ts
    * const difference = PositiveInt.sub(asPositiveInt(5), asPositiveInt(7));
    *
-   * assert(difference === 1);
+   * assert.isTrue(difference === 1);
    * ```
    *
    * @param a - The minuend (positive integer)
@@ -275,7 +275,7 @@ export const PositiveInt = {
    * ```ts
    * const product = PositiveInt.mul(asPositiveInt(3), asPositiveInt(7));
    *
-   * assert(product === 21);
+   * assert.isTrue(product === 21);
    * ```
    *
    * @param a - First positive integer
@@ -299,9 +299,9 @@ export const PositiveInt = {
    *
    * const clamped = PositiveInt.div(asPositiveInt(3), asPositiveInt(10));
    *
-   * assert(quotient === 4);
+   * assert.isTrue(quotient === 4);
    *
-   * assert(clamped === 1);
+   * assert.isTrue(clamped === 1);
    * ```
    *
    * @param a - The dividend (positive integer)