ts-data-forge 5.0.1 → 5.1.1

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

@@ -3,9 +3,9 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 const typeNameInMessage = 'a safe integer';
 const { MAX_VALUE, MIN_VALUE, abs, add, castType, clamp, div, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'SafeInteger',
-    // 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,
 });
@@ -18,9 +18,11 @@ const { MAX_VALUE, MIN_VALUE, abs, add, castType, clamp, div, is, max: max_, min
  * @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
@@ -39,8 +41,9 @@ const isSafeInt = is;
  * ```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
@@ -71,9 +74,11 @@ 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
@@ -103,10 +108,12 @@ 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
@@ -121,7 +128,7 @@ 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)
@@ -136,7 +143,7 @@ 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)
@@ -150,12 +157,16 @@ 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.
@@ -173,11 +184,14 @@ 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)
@@ -192,11 +206,14 @@ 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.
@@ -212,8 +229,9 @@ 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.
@@ -229,8 +247,9 @@ 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.
@@ -246,8 +265,9 @@ 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.
@@ -266,8 +286,9 @@ 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.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"safe-int.mjs","sources":["../../../src/number/branded-types/safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,gBAAgB;AAE1C,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,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;;IAEnC,SAAS,EAAE,MAAM,CAAC,gBAA2B;;IAE7C,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,SAAS,GAAG;AAEzB;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,SAAS,GAAG;AAEzB;;;;;;;;;;;;;;;AAeG;AACI,MAAM,OAAO,GAAG;AACrB;;;;;;;;;;;;;;AAcG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;AAkBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;AAiBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;AAeG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;AAeG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;AAeG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"safe-int.mjs","sources":["../../../src/number/branded-types/safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,gBAAgB;AAE1C,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,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;;IAEnC,SAAS,EAAE,MAAM,CAAC,gBAA2B;;IAE7C,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,SAAS,GAAG;AAEzB;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,SAAS,GAAG;AAEzB;;;;;;;;;;;;;;;AAeG;AACI,MAAM,OAAO,GAAG;AACrB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,GAAG;AAEH;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;;AAsBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;AAuBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/safe-uint.mjs

@@ -4,7 +4,7 @@ const typeNameInMessage = 'a non-negative 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: 0,
-    // 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/uint.d.mts

@@ -4,9 +4,11 @@
  * @example
  *
  * ```ts
- * assert.ok(isUint(4));
- * assert.notOk(isUint(-1));
- * assert.ok(Uint.is(0));
+ * assert.isTrue(isUint(4));
+ *
+ * assert.isFalse(isUint(-1));
+ *
+ * assert.isTrue(Uint.is(0));
  * ```
  *
  * @param value The value to check.
@@ -21,8 +23,9 @@ export declare const isUint: (a: number) => a is NonNegativeInt;
  * ```ts
  * const branded = asUint(12);
  *
- * assert(branded === 12);
- * assert.ok(Uint.is(branded));
+ * assert.isTrue(branded === 12);
+ *
+ * assert.isTrue(Uint.is(branded));
  * ```
  *
  * @param value The value to cast.
@@ -55,9 +58,11 @@ export declare const Uint: {
      * @example
      *
      * ```ts
-     * assert.ok(isUint(4));
-     * assert.notOk(isUint(-1));
-     * assert.ok(Uint.is(0));
+     * assert.isTrue(isUint(4));
+     *
+     * assert.isFalse(isUint(-1));
+     *
+     * assert.isTrue(Uint.is(0));
      * ```
      *
      * @param value The value to check.
@@ -79,7 +84,7 @@ export declare const Uint: {
      * ```ts
      * const smallest = Uint.min(asUint(7), asUint(3));
      *
-     * assert(smallest === 3);
+     * assert.isTrue(smallest === 3);
      * ```
      *
      * @param a The first Uint.
@@ -95,7 +100,7 @@ export declare const Uint: {
      * ```ts
      * const largest = Uint.max(asUint(7), asUint(3));
      *
-     * assert(largest === 7);
+     * assert.isTrue(largest === 7);
      * ```
      *
      * @param a The first Uint.
@@ -110,10 +115,12 @@ export declare const Uint: {
      *
      * ```ts
      * const clampedNegative = Uint.clamp(-5);
+     *
      * const clampedPositive = Uint.clamp(42);
      *
-     * assert(clampedNegative === 0);
-     * assert(clampedPositive === 42);
+     * assert.isTrue(clampedNegative === 0);
+     *
+     * assert.isTrue(clampedPositive === 42);
      * ```
      *
      * @param value The number to clamp.
@@ -127,11 +134,14 @@ export declare const Uint: {
      *
      * ```ts
      * const min = asUint(0);
+     *
      * const max = asUint(3);
+     *
      * const randomValue = Uint.random(min, max);
      *
-     * assert.ok(Uint.is(randomValue));
-     * assert.ok(randomValue >= 0 && randomValue <= 3);
+     * assert.isTrue(Uint.is(randomValue));
+     *
+     * assert.isTrue(randomValue >= 0 && randomValue <= 3);
      * ```
      *
      * @returns A random non-negative integer as a Uint.
@@ -144,10 +154,12 @@ export declare const Uint: {
      *
      * ```ts
      * const base = asUint(2);
+     *
      * const exponent = asUint(5);
+     *
      * const power = Uint.pow(base, exponent);
      *
-     * assert(power === 32);
+     * assert.isTrue(power === 32);
      * ```
      *
      * @param a The base Uint.
@@ -163,7 +175,7 @@ export declare const Uint: {
      * ```ts
      * const sum = Uint.add(asUint(5), asUint(8));
      *
-     * assert(sum === 13);
+     * assert.isTrue(sum === 13);
      * ```
      *
      * @param a The first Uint.
@@ -179,7 +191,7 @@ export declare const Uint: {
      * ```ts
      * const difference = Uint.sub(asUint(5), asUint(8));
      *
-     * assert(difference === 0);
+     * assert.isTrue(difference === 0);
      * ```
      *
      * @param a The minuend Uint.
@@ -195,7 +207,7 @@ export declare const Uint: {
      * ```ts
      * const product = Uint.mul(asUint(7), asUint(6));
      *
-     * assert(product === 42);
+     * assert.isTrue(product === 42);
      * ```
      *
      * @param a The first Uint.
@@ -211,7 +223,7 @@ export declare const Uint: {
      * ```ts
      * const quotient = Uint.div(asUint(10), asUint(4));
      *
-     * assert(quotient === 2);
+     * assert.isTrue(quotient === 2);
      * ```
      *
      * @param a The dividend Uint.

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

@@ -1 +1 @@
-{"version":3,"file":"uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint.mts"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,MAAM,oCAAK,CAAC;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;MAAW,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;;;;;;;;OAcG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint.mts"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,oCAAK,CAAC;AAEzB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;MAAW,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -13,9 +13,11 @@ const { MIN_VALUE, add, castType, clamp, div, is, max: max_, min: min_, mul, pow
  * @example
  *
  * ```ts
- * assert.ok(isUint(4));
- * assert.notOk(isUint(-1));
- * assert.ok(Uint.is(0));
+ * assert.isTrue(isUint(4));
+ *
+ * assert.isFalse(isUint(-1));
+ *
+ * assert.isTrue(Uint.is(0));
  * ```
  *
  * @param value The value to check.
@@ -30,8 +32,9 @@ const isUint = is;
  * ```ts
  * const branded = asUint(12);
  *
- * assert(branded === 12);
- * assert.ok(Uint.is(branded));
+ * assert.isTrue(branded === 12);
+ *
+ * assert.isTrue(Uint.is(branded));
  * ```
  *
  * @param value The value to cast.
@@ -53,9 +56,11 @@ const Uint = {
      * @example
      *
      * ```ts
-     * assert.ok(isUint(4));
-     * assert.notOk(isUint(-1));
-     * assert.ok(Uint.is(0));
+     * assert.isTrue(isUint(4));
+     *
+     * assert.isFalse(isUint(-1));
+     *
+     * assert.isTrue(Uint.is(0));
      * ```
      *
      * @param value The value to check.
@@ -77,7 +82,7 @@ const Uint = {
      * ```ts
      * const smallest = Uint.min(asUint(7), asUint(3));
      *
-     * assert(smallest === 3);
+     * assert.isTrue(smallest === 3);
      * ```
      *
      * @param a The first Uint.
@@ -93,7 +98,7 @@ const Uint = {
      * ```ts
      * const largest = Uint.max(asUint(7), asUint(3));
      *
-     * assert(largest === 7);
+     * assert.isTrue(largest === 7);
      * ```
      *
      * @param a The first Uint.
@@ -108,10 +113,12 @@ const Uint = {
      *
      * ```ts
      * const clampedNegative = Uint.clamp(-5);
+     *
      * const clampedPositive = Uint.clamp(42);
      *
-     * assert(clampedNegative === 0);
-     * assert(clampedPositive === 42);
+     * assert.isTrue(clampedNegative === 0);
+     *
+     * assert.isTrue(clampedPositive === 42);
      * ```
      *
      * @param value The number to clamp.
@@ -125,11 +132,14 @@ const Uint = {
      *
      * ```ts
      * const min = asUint(0);
+     *
      * const max = asUint(3);
+     *
      * const randomValue = Uint.random(min, max);
      *
-     * assert.ok(Uint.is(randomValue));
-     * assert.ok(randomValue >= 0 && randomValue <= 3);
+     * assert.isTrue(Uint.is(randomValue));
+     *
+     * assert.isTrue(randomValue >= 0 && randomValue <= 3);
      * ```
      *
      * @returns A random non-negative integer as a Uint.
@@ -142,10 +152,12 @@ const Uint = {
      *
      * ```ts
      * const base = asUint(2);
+     *
      * const exponent = asUint(5);
+     *
      * const power = Uint.pow(base, exponent);
      *
-     * assert(power === 32);
+     * assert.isTrue(power === 32);
      * ```
      *
      * @param a The base Uint.
@@ -161,7 +173,7 @@ const Uint = {
      * ```ts
      * const sum = Uint.add(asUint(5), asUint(8));
      *
-     * assert(sum === 13);
+     * assert.isTrue(sum === 13);
      * ```
      *
      * @param a The first Uint.
@@ -177,7 +189,7 @@ const Uint = {
      * ```ts
      * const difference = Uint.sub(asUint(5), asUint(8));
      *
-     * assert(difference === 0);
+     * assert.isTrue(difference === 0);
      * ```
      *
      * @param a The minuend Uint.
@@ -193,7 +205,7 @@ const Uint = {
      * ```ts
      * const product = Uint.mul(asUint(7), asUint(6));
      *
-     * assert(product === 42);
+     * assert.isTrue(product === 42);
      * ```
      *
      * @param a The first Uint.
@@ -209,7 +221,7 @@ const Uint = {
      * ```ts
      * const quotient = Uint.div(asUint(10), asUint(4));
      *
-     * assert(quotient === 2);
+     * assert.isTrue(quotient === 2);
      * ```
      *
      * @param a The dividend Uint.

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

@@ -1 +1 @@
-{"version":3,"file":"uint.mjs","sources":["../../../src/number/branded-types/uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,wBAAwB;AAElD,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;;;;;;;;;;;;;AAaG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;AAeG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;AAMG;AACI,MAAM,IAAI,GAAG;AAClB;;;;;;;;;;;;;;AAcG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;AAeG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;AAeG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;;;;;"}
+{"version":3,"file":"uint.mjs","sources":["../../../src/number/branded-types/uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,wBAAwB;AAElD,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;;;;;;;;;;;;;;;AAeG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;AAMG;AACI,MAAM,IAAI,GAAG;AAClB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;AAkBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;;;;;"}

package/dist/number/num.d.mts

@@ -24,7 +24,7 @@ export declare namespace Num {
      *
      * const result = Num.from(input);
      *
-     * assert(result === 123.45);
+     * assert.isTrue(result === 123.45);
      * ```
      *
      * @param n The value to convert.
@@ -47,10 +47,11 @@ export declare namespace Num {
      *   // Safe to divide now that we know value is non-zero
      *   // eslint-disable-next-line total-functions/no-partial-division
      *   const inverted = 1 / value;
-     *   assert(inverted === 0.2);
+     *
+     *   assert.isTrue(inverted === 0.2);
      * }
      *
-     * assert.notOk(Num.isNonZero(0));
+     * assert.isFalse(Num.isNonZero(0));
      * ```
      *
      * @template N - The numeric literal type or number type to check
@@ -73,10 +74,11 @@ export declare namespace Num {
      *
      * if (Num.isNonNegative(candidate)) {
      *   const index: number = candidate;
-     *   assert(index === 10);
+     *
+     *   assert.isTrue(index === 10);
      * }
      *
-     * assert.notOk(Num.isNonNegative(-1));
+     * assert.isFalse(Num.isNonNegative(-1));
      * ```
      *
      * @template N - The numeric literal type or number type to check
@@ -97,10 +99,10 @@ export declare namespace Num {
      * const amount = 42;
      *
      * if (Num.isPositive(amount)) {
-     *   assert.ok(amount > 0);
+     *   assert.isTrue(amount > 0);
      * }
      *
-     * assert.notOk(Num.isPositive(0));
+     * assert.isFalse(Num.isPositive(0));
      * ```
      *
      * @template N - The numeric literal type or number type to check
@@ -117,8 +119,9 @@ export declare namespace Num {
      * ```ts
      * const isGrade = Num.isInRange(0, 100);
      *
-     * assert.ok(isGrade(50));
-     * assert.notOk(isGrade(100));
+     * assert.isTrue(isGrade(50));
+     *
+     * assert.isFalse(isGrade(100));
      * ```
      *
      * @param lowerBound The lower bound (inclusive).
@@ -136,8 +139,9 @@ export declare namespace Num {
      * ```ts
      * const isPercentage = Num.isInRangeInclusive(0, 100);
      *
-     * assert.ok(isPercentage(100));
-     * assert.notOk(isPercentage(-1));
+     * assert.isTrue(isPercentage(100));
+     *
+     * assert.isFalse(isPercentage(-1));
      * ```
      *
      * @param lowerBound The lower bound (inclusive).
@@ -189,9 +193,11 @@ export declare namespace Num {
      * ```ts
      * const indexGuard = Num.isUintInRange(0, 5);
      *
-     * assert.ok(indexGuard(3));
-     * assert.notOk(indexGuard(5));
-     * assert.notOk(indexGuard(-1));
+     * assert.isTrue(indexGuard(3));
+     *
+     * assert.isFalse(indexGuard(5));
+     *
+     * assert.isFalse(indexGuard(-1));
      * ```
      *
      * @template L - The lower bound as a SmallUint literal type
@@ -219,8 +225,9 @@ export declare namespace Num {
      * ```ts
      * const inclusiveGuard = Num.isUintInRangeInclusive(0, 5);
      *
-     * assert.ok(inclusiveGuard(5));
-     * assert.notOk(inclusiveGuard(6));
+     * assert.isTrue(inclusiveGuard(5));
+     *
+     * assert.isFalse(inclusiveGuard(6));
      * ```
      *
      * @template L - The lower bound as a SmallUint literal type
@@ -243,13 +250,15 @@ export declare namespace Num {
      * @example
      *
      * ```ts
-     * assert(Num.clamp(150, 0, 100) === 100);
-     * assert(Num.clamp(-50, 0, 100) === 0);
+     * assert.isTrue(Num.clamp(150, 0, 100) === 100);
+     *
+     * assert.isTrue(Num.clamp(-50, 0, 100) === 0);
      *
      * const clampToPercentage = Num.clamp(0, 100);
      *
-     * assert(clampToPercentage(75) === 75);
-     * assert(clampToPercentage(150) === 100);
+     * assert.isTrue(clampToPercentage(75) === 75);
+     *
+     * assert.isTrue(clampToPercentage(150) === 100);
      * ```
      */
     export function clamp(target: number, lowerBound: number, upperBound: number): number;

package/dist/number/num.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"num.d.mts","sourceRoot":"","sources":["../../src/number/num.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"num.d.mts","sourceRoot":"","sources":["../../src/number/num.mts"],"names":[],"mappings":"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"}