ts-data-forge 5.0.1 → 5.1.1

package/dist/number/branded-types/int.d.mts

@@ -9,9 +9,11 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
  * @example
  *
  * ```ts
- * assert.ok(isInt(5));
- * assert.notOk(isInt(5.25));
- * assert.ok(Int.is(-10));
+ * assert.isTrue(isInt(5));
+ *
+ * assert.isFalse(isInt(5.25));
+ *
+ * assert.isTrue(Int.is(-10));
  * ```
  *
  * @param value - The value to check
@@ -30,8 +32,9 @@ export declare const isInt: (a: number) => a is Int;
  * ```ts
  * const branded = asInt(42);
  *
- * assert(branded === 42);
- * assert.ok(Int.is(branded));
+ * assert.isTrue(branded === 42);
+ *
+ * assert.isTrue(Int.is(branded));
  * ```
  *
  * @param value - The value to cast
@@ -63,9 +66,11 @@ export declare const Int: {
      * @example
      *
      * ```ts
-     * assert.ok(isInt(5));
-     * assert.notOk(isInt(5.25));
-     * assert.ok(Int.is(-10));
+     * assert.isTrue(isInt(5));
+     *
+     * assert.isFalse(isInt(5.25));
+     *
+     * assert.isTrue(Int.is(-10));
      * ```
      *
      * @param value - The value to check
@@ -84,10 +89,12 @@ export declare const Int: {
      *
      * ```ts
      * const negative = asInt(-12);
+     *
      * const absolute = Int.abs(negative);
      *
-     * assert(absolute === 12);
-     * assert.ok(Int.is(absolute));
+     * assert.isTrue(absolute === 12);
+     *
+     * assert.isTrue(Int.is(absolute));
      * ```
      *
      * @param a - The integer value
@@ -102,7 +109,7 @@ export declare const Int: {
      * ```ts
      * const smallest = Int.min(asInt(7), asInt(-3), asInt(2));
      *
-     * assert(smallest === -3);
+     * assert.isTrue(smallest === -3);
      * ```
      *
      * @param values - The integers to compare (at least one required)
@@ -117,7 +124,7 @@ export declare const Int: {
      * ```ts
      * const largest = Int.max(asInt(7), asInt(-3), asInt(2));
      *
-     * assert(largest === 7);
+     * assert.isTrue(largest === 7);
      * ```
      *
      * @param values - The integers to compare (at least one required)
@@ -134,11 +141,14 @@ export declare const Int: {
      *
      * ```ts
      * const min = asInt(1);
+     *
      * const max = asInt(6);
+     *
      * const randomValue = Int.random(min, max);
      *
-     * assert.ok(Int.is(randomValue));
-     * assert.ok(randomValue >= 1 && randomValue <= 6);
+     * assert.isTrue(Int.is(randomValue));
+     *
+     * assert.isTrue(randomValue >= 1 && randomValue <= 6);
      * ```
      *
      * @param min - The minimum value (inclusive)
@@ -153,10 +163,12 @@ export declare const Int: {
      *
      * ```ts
      * const base = asInt(2);
+     *
      * const exponent = asInt(5);
+     *
      * const power = Int.pow(base, exponent);
      *
-     * assert(power === 32);
+     * assert.isTrue(power === 32);
      * ```
      *
      * @param a - The base integer
@@ -172,7 +184,7 @@ export declare const Int: {
      * ```ts
      * const sum = Int.add(asInt(12), asInt(8));
      *
-     * assert(sum === 20);
+     * assert.isTrue(sum === 20);
      * ```
      *
      * @param a - First integer
@@ -188,7 +200,7 @@ export declare const Int: {
      * ```ts
      * const difference = Int.sub(asInt(12), asInt(8));
      *
-     * assert(difference === 4);
+     * assert.isTrue(difference === 4);
      * ```
      *
      * @param a - First integer
@@ -204,7 +216,7 @@ export declare const Int: {
      * ```ts
      * const product = Int.mul(asInt(-4), asInt(6));
      *
-     * assert(product === -24);
+     * assert.isTrue(product === -24);
      * ```
      *
      * @param a - First integer
@@ -222,10 +234,12 @@ export declare const Int: {
      *
      * ```ts
      * const dividend = asInt(17);
+     *
      * const divisor = asInt(5);
+     *
      * const quotient = Int.div(dividend, divisor);
      *
-     * assert(quotient === 3);
+     * assert.isTrue(quotient === 3);
      * ```
      *
      * @param a - The dividend

package/dist/number/branded-types/int.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA6BnE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,yBAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA6BnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,yBAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/int.mjs

@@ -17,9 +17,11 @@ const { abs, add, castType, div, is, max: max_, min: min_, mul, pow, random, sub
  * @example
  *
  * ```ts
- * assert.ok(isInt(5));
- * assert.notOk(isInt(5.25));
- * assert.ok(Int.is(-10));
+ * assert.isTrue(isInt(5));
+ *
+ * assert.isFalse(isInt(5.25));
+ *
+ * assert.isTrue(Int.is(-10));
  * ```
  *
  * @param value - The value to check
@@ -38,8 +40,9 @@ const isInt = is;
  * ```ts
  * const branded = asInt(42);
  *
- * assert(branded === 42);
- * assert.ok(Int.is(branded));
+ * assert.isTrue(branded === 42);
+ *
+ * assert.isTrue(Int.is(branded));
  * ```
  *
  * @param value - The value to cast
@@ -65,9 +68,11 @@ const Int = {
      * @example
      *
      * ```ts
-     * assert.ok(isInt(5));
-     * assert.notOk(isInt(5.25));
-     * assert.ok(Int.is(-10));
+     * assert.isTrue(isInt(5));
+     *
+     * assert.isFalse(isInt(5.25));
+     *
+     * assert.isTrue(Int.is(-10));
      * ```
      *
      * @param value - The value to check
@@ -86,10 +91,12 @@ const Int = {
      *
      * ```ts
      * const negative = asInt(-12);
+     *
      * const absolute = Int.abs(negative);
      *
-     * assert(absolute === 12);
-     * assert.ok(Int.is(absolute));
+     * assert.isTrue(absolute === 12);
+     *
+     * assert.isTrue(Int.is(absolute));
      * ```
      *
      * @param a - The integer value
@@ -104,7 +111,7 @@ const Int = {
      * ```ts
      * const smallest = Int.min(asInt(7), asInt(-3), asInt(2));
      *
-     * assert(smallest === -3);
+     * assert.isTrue(smallest === -3);
      * ```
      *
      * @param values - The integers to compare (at least one required)
@@ -119,7 +126,7 @@ const Int = {
      * ```ts
      * const largest = Int.max(asInt(7), asInt(-3), asInt(2));
      *
-     * assert(largest === 7);
+     * assert.isTrue(largest === 7);
      * ```
      *
      * @param values - The integers to compare (at least one required)
@@ -136,11 +143,14 @@ const Int = {
      *
      * ```ts
      * const min = asInt(1);
+     *
      * const max = asInt(6);
+     *
      * const randomValue = Int.random(min, max);
      *
-     * assert.ok(Int.is(randomValue));
-     * assert.ok(randomValue >= 1 && randomValue <= 6);
+     * assert.isTrue(Int.is(randomValue));
+     *
+     * assert.isTrue(randomValue >= 1 && randomValue <= 6);
      * ```
      *
      * @param min - The minimum value (inclusive)
@@ -155,10 +165,12 @@ const Int = {
      *
      * ```ts
      * const base = asInt(2);
+     *
      * const exponent = asInt(5);
+     *
      * const power = Int.pow(base, exponent);
      *
-     * assert(power === 32);
+     * assert.isTrue(power === 32);
      * ```
      *
      * @param a - The base integer
@@ -174,7 +186,7 @@ const Int = {
      * ```ts
      * const sum = Int.add(asInt(12), asInt(8));
      *
-     * assert(sum === 20);
+     * assert.isTrue(sum === 20);
      * ```
      *
      * @param a - First integer
@@ -190,7 +202,7 @@ const Int = {
      * ```ts
      * const difference = Int.sub(asInt(12), asInt(8));
      *
-     * assert(difference === 4);
+     * assert.isTrue(difference === 4);
      * ```
      *
      * @param a - First integer
@@ -206,7 +218,7 @@ const Int = {
      * ```ts
      * const product = Int.mul(asInt(-4), asInt(6));
      *
-     * assert(product === -24);
+     * assert.isTrue(product === -24);
      * ```
      *
      * @param a - First integer
@@ -224,10 +236,12 @@ const Int = {
      *
      * ```ts
      * const dividend = asInt(17);
+     *
      * const divisor = asInt(5);
+     *
      * const quotient = Int.div(dividend, divisor);
      *
-     * assert(quotient === 3);
+     * assert.isTrue(quotient === 3);
      * ```
      *
      * @param a - The dividend

package/dist/number/branded-types/int.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,MAAM,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;AAUG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;;;;;;;;AAcG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,MAAM,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;AAUG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;AAEH;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/non-zero-safe-int.mjs

@@ -4,9 +4,9 @@ const typeNameInMessage = 'a non-zero safe integer';
 const { MAX_VALUE, MIN_VALUE, abs, add, castType, clamp, div, is, max: max_, min: min_, mul, pow, randomNonZero: random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     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,
-    // 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,
     typeNameInMessage,
 });

package/dist/number/branded-types/positive-int.d.mts

@@ -7,9 +7,11 @@
  * @example
  *
  * ```ts
- * assert.ok(isPositiveInt(5));
- * assert.notOk(isPositiveInt(0));
- * assert.ok(PositiveInt.is(10));
+ * assert.isTrue(isPositiveInt(5));
+ *
+ * assert.isFalse(isPositiveInt(0));
+ *
+ * assert.isTrue(PositiveInt.is(10));
  * ```
  *
  * @param value - The value to check
@@ -28,8 +30,9 @@ export declare const isPositiveInt: (a: number) => a is PositiveInt;
  * ```ts
  * const branded = asPositiveInt(7);
  *
- * assert(branded === 7);
- * assert.ok(PositiveInt.is(branded));
+ * assert.isTrue(branded === 7);
+ *
+ * assert.isTrue(PositiveInt.is(branded));
  * ```
  *
  * @param value - The value to cast
@@ -72,9 +75,11 @@ export declare const PositiveInt: {
      * @example
      *
      * ```ts
-     * assert.ok(isPositiveInt(5));
-     * assert.notOk(isPositiveInt(0));
-     * assert.ok(PositiveInt.is(10));
+     * assert.isTrue(isPositiveInt(5));
+     *
+     * assert.isFalse(isPositiveInt(0));
+     *
+     * assert.isTrue(PositiveInt.is(10));
      * ```
      *
      * @param value - The value to check
@@ -103,7 +108,7 @@ export declare const PositiveInt: {
      *   asPositiveInt(12),
      * );
      *
-     * assert(smallest === 3);
+     * assert.isTrue(smallest === 3);
      * ```
      *
      * @param values - The positive integers to compare (at least one required)
@@ -122,7 +127,7 @@ export declare const PositiveInt: {
      *   asPositiveInt(12),
      * );
      *
-     * assert(largest === 12);
+     * assert.isTrue(largest === 12);
      * ```
      *
      * @param values - The positive integers to compare (at least one required)
@@ -139,10 +144,12 @@ export declare const PositiveInt: {
      *
      * ```ts
      * const belowRange = PositiveInt.clamp(0);
+     *
      * const withinRange = PositiveInt.clamp(10);
      *
-     * assert(belowRange === 1);
-     * assert(withinRange === 10);
+     * assert.isTrue(belowRange === 1);
+     *
+     * assert.isTrue(withinRange === 10);
      * ```
      *
      * @param value - The number to clamp
@@ -159,11 +166,14 @@ export declare const PositiveInt: {
      *
      * ```ts
      * const min = asPositiveInt(3);
+     *
      * const max = asPositiveInt(6);
+     *
      * const randomValue = PositiveInt.random(min, max);
      *
-     * assert.ok(PositiveInt.is(randomValue));
-     * assert.ok(randomValue >= 3 && randomValue <= 6);
+     * assert.isTrue(PositiveInt.is(randomValue));
+     *
+     * assert.isTrue(randomValue >= 3 && randomValue <= 6);
      * ```
      *
      * @param min - The minimum value (inclusive, must be >= 1)
@@ -179,10 +189,12 @@ export declare const PositiveInt: {
      *
      * ```ts
      * const base = asPositiveInt(2);
+     *
      * const exponent = asPositiveInt(4);
+     *
      * const power = PositiveInt.pow(base, exponent);
      *
-     * assert(power === 16);
+     * assert.isTrue(power === 16);
      * ```
      *
      * @param a - The base positive integer
@@ -198,7 +210,7 @@ export declare const PositiveInt: {
      * ```ts
      * const sum = PositiveInt.add(asPositiveInt(4), asPositiveInt(5));
      *
-     * assert(sum === 9);
+     * assert.isTrue(sum === 9);
      * ```
      *
      * @param a - First positive integer
@@ -217,7 +229,7 @@ export declare const PositiveInt: {
      * ```ts
      * const difference = PositiveInt.sub(asPositiveInt(5), asPositiveInt(7));
      *
-     * assert(difference === 1);
+     * assert.isTrue(difference === 1);
      * ```
      *
      * @param a - The minuend (positive integer)
@@ -233,7 +245,7 @@ export declare const PositiveInt: {
      * ```ts
      * const product = PositiveInt.mul(asPositiveInt(3), asPositiveInt(7));
      *
-     * assert(product === 21);
+     * assert.isTrue(product === 21);
      * ```
      *
      * @param a - First positive integer
@@ -253,10 +265,12 @@ export declare const PositiveInt: {
      *
      * ```ts
      * const quotient = PositiveInt.div(asPositiveInt(9), asPositiveInt(2));
+     *
      * const clamped = PositiveInt.div(asPositiveInt(3), asPositiveInt(10));
      *
-     * assert(quotient === 4);
-     * assert(clamped === 1);
+     * assert.isTrue(quotient === 4);
+     *
+     * assert.isTrue(clamped === 1);
      * ```
      *
      * @param a - The dividend (positive integer)

package/dist/number/branded-types/positive-int.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"positive-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int.mts"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,iCAAK,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;;;;;;;;;OAcG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int.mts"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,iCAAK,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/positive-int.mjs

@@ -16,9 +16,11 @@ const { MIN_VALUE, add, castType, clamp, div, is, max: max_, min: min_, mul, pow
  * @example
  *
  * ```ts
- * assert.ok(isPositiveInt(5));
- * assert.notOk(isPositiveInt(0));
- * assert.ok(PositiveInt.is(10));
+ * assert.isTrue(isPositiveInt(5));
+ *
+ * assert.isFalse(isPositiveInt(0));
+ *
+ * assert.isTrue(PositiveInt.is(10));
  * ```
  *
  * @param value - The value to check
@@ -37,8 +39,9 @@ const isPositiveInt = is;
  * ```ts
  * const branded = asPositiveInt(7);
  *
- * assert(branded === 7);
- * assert.ok(PositiveInt.is(branded));
+ * assert.isTrue(branded === 7);
+ *
+ * assert.isTrue(PositiveInt.is(branded));
  * ```
  *
  * @param value - The value to cast
@@ -69,9 +72,11 @@ const PositiveInt = {
      * @example
      *
      * ```ts
-     * assert.ok(isPositiveInt(5));
-     * assert.notOk(isPositiveInt(0));
-     * assert.ok(PositiveInt.is(10));
+     * assert.isTrue(isPositiveInt(5));
+     *
+     * assert.isFalse(isPositiveInt(0));
+     *
+     * assert.isTrue(PositiveInt.is(10));
      * ```
      *
      * @param value - The value to check
@@ -100,7 +105,7 @@ const PositiveInt = {
      *   asPositiveInt(12),
      * );
      *
-     * assert(smallest === 3);
+     * assert.isTrue(smallest === 3);
      * ```
      *
      * @param values - The positive integers to compare (at least one required)
@@ -119,7 +124,7 @@ const PositiveInt = {
      *   asPositiveInt(12),
      * );
      *
-     * assert(largest === 12);
+     * assert.isTrue(largest === 12);
      * ```
      *
      * @param values - The positive integers to compare (at least one required)
@@ -136,10 +141,12 @@ const PositiveInt = {
      *
      * ```ts
      * const belowRange = PositiveInt.clamp(0);
+     *
      * const withinRange = PositiveInt.clamp(10);
      *
-     * assert(belowRange === 1);
-     * assert(withinRange === 10);
+     * assert.isTrue(belowRange === 1);
+     *
+     * assert.isTrue(withinRange === 10);
      * ```
      *
      * @param value - The number to clamp
@@ -156,11 +163,14 @@ const PositiveInt = {
      *
      * ```ts
      * const min = asPositiveInt(3);
+     *
      * const max = asPositiveInt(6);
+     *
      * const randomValue = PositiveInt.random(min, max);
      *
-     * assert.ok(PositiveInt.is(randomValue));
-     * assert.ok(randomValue >= 3 && randomValue <= 6);
+     * assert.isTrue(PositiveInt.is(randomValue));
+     *
+     * assert.isTrue(randomValue >= 3 && randomValue <= 6);
      * ```
      *
      * @param min - The minimum value (inclusive, must be >= 1)
@@ -176,10 +186,12 @@ const PositiveInt = {
      *
      * ```ts
      * const base = asPositiveInt(2);
+     *
      * const exponent = asPositiveInt(4);
+     *
      * const power = PositiveInt.pow(base, exponent);
      *
-     * assert(power === 16);
+     * assert.isTrue(power === 16);
      * ```
      *
      * @param a - The base positive integer
@@ -195,7 +207,7 @@ const PositiveInt = {
      * ```ts
      * const sum = PositiveInt.add(asPositiveInt(4), asPositiveInt(5));
      *
-     * assert(sum === 9);
+     * assert.isTrue(sum === 9);
      * ```
      *
      * @param a - First positive integer
@@ -214,7 +226,7 @@ const PositiveInt = {
      * ```ts
      * const difference = PositiveInt.sub(asPositiveInt(5), asPositiveInt(7));
      *
-     * assert(difference === 1);
+     * assert.isTrue(difference === 1);
      * ```
      *
      * @param a - The minuend (positive integer)
@@ -230,7 +242,7 @@ const PositiveInt = {
      * ```ts
      * const product = PositiveInt.mul(asPositiveInt(3), asPositiveInt(7));
      *
-     * assert(product === 21);
+     * assert.isTrue(product === 21);
      * ```
      *
      * @param a - First positive integer
@@ -250,10 +262,12 @@ const PositiveInt = {
      *
      * ```ts
      * const quotient = PositiveInt.div(asPositiveInt(9), asPositiveInt(2));
+     *
      * const clamped = PositiveInt.div(asPositiveInt(3), asPositiveInt(10));
      *
-     * assert(quotient === 4);
-     * assert(clamped === 1);
+     * assert.isTrue(quotient === 4);
+     *
+     * assert.isTrue(clamped === 1);
      * ```
      *
      * @param a - The dividend (positive integer)

package/dist/number/branded-types/positive-int.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"positive-int.mjs","sources":["../../../src/number/branded-types/positive-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;AAeG;AACI,MAAM,WAAW,GAAG;AACzB;;;;;;;;;;;;;;AAcG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;AAkBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;AAiBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;AAiBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"positive-int.mjs","sources":["../../../src/number/branded-types/positive-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,aAAa,GAAG;AAE7B;;;;;;;;;;;;;;;AAeG;AACI,MAAM,WAAW,GAAG;AACzB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;AAiBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,GAAG;;;;;"}