ts-data-forge 5.0.1 → 5.1.1

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

@@ -5,10 +5,13 @@
  * @example
  *
  * ```ts
- * assert.ok(isPositiveSafeInt(1));
- * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
- * assert.notOk(isPositiveSafeInt(0));
- * assert.ok(PositiveSafeInt.is(42));
+ * assert.isTrue(isPositiveSafeInt(1));
+ *
+ * assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+ *
+ * assert.isFalse(isPositiveSafeInt(0));
+ *
+ * assert.isTrue(PositiveSafeInt.is(42));
  * ```
  *
  * @param value The value to check.
@@ -23,8 +26,9 @@ export declare const isPositiveSafeInt: (a: number) => a is PositiveSafeInt;
  * ```ts
  * const branded = asPositiveSafeInt(128);
  *
- * assert(branded === 128);
- * assert.ok(PositiveSafeInt.is(branded));
+ * assert.isTrue(branded === 128);
+ *
+ * assert.isTrue(PositiveSafeInt.is(branded));
  * ```
  *
  * @param value The value to cast.
@@ -61,10 +65,13 @@ export declare const PositiveSafeInt: {
      * @example
      *
      * ```ts
-     * assert.ok(isPositiveSafeInt(1));
-     * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
-     * assert.notOk(isPositiveSafeInt(0));
-     * assert.ok(PositiveSafeInt.is(42));
+     * assert.isTrue(isPositiveSafeInt(1));
+     *
+     * assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+     *
+     * assert.isFalse(isPositiveSafeInt(0));
+     *
+     * assert.isTrue(PositiveSafeInt.is(42));
      * ```
      *
      * @param value The value to check.
@@ -95,7 +102,7 @@ export declare const PositiveSafeInt: {
      *   asPositiveSafeInt(5),
      * );
      *
-     * assert(smallest === 5);
+     * assert.isTrue(smallest === 5);
      * ```
      *
      * @param a The first PositiveSafeInt.
@@ -114,7 +121,7 @@ export declare const PositiveSafeInt: {
      *   asPositiveSafeInt(5),
      * );
      *
-     * assert(largest === 10);
+     * assert.isTrue(largest === 10);
      * ```
      *
      * @param a The first PositiveSafeInt.
@@ -129,12 +136,16 @@ export declare const PositiveSafeInt: {
      *
      * ```ts
      * const belowRange = PositiveSafeInt.clamp(0);
+     *
      * const withinRange = PositiveSafeInt.clamp(123);
+     *
      * const aboveRange = PositiveSafeInt.clamp(Number.MAX_SAFE_INTEGER + 10);
      *
-     * assert(belowRange === 1);
-     * assert(withinRange === 123);
-     * assert(aboveRange === Number.MAX_SAFE_INTEGER);
+     * assert.isTrue(belowRange === 1);
+     *
+     * assert.isTrue(withinRange === 123);
+     *
+     * assert.isTrue(aboveRange === Number.MAX_SAFE_INTEGER);
      * ```
      *
      * @param value The number to clamp.
@@ -148,11 +159,14 @@ export declare const PositiveSafeInt: {
      *
      * ```ts
      * const min = asPositiveSafeInt(1);
+     *
      * const max = asPositiveSafeInt(6);
+     *
      * const randomValue = PositiveSafeInt.random(min, max);
      *
-     * assert.ok(PositiveSafeInt.is(randomValue));
-     * assert.ok(randomValue >= 1 && randomValue <= 6);
+     * assert.isTrue(PositiveSafeInt.is(randomValue));
+     *
+     * assert.isTrue(randomValue >= 1 && randomValue <= 6);
      * ```
      *
      * @returns A random PositiveSafeInt between 1 and MAX_SAFE_INTEGER.
@@ -165,10 +179,12 @@ export declare const PositiveSafeInt: {
      *
      * ```ts
      * const base = asPositiveSafeInt(3);
+     *
      * const exponent = asPositiveSafeInt(3);
+     *
      * const power = PositiveSafeInt.pow(base, exponent);
      *
-     * assert(power === 27);
+     * assert.isTrue(power === 27);
      * ```
      *
      * @param a The base PositiveSafeInt.
@@ -187,8 +203,9 @@ export declare const PositiveSafeInt: {
      *   asPositiveSafeInt(2048),
      * );
      *
-     * assert(sum === 3048);
-     * assert.ok(PositiveSafeInt.is(sum));
+     * assert.isTrue(sum === 3048);
+     *
+     * assert.isTrue(PositiveSafeInt.is(sum));
      * ```
      *
      * @param a The first PositiveSafeInt.
@@ -207,8 +224,9 @@ export declare const PositiveSafeInt: {
      *   asPositiveSafeInt(20),
      * );
      *
-     * assert(difference === 1);
-     * assert.ok(PositiveSafeInt.is(difference));
+     * assert.isTrue(difference === 1);
+     *
+     * assert.isTrue(PositiveSafeInt.is(difference));
      * ```
      *
      * @param a The minuend PositiveSafeInt.
@@ -228,8 +246,9 @@ export declare const PositiveSafeInt: {
      *   asPositiveSafeInt(20),
      * );
      *
-     * assert(product === 1000);
-     * assert.ok(PositiveSafeInt.is(product));
+     * assert.isTrue(product === 1000);
+     *
+     * assert.isTrue(PositiveSafeInt.is(product));
      * ```
      *
      * @param a The first PositiveSafeInt.
@@ -247,13 +266,15 @@ export declare const PositiveSafeInt: {
      *   asPositiveSafeInt(25),
      *   asPositiveSafeInt(4),
      * );
+     *
      * const clamped = PositiveSafeInt.div(
      *   asPositiveSafeInt(5),
      *   asPositiveSafeInt(50),
      * );
      *
-     * assert(quotient === 6);
-     * assert(clamped === 1);
+     * assert.isTrue(quotient === 6);
+     *
+     * assert.isTrue(clamped === 1);
      * ```
      *
      * @param a The dividend PositiveSafeInt.

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

@@ -1 +1 @@
-{"version":3,"file":"positive-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,qCAAK,CAAC;AAEpC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;;;;;;;;;;OAeG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,iBAAiB,qCAAK,CAAC;AAEpC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -4,7 +4,7 @@ const typeNameInMessage = 'a positive safe integer';
 const { MAX_VALUE, MIN_VALUE, add, castType, clamp, div, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'SafeInteger',
     MIN_VALUE: 1,
-    // 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,
 });
@@ -15,10 +15,13 @@ const { MAX_VALUE, MIN_VALUE, add, castType, clamp, div, is, max: max_, min: min
  * @example
  *
  * ```ts
- * assert.ok(isPositiveSafeInt(1));
- * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
- * assert.notOk(isPositiveSafeInt(0));
- * assert.ok(PositiveSafeInt.is(42));
+ * assert.isTrue(isPositiveSafeInt(1));
+ *
+ * assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+ *
+ * assert.isFalse(isPositiveSafeInt(0));
+ *
+ * assert.isTrue(PositiveSafeInt.is(42));
  * ```
  *
  * @param value The value to check.
@@ -33,8 +36,9 @@ const isPositiveSafeInt = is;
  * ```ts
  * const branded = asPositiveSafeInt(128);
  *
- * assert(branded === 128);
- * assert.ok(PositiveSafeInt.is(branded));
+ * assert.isTrue(branded === 128);
+ *
+ * assert.isTrue(PositiveSafeInt.is(branded));
  * ```
  *
  * @param value The value to cast.
@@ -58,10 +62,13 @@ const PositiveSafeInt = {
      * @example
      *
      * ```ts
-     * assert.ok(isPositiveSafeInt(1));
-     * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
-     * assert.notOk(isPositiveSafeInt(0));
-     * assert.ok(PositiveSafeInt.is(42));
+     * assert.isTrue(isPositiveSafeInt(1));
+     *
+     * assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+     *
+     * assert.isFalse(isPositiveSafeInt(0));
+     *
+     * assert.isTrue(PositiveSafeInt.is(42));
      * ```
      *
      * @param value The value to check.
@@ -92,7 +99,7 @@ const PositiveSafeInt = {
      *   asPositiveSafeInt(5),
      * );
      *
-     * assert(smallest === 5);
+     * assert.isTrue(smallest === 5);
      * ```
      *
      * @param a The first PositiveSafeInt.
@@ -111,7 +118,7 @@ const PositiveSafeInt = {
      *   asPositiveSafeInt(5),
      * );
      *
-     * assert(largest === 10);
+     * assert.isTrue(largest === 10);
      * ```
      *
      * @param a The first PositiveSafeInt.
@@ -126,12 +133,16 @@ const PositiveSafeInt = {
      *
      * ```ts
      * const belowRange = PositiveSafeInt.clamp(0);
+     *
      * const withinRange = PositiveSafeInt.clamp(123);
+     *
      * const aboveRange = PositiveSafeInt.clamp(Number.MAX_SAFE_INTEGER + 10);
      *
-     * assert(belowRange === 1);
-     * assert(withinRange === 123);
-     * assert(aboveRange === Number.MAX_SAFE_INTEGER);
+     * assert.isTrue(belowRange === 1);
+     *
+     * assert.isTrue(withinRange === 123);
+     *
+     * assert.isTrue(aboveRange === Number.MAX_SAFE_INTEGER);
      * ```
      *
      * @param value The number to clamp.
@@ -145,11 +156,14 @@ const PositiveSafeInt = {
      *
      * ```ts
      * const min = asPositiveSafeInt(1);
+     *
      * const max = asPositiveSafeInt(6);
+     *
      * const randomValue = PositiveSafeInt.random(min, max);
      *
-     * assert.ok(PositiveSafeInt.is(randomValue));
-     * assert.ok(randomValue >= 1 && randomValue <= 6);
+     * assert.isTrue(PositiveSafeInt.is(randomValue));
+     *
+     * assert.isTrue(randomValue >= 1 && randomValue <= 6);
      * ```
      *
      * @returns A random PositiveSafeInt between 1 and MAX_SAFE_INTEGER.
@@ -162,10 +176,12 @@ const PositiveSafeInt = {
      *
      * ```ts
      * const base = asPositiveSafeInt(3);
+     *
      * const exponent = asPositiveSafeInt(3);
+     *
      * const power = PositiveSafeInt.pow(base, exponent);
      *
-     * assert(power === 27);
+     * assert.isTrue(power === 27);
      * ```
      *
      * @param a The base PositiveSafeInt.
@@ -184,8 +200,9 @@ const PositiveSafeInt = {
      *   asPositiveSafeInt(2048),
      * );
      *
-     * assert(sum === 3048);
-     * assert.ok(PositiveSafeInt.is(sum));
+     * assert.isTrue(sum === 3048);
+     *
+     * assert.isTrue(PositiveSafeInt.is(sum));
      * ```
      *
      * @param a The first PositiveSafeInt.
@@ -204,8 +221,9 @@ const PositiveSafeInt = {
      *   asPositiveSafeInt(20),
      * );
      *
-     * assert(difference === 1);
-     * assert.ok(PositiveSafeInt.is(difference));
+     * assert.isTrue(difference === 1);
+     *
+     * assert.isTrue(PositiveSafeInt.is(difference));
      * ```
      *
      * @param a The minuend PositiveSafeInt.
@@ -225,8 +243,9 @@ const PositiveSafeInt = {
      *   asPositiveSafeInt(20),
      * );
      *
-     * assert(product === 1000);
-     * assert.ok(PositiveSafeInt.is(product));
+     * assert.isTrue(product === 1000);
+     *
+     * assert.isTrue(PositiveSafeInt.is(product));
      * ```
      *
      * @param a The first PositiveSafeInt.
@@ -244,13 +263,15 @@ const PositiveSafeInt = {
      *   asPositiveSafeInt(25),
      *   asPositiveSafeInt(4),
      * );
+     *
      * const clamped = PositiveSafeInt.div(
      *   asPositiveSafeInt(5),
      *   asPositiveSafeInt(50),
      * );
      *
-     * assert(quotient === 6);
-     * assert(clamped === 1);
+     * assert.isTrue(quotient === 6);
+     *
+     * assert.isTrue(clamped === 1);
      * ```
      *
      * @param a The dividend PositiveSafeInt.

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

@@ -1 +1 @@
-{"version":3,"file":"positive-safe-int.mjs","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,yBAAyB;AAEnD,MAAM,EACJ,SAAS,EACT,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,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;;IAEZ,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;AAeG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;;;;;;;;AAeG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;AAQG;AACI,MAAM,eAAe,GAAG;AAC7B;;;;;;;;;;;;;;;AAeG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;AAeG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;AAsBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"positive-safe-int.mjs","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,yBAAyB;AAEnD,MAAM,EACJ,SAAS,EACT,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,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;;IAEZ,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,iBAAiB,GAAG;AAEjC;;;;;;;;AAQG;AACI,MAAM,eAAe,GAAG;AAC7B;;;;;;;;;;;;;;;;;;AAkBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;AAkBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,GAAG;;;;;"}

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

@@ -8,9 +8,11 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
  * @example
  *
  * ```ts
- * assert.ok(isSafeInt(Number.MAX_SAFE_INTEGER));
- * assert.notOk(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
- * assert.ok(SafeInt.is(Number.MIN_SAFE_INTEGER));
+ * assert.isTrue(isSafeInt(Number.MAX_SAFE_INTEGER));
+ *
+ * assert.isFalse(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
+ *
+ * assert.isTrue(SafeInt.is(Number.MIN_SAFE_INTEGER));
  * ```
  *
  * @param value - The value to check
@@ -29,8 +31,9 @@ export declare const isSafeInt: (a: number) => a is SafeInt;
  * ```ts
  * const branded = asSafeInt(123);
  *
- * assert(branded === 123);
- * assert.ok(SafeInt.is(branded));
+ * assert.isTrue(branded === 123);
+ *
+ * assert.isTrue(SafeInt.is(branded));
  * ```
  *
  * @param value - The value to cast
@@ -68,9 +71,11 @@ export declare const SafeInt: {
      * @example
      *
      * ```ts
-     * assert.ok(isSafeInt(Number.MAX_SAFE_INTEGER));
-     * assert.notOk(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
-     * assert.ok(SafeInt.is(Number.MIN_SAFE_INTEGER));
+     * assert.isTrue(isSafeInt(Number.MAX_SAFE_INTEGER));
+     *
+     * assert.isFalse(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
+     *
+     * assert.isTrue(SafeInt.is(Number.MIN_SAFE_INTEGER));
      * ```
      *
      * @param value - The value to check
@@ -100,10 +105,12 @@ export declare const SafeInt: {
      *
      * ```ts
      * const negative = asSafeInt(-900);
+     *
      * const absolute = SafeInt.abs(negative);
      *
-     * assert(absolute === 900);
-     * assert.ok(SafeInt.is(absolute));
+     * assert.isTrue(absolute === 900);
+     *
+     * assert.isTrue(SafeInt.is(absolute));
      * ```
      *
      * @param a - The safe integer value
@@ -118,7 +125,7 @@ export declare const SafeInt: {
      * ```ts
      * const smallest = SafeInt.min(asSafeInt(25), asSafeInt(-14), asSafeInt(99));
      *
-     * assert(smallest === -14);
+     * assert.isTrue(smallest === -14);
      * ```
      *
      * @param values - The safe integers to compare (at least one required)
@@ -133,7 +140,7 @@ export declare const SafeInt: {
      * ```ts
      * const largest = SafeInt.max(asSafeInt(25), asSafeInt(-14), asSafeInt(99));
      *
-     * assert(largest === 99);
+     * assert.isTrue(largest === 99);
      * ```
      *
      * @param values - The safe integers to compare (at least one required)
@@ -147,12 +154,16 @@ export declare const SafeInt: {
      *
      * ```ts
      * const aboveRange = SafeInt.clamp(1e20);
+     *
      * const withinRange = SafeInt.clamp(123);
+     *
      * const belowRange = SafeInt.clamp(-1e20);
      *
-     * assert(aboveRange === Number.MAX_SAFE_INTEGER);
-     * assert(withinRange === 123);
-     * assert(belowRange === Number.MIN_SAFE_INTEGER);
+     * assert.isTrue(aboveRange === Number.MAX_SAFE_INTEGER);
+     *
+     * assert.isTrue(withinRange === 123);
+     *
+     * assert.isTrue(belowRange === Number.MIN_SAFE_INTEGER);
      * ```
      *
      * @param value The number to clamp.
@@ -170,11 +181,14 @@ export declare const SafeInt: {
      *
      * ```ts
      * const min = asSafeInt(-10);
+     *
      * const max = asSafeInt(10);
+     *
      * const randomValue = SafeInt.random(min, max);
      *
-     * assert.ok(SafeInt.is(randomValue));
-     * assert.ok(randomValue >= -10 && randomValue <= 10);
+     * assert.isTrue(SafeInt.is(randomValue));
+     *
+     * assert.isTrue(randomValue >= -10 && randomValue <= 10);
      * ```
      *
      * @param min - The minimum value (inclusive)
@@ -189,11 +203,14 @@ export declare const SafeInt: {
      *
      * ```ts
      * const base = asSafeInt(3);
+     *
      * const exponent = asSafeInt(5);
+     *
      * const power = SafeInt.pow(base, exponent);
      *
-     * assert(power === 243);
-     * assert.ok(SafeInt.is(power));
+     * assert.isTrue(power === 243);
+     *
+     * assert.isTrue(SafeInt.is(power));
      * ```
      *
      * @param a The base SafeInt.
@@ -209,8 +226,9 @@ export declare const SafeInt: {
      * ```ts
      * const sum = SafeInt.add(asSafeInt(9), asSafeInt(4));
      *
-     * assert(sum === 13);
-     * assert.ok(SafeInt.is(sum));
+     * assert.isTrue(sum === 13);
+     *
+     * assert.isTrue(SafeInt.is(sum));
      * ```
      *
      * @param a The first SafeInt.
@@ -226,8 +244,9 @@ export declare const SafeInt: {
      * ```ts
      * const difference = SafeInt.sub(asSafeInt(9), asSafeInt(14));
      *
-     * assert(difference === -5);
-     * assert.ok(SafeInt.is(difference));
+     * assert.isTrue(difference === -5);
+     *
+     * assert.isTrue(SafeInt.is(difference));
      * ```
      *
      * @param a The minuend SafeInt.
@@ -243,8 +262,9 @@ export declare const SafeInt: {
      * ```ts
      * const product = SafeInt.mul(asSafeInt(-8), asSafeInt(7));
      *
-     * assert(product === -56);
-     * assert.ok(SafeInt.is(product));
+     * assert.isTrue(product === -56);
+     *
+     * assert.isTrue(SafeInt.is(product));
      * ```
      *
      * @param a The first SafeInt.
@@ -263,8 +283,9 @@ export declare const SafeInt: {
      * ```ts
      * const quotient = SafeInt.div(asSafeInt(-17), asSafeInt(5));
      *
-     * assert(quotient === -4);
-     * assert.ok(SafeInt.is(quotient));
+     * assert.isTrue(quotient === -4);
+     *
+     * assert.isTrue(SafeInt.is(quotient));
      * ```
      *
      * @param a - The dividend

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

@@ -1 +1 @@
-{"version":3,"file":"safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAkCnE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,SAAS,6BAAK,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,SAAS;;;;;;;MAAW,CAAC;AAElC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,OAAO;IAClB;;;;;;;;;;;;;;OAcG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAkCnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS,6BAAK,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS;;;;;;;MAAW,CAAC;AAElC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,OAAO;IAClB;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;;;;;;;;;CAEK,CAAC"}