ts-data-forge 5.0.1 → 5.1.0

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

@@ -6,8 +6,11 @@
  *
  * ```ts
  * assert.ok(isPositiveSafeInt(1));
+ *
  * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+ *
  * assert.notOk(isPositiveSafeInt(0));
+ *
  * assert.ok(PositiveSafeInt.is(42));
  * ```
  *
@@ -24,6 +27,7 @@ export declare const isPositiveSafeInt: (a: number) => a is PositiveSafeInt;
  * const branded = asPositiveSafeInt(128);
  *
  * assert(branded === 128);
+ *
  * assert.ok(PositiveSafeInt.is(branded));
  * ```
  *
@@ -62,8 +66,11 @@ export declare const PositiveSafeInt: {
      *
      * ```ts
      * assert.ok(isPositiveSafeInt(1));
+     *
      * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+     *
      * assert.notOk(isPositiveSafeInt(0));
+     *
      * assert.ok(PositiveSafeInt.is(42));
      * ```
      *
@@ -129,11 +136,15 @@ 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);
      * ```
      *
@@ -148,10 +159,13 @@ 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);
      * ```
      *
@@ -165,7 +179,9 @@ export declare const PositiveSafeInt: {
      *
      * ```ts
      * const base = asPositiveSafeInt(3);
+     *
      * const exponent = asPositiveSafeInt(3);
+     *
      * const power = PositiveSafeInt.pow(base, exponent);
      *
      * assert(power === 27);
@@ -188,6 +204,7 @@ export declare const PositiveSafeInt: {
      * );
      *
      * assert(sum === 3048);
+     *
      * assert.ok(PositiveSafeInt.is(sum));
      * ```
      *
@@ -208,6 +225,7 @@ export declare const PositiveSafeInt: {
      * );
      *
      * assert(difference === 1);
+     *
      * assert.ok(PositiveSafeInt.is(difference));
      * ```
      *
@@ -229,6 +247,7 @@ export declare const PositiveSafeInt: {
      * );
      *
      * assert(product === 1000);
+     *
      * assert.ok(PositiveSafeInt.is(product));
      * ```
      *
@@ -247,12 +266,14 @@ export declare const PositiveSafeInt: {
      *   asPositiveSafeInt(25),
      *   asPositiveSafeInt(4),
      * );
+     *
      * const clamped = PositiveSafeInt.div(
      *   asPositiveSafeInt(5),
      *   asPositiveSafeInt(50),
      * );
      *
      * assert(quotient === 6);
+     *
      * assert(clamped === 1);
      * ```
      *

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,
 });
@@ -16,8 +16,11 @@ const { MAX_VALUE, MIN_VALUE, add, castType, clamp, div, is, max: max_, min: min
  *
  * ```ts
  * assert.ok(isPositiveSafeInt(1));
+ *
  * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+ *
  * assert.notOk(isPositiveSafeInt(0));
+ *
  * assert.ok(PositiveSafeInt.is(42));
  * ```
  *
@@ -34,6 +37,7 @@ const isPositiveSafeInt = is;
  * const branded = asPositiveSafeInt(128);
  *
  * assert(branded === 128);
+ *
  * assert.ok(PositiveSafeInt.is(branded));
  * ```
  *
@@ -59,8 +63,11 @@ const PositiveSafeInt = {
      *
      * ```ts
      * assert.ok(isPositiveSafeInt(1));
+     *
      * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+     *
      * assert.notOk(isPositiveSafeInt(0));
+     *
      * assert.ok(PositiveSafeInt.is(42));
      * ```
      *
@@ -126,11 +133,15 @@ 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);
      * ```
      *
@@ -145,10 +156,13 @@ 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);
      * ```
      *
@@ -162,7 +176,9 @@ const PositiveSafeInt = {
      *
      * ```ts
      * const base = asPositiveSafeInt(3);
+     *
      * const exponent = asPositiveSafeInt(3);
+     *
      * const power = PositiveSafeInt.pow(base, exponent);
      *
      * assert(power === 27);
@@ -185,6 +201,7 @@ const PositiveSafeInt = {
      * );
      *
      * assert(sum === 3048);
+     *
      * assert.ok(PositiveSafeInt.is(sum));
      * ```
      *
@@ -205,6 +222,7 @@ const PositiveSafeInt = {
      * );
      *
      * assert(difference === 1);
+     *
      * assert.ok(PositiveSafeInt.is(difference));
      * ```
      *
@@ -226,6 +244,7 @@ const PositiveSafeInt = {
      * );
      *
      * assert(product === 1000);
+     *
      * assert.ok(PositiveSafeInt.is(product));
      * ```
      *
@@ -244,12 +263,14 @@ const PositiveSafeInt = {
      *   asPositiveSafeInt(25),
      *   asPositiveSafeInt(4),
      * );
+     *
      * const clamped = PositiveSafeInt.div(
      *   asPositiveSafeInt(5),
      *   asPositiveSafeInt(50),
      * );
      *
      * assert(quotient === 6);
+     *
      * assert(clamped === 1);
      * ```
      *

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

@@ -9,7 +9,9 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
  *
  * ```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));
  * ```
  *
@@ -30,6 +32,7 @@ export declare const isSafeInt: (a: number) => a is SafeInt;
  * const branded = asSafeInt(123);
  *
  * assert(branded === 123);
+ *
  * assert.ok(SafeInt.is(branded));
  * ```
  *
@@ -69,7 +72,9 @@ export declare const SafeInt: {
      *
      * ```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));
      * ```
      *
@@ -100,9 +105,11 @@ export declare const SafeInt: {
      *
      * ```ts
      * const negative = asSafeInt(-900);
+     *
      * const absolute = SafeInt.abs(negative);
      *
      * assert(absolute === 900);
+     *
      * assert.ok(SafeInt.is(absolute));
      * ```
      *
@@ -147,11 +154,15 @@ 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);
      * ```
      *
@@ -170,10 +181,13 @@ 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);
      * ```
      *
@@ -189,10 +203,13 @@ 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));
      * ```
      *
@@ -210,6 +227,7 @@ export declare const SafeInt: {
      * const sum = SafeInt.add(asSafeInt(9), asSafeInt(4));
      *
      * assert(sum === 13);
+     *
      * assert.ok(SafeInt.is(sum));
      * ```
      *
@@ -227,6 +245,7 @@ export declare const SafeInt: {
      * const difference = SafeInt.sub(asSafeInt(9), asSafeInt(14));
      *
      * assert(difference === -5);
+     *
      * assert.ok(SafeInt.is(difference));
      * ```
      *
@@ -244,6 +263,7 @@ export declare const SafeInt: {
      * const product = SafeInt.mul(asSafeInt(-8), asSafeInt(7));
      *
      * assert(product === -56);
+     *
      * assert.ok(SafeInt.is(product));
      * ```
      *
@@ -264,6 +284,7 @@ export declare const SafeInt: {
      * const quotient = SafeInt.div(asSafeInt(-17), asSafeInt(5));
      *
      * assert(quotient === -4);
+     *
      * assert.ok(SafeInt.is(quotient));
      * ```
      *

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"}

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,
 });
@@ -19,7 +19,9 @@ const { MAX_VALUE, MIN_VALUE, abs, add, castType, clamp, div, is, max: max_, min
  *
  * ```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));
  * ```
  *
@@ -40,6 +42,7 @@ const isSafeInt = is;
  * const branded = asSafeInt(123);
  *
  * assert(branded === 123);
+ *
  * assert.ok(SafeInt.is(branded));
  * ```
  *
@@ -72,7 +75,9 @@ const SafeInt = {
      *
      * ```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));
      * ```
      *
@@ -103,9 +108,11 @@ const SafeInt = {
      *
      * ```ts
      * const negative = asSafeInt(-900);
+     *
      * const absolute = SafeInt.abs(negative);
      *
      * assert(absolute === 900);
+     *
      * assert.ok(SafeInt.is(absolute));
      * ```
      *
@@ -150,11 +157,15 @@ 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);
      * ```
      *
@@ -173,10 +184,13 @@ 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);
      * ```
      *
@@ -192,10 +206,13 @@ 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));
      * ```
      *
@@ -213,6 +230,7 @@ const SafeInt = {
      * const sum = SafeInt.add(asSafeInt(9), asSafeInt(4));
      *
      * assert(sum === 13);
+     *
      * assert.ok(SafeInt.is(sum));
      * ```
      *
@@ -230,6 +248,7 @@ const SafeInt = {
      * const difference = SafeInt.sub(asSafeInt(9), asSafeInt(14));
      *
      * assert(difference === -5);
+     *
      * assert.ok(SafeInt.is(difference));
      * ```
      *
@@ -247,6 +266,7 @@ const SafeInt = {
      * const product = SafeInt.mul(asSafeInt(-8), asSafeInt(7));
      *
      * assert(product === -56);
+     *
      * assert.ok(SafeInt.is(product));
      * ```
      *
@@ -267,6 +287,7 @@ const SafeInt = {
      * const quotient = SafeInt.div(asSafeInt(-17), asSafeInt(5));
      *
      * assert(quotient === -4);
+     *
      * assert.ok(SafeInt.is(quotient));
      * ```
      *

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

@@ -5,7 +5,9 @@
  *
  * ```ts
  * assert.ok(isUint(4));
+ *
  * assert.notOk(isUint(-1));
+ *
  * assert.ok(Uint.is(0));
  * ```
  *
@@ -22,6 +24,7 @@ export declare const isUint: (a: number) => a is NonNegativeInt;
  * const branded = asUint(12);
  *
  * assert(branded === 12);
+ *
  * assert.ok(Uint.is(branded));
  * ```
  *
@@ -56,7 +59,9 @@ export declare const Uint: {
      *
      * ```ts
      * assert.ok(isUint(4));
+     *
      * assert.notOk(isUint(-1));
+     *
      * assert.ok(Uint.is(0));
      * ```
      *
@@ -110,9 +115,11 @@ export declare const Uint: {
      *
      * ```ts
      * const clampedNegative = Uint.clamp(-5);
+     *
      * const clampedPositive = Uint.clamp(42);
      *
      * assert(clampedNegative === 0);
+     *
      * assert(clampedPositive === 42);
      * ```
      *
@@ -127,10 +134,13 @@ 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);
      * ```
      *
@@ -144,7 +154,9 @@ export declare const Uint: {
      *
      * ```ts
      * const base = asUint(2);
+     *
      * const exponent = asUint(5);
+     *
      * const power = Uint.pow(base, exponent);
      *
      * assert(power === 32);

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

@@ -14,7 +14,9 @@ const { MIN_VALUE, add, castType, clamp, div, is, max: max_, min: min_, mul, pow
  *
  * ```ts
  * assert.ok(isUint(4));
+ *
  * assert.notOk(isUint(-1));
+ *
  * assert.ok(Uint.is(0));
  * ```
  *
@@ -31,6 +33,7 @@ const isUint = is;
  * const branded = asUint(12);
  *
  * assert(branded === 12);
+ *
  * assert.ok(Uint.is(branded));
  * ```
  *
@@ -54,7 +57,9 @@ const Uint = {
      *
      * ```ts
      * assert.ok(isUint(4));
+     *
      * assert.notOk(isUint(-1));
+     *
      * assert.ok(Uint.is(0));
      * ```
      *
@@ -108,9 +113,11 @@ const Uint = {
      *
      * ```ts
      * const clampedNegative = Uint.clamp(-5);
+     *
      * const clampedPositive = Uint.clamp(42);
      *
      * assert(clampedNegative === 0);
+     *
      * assert(clampedPositive === 42);
      * ```
      *
@@ -125,10 +132,13 @@ 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);
      * ```
      *
@@ -142,7 +152,9 @@ const Uint = {
      *
      * ```ts
      * const base = asUint(2);
+     *
      * const exponent = asUint(5);
+     *
      * const power = Uint.pow(base, exponent);
      *
      * assert(power === 32);

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;;;;;"}