ts-data-forge 3.3.0 → 4.0.0

package/dist/number/branded-types/non-negative-int32.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,sCAAK,CAAC;AAErC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,sCAAK,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/non-negative-int32.mjs

@@ -1,79 +1,61 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a non-negative integer in [0, 2^31)';
-const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
+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,
     MAX_VALUE: 2 ** 31 - 1,
     typeNameInMessage,
 });
 /**
- * Checks if a number is a NonNegativeInt32 (32-bit non-negative signed integer in the range [0, 2^31)).
+ * Checks if a number is a NonNegativeInt32 (32-bit non-negative signed integer
+ * in the range [0, 2^31)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonNegativeInt32, `false` otherwise.
  */
 const isNonNegativeInt32 = is;
 /**
  * Casts a number to a NonNegativeInt32 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonNegativeInt32 type.
  * @throws {TypeError} If the value is not a non-negative integer in [0, 2^31).
- * @example
- * ```typescript
- * const x = asNonNegativeInt32(1000); // NonNegativeInt32
- * const y = asNonNegativeInt32(0); // NonNegativeInt32
- * // asNonNegativeInt32(-1); // throws TypeError
- * // asNonNegativeInt32(2147483648); // throws TypeError
- * ```
  */
 const asNonNegativeInt32 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 32-bit non-negative integers.
- *
- * All operations automatically clamp results to the valid NonNegativeInt32 range [0, 2147483647].
- * This ensures that all arithmetic maintains the 32-bit non-negative integer constraint,
- * with negative results clamped to 0 and overflow results clamped to MAX_VALUE.
- *
- * @example
- * ```typescript
- * const a = asNonNegativeInt32(2000000000);
- * const b = asNonNegativeInt32(500000000);
- *
- * // Arithmetic operations with automatic clamping
- * const sum = NonNegativeInt32.add(a, b);       // NonNegativeInt32 (2147483647 - clamped to MAX_VALUE)
- * const diff = NonNegativeInt32.sub(a, b);      // NonNegativeInt32 (1500000000)
- * const reverseDiff = NonNegativeInt32.sub(b, a); // NonNegativeInt32 (0 - clamped to MIN_VALUE)
- * const product = NonNegativeInt32.mul(a, b);   // NonNegativeInt32 (2147483647 - clamped due to overflow)
- *
- * // Range operations
- * const clamped = NonNegativeInt32.clamp(-1000);     // NonNegativeInt32 (0)
- * const minimum = NonNegativeInt32.min(a, b);        // NonNegativeInt32 (500000000)
- * const maximum = NonNegativeInt32.max(a, b);        // NonNegativeInt32 (2000000000)
+ * Namespace providing type-safe arithmetic operations for 32-bit non-negative
+ * integers.
  *
- * // Utility operations
- * const random = NonNegativeInt32.random();          // NonNegativeInt32 (random value in [0, 2147483647])
- * const power = NonNegativeInt32.pow(asNonNegativeInt32(2), asNonNegativeInt32(20)); // NonNegativeInt32 (1048576)
- * ```
+ * All operations automatically clamp results to the valid NonNegativeInt32
+ * range [0, 2147483647]. This ensures that all arithmetic maintains the 32-bit
+ * non-negative integer constraint, with negative results clamped to 0 and
+ * overflow results clamped to MAX_VALUE.
  */
 const NonNegativeInt32 = {
     /**
      * Type guard to check if a value is a NonNegativeInt32.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 32-bit non-negative integer, `false` otherwise.
+     * @returns `true` if the value is a 32-bit non-negative integer, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for a 32-bit non-negative integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a 32-bit non-negative integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the smaller of two NonNegativeInt32 values.
+     *
      * @param a The first NonNegativeInt32.
      * @param b The second NonNegativeInt32.
      * @returns The minimum value as a NonNegativeInt32.
@@ -81,6 +63,7 @@ const NonNegativeInt32 = {
     min: min_,
     /**
      * Returns the larger of two NonNegativeInt32 values.
+     *
      * @param a The first NonNegativeInt32.
      * @param b The second NonNegativeInt32.
      * @returns The maximum value as a NonNegativeInt32.
@@ -88,17 +71,20 @@ const NonNegativeInt32 = {
     max: max_,
     /**
      * Clamps a number to the NonNegativeInt32 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [0, 2147483647] as a NonNegativeInt32.
      */
     clamp,
     /**
      * Generates a random NonNegativeInt32 value within the valid range.
+     *
      * @returns A random NonNegativeInt32 between 0 and 2147483647.
      */
     random,
     /**
      * Raises a NonNegativeInt32 to the power of another NonNegativeInt32.
+     *
      * @param a The base NonNegativeInt32.
      * @param b The exponent NonNegativeInt32.
      * @returns `a ** b` clamped to [0, 2147483647] as a NonNegativeInt32.
@@ -106,6 +92,7 @@ const NonNegativeInt32 = {
     pow,
     /**
      * Adds two NonNegativeInt32 values.
+     *
      * @param a The first NonNegativeInt32.
      * @param b The second NonNegativeInt32.
      * @returns `a + b` clamped to [0, 2147483647] as a NonNegativeInt32.
@@ -113,13 +100,16 @@ const NonNegativeInt32 = {
     add,
     /**
      * Subtracts one NonNegativeInt32 from another.
+     *
      * @param a The minuend NonNegativeInt32.
      * @param b The subtrahend NonNegativeInt32.
-     * @returns `a - b` clamped to [0, 2147483647] as a NonNegativeInt32 (minimum 0).
+     * @returns `a - b` clamped to [0, 2147483647] as a NonNegativeInt32 (minimum
+     *   0).
      */
     sub,
     /**
      * Multiplies two NonNegativeInt32 values.
+     *
      * @param a The first NonNegativeInt32.
      * @param b The second NonNegativeInt32.
      * @returns `a * b` clamped to [0, 2147483647] as a NonNegativeInt32.
@@ -127,6 +117,7 @@ const NonNegativeInt32 = {
     mul,
     /**
      * Divides one NonNegativeInt32 by another using floor division.
+     *
      * @param a The dividend NonNegativeInt32.
      * @param b The divisor NonNegativeInt32.
      * @returns `⌊a / b⌋` clamped to [0, 2147483647] as a NonNegativeInt32.

package/dist/number/branded-types/non-negative-int32.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int32.mjs","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;AAYG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-negative-int32.mjs","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,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;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;AAMG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;AAQG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/non-zero-finite-number.d.mts

@@ -2,22 +2,17 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 type ElementType = NonZeroFiniteNumber;
 /**
  * Checks if a number is a NonZeroFiniteNumber (a finite number that is not 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroFiniteNumber, `false` otherwise.
  */
 export declare const isNonZeroFiniteNumber: (a: number) => a is NonZeroFiniteNumber;
 /**
  * Casts a number to a NonZeroFiniteNumber type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroFiniteNumber type.
  * @throws {TypeError} If the value is not a non-zero finite number.
- * @example
- * ```typescript
- * const x = asNonZeroFiniteNumber(5.5); // NonZeroFiniteNumber
- * const y = asNonZeroFiniteNumber(-3.2); // NonZeroFiniteNumber
- * // asNonZeroFiniteNumber(0); // throws TypeError
- * // asNonZeroFiniteNumber(Infinity); // throws TypeError
- * ```
  */
 export declare const asNonZeroFiniteNumber: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -27,52 +22,32 @@ export declare const asNonZeroFiniteNumber: <N extends number>(x: N) => number &
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
 /**
- * Namespace providing type-safe arithmetic operations for non-zero finite numbers.
- *
- * All operations maintain the non-zero constraint while ensuring results remain finite
- * (excluding NaN and Infinity). This type is useful for values that must never be zero,
- * such as denominators, scaling factors, and ratios.
- *
- * @example
- * ```typescript
- * const factor = asNonZeroFiniteNumber(2.5);
- * const multiplier = asNonZeroFiniteNumber(-1.5);
- *
- * // Arithmetic operations that preserve non-zero constraint
- * const result = NonZeroFiniteNumber.add(factor, multiplier);        // NonZeroFiniteNumber (1.0)
- * const difference = NonZeroFiniteNumber.sub(factor, multiplier);    // NonZeroFiniteNumber (4.0)
- * const product = NonZeroFiniteNumber.mul(factor, multiplier);       // NonZeroFiniteNumber (-3.75)
- * const quotient = NonZeroFiniteNumber.div(factor, multiplier);      // NonZeroFiniteNumber (-1.666...)
- *
- * // Utility operations
- * const absolute = NonZeroFiniteNumber.abs(multiplier);              // NonZeroFiniteNumber (1.5)
- * const minimum = NonZeroFiniteNumber.min(factor, multiplier);       // NonZeroFiniteNumber (-1.5)
- * const maximum = NonZeroFiniteNumber.max(factor, multiplier);       // NonZeroFiniteNumber (2.5)
- *
- * // Rounding operations (return NonZeroInt)
- * const rounded = NonZeroFiniteNumber.round(factor);                 // NonZeroInt (3)
- * const floored = NonZeroFiniteNumber.floor(factor);                 // NonZeroInt (2)
- * const ceiled = NonZeroFiniteNumber.ceil(factor);                   // NonZeroInt (3)
+ * Namespace providing type-safe arithmetic operations for non-zero finite
+ * numbers.
  *
- * // Random generation
- * const randomValue = NonZeroFiniteNumber.random();                  // NonZeroFiniteNumber (random non-zero value)
- * ```
+ * All operations maintain the non-zero constraint while ensuring results remain
+ * finite (excluding NaN and Infinity). This type is useful for values that must
+ * never be zero, such as denominators, scaling factors, and ratios.
  */
 export declare const NonZeroFiniteNumber: {
     /**
      * Type guard to check if a value is a NonZeroFiniteNumber.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a non-zero finite number, `false` otherwise.
+     * @returns `true` if the value is a non-zero finite number, `false`
+     *   otherwise.
      */
     readonly is: (a: number) => a is NonZeroFiniteNumber;
     /**
      * Returns the absolute value of a non-zero finite number.
+     *
      * @param a The NonZeroFiniteNumber.
      * @returns The absolute value as a NonZeroFiniteNumber.
      */
     readonly abs: (x: NonZeroFiniteNumber) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroFiniteNumber>;
     /**
      * Returns the smaller of two NonZeroFiniteNumber values.
+     *
      * @param a The first NonZeroFiniteNumber.
      * @param b The second NonZeroFiniteNumber.
      * @returns The minimum value as a NonZeroFiniteNumber.
@@ -80,6 +55,7 @@ export declare const NonZeroFiniteNumber: {
     readonly min: (...values: readonly NonZeroFiniteNumber[]) => NonZeroFiniteNumber;
     /**
      * Returns the larger of two NonZeroFiniteNumber values.
+     *
      * @param a The first NonZeroFiniteNumber.
      * @param b The second NonZeroFiniteNumber.
      * @returns The maximum value as a NonZeroFiniteNumber.
@@ -87,29 +63,34 @@ export declare const NonZeroFiniteNumber: {
     readonly max: (...values: readonly NonZeroFiniteNumber[]) => NonZeroFiniteNumber;
     /**
      * Rounds down a NonZeroFiniteNumber to the nearest integer.
+     *
      * @param x The NonZeroFiniteNumber to round down.
      * @returns The floor value as a NonZeroInt.
      */
     readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds up a NonZeroFiniteNumber to the nearest integer.
+     *
      * @param x The NonZeroFiniteNumber to round up.
      * @returns The ceiling value as a NonZeroInt.
      */
     readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds a NonZeroFiniteNumber to the nearest integer.
+     *
      * @param x The NonZeroFiniteNumber to round.
      * @returns The rounded value as a NonZeroInt.
      */
     readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Generates a random NonZeroFiniteNumber value.
+     *
      * @returns A random non-zero finite number.
      */
     readonly random: (min?: NonZeroFiniteNumber | undefined, max?: NonZeroFiniteNumber | undefined) => NonZeroFiniteNumber;
     /**
      * Raises a NonZeroFiniteNumber to the power of another NonZeroFiniteNumber.
+     *
      * @param a The base NonZeroFiniteNumber.
      * @param b The exponent NonZeroFiniteNumber.
      * @returns `a ** b` as a NonZeroFiniteNumber.
@@ -117,6 +98,7 @@ export declare const NonZeroFiniteNumber: {
     readonly pow: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
     /**
      * Adds two NonZeroFiniteNumber values.
+     *
      * @param a The first NonZeroFiniteNumber.
      * @param b The second NonZeroFiniteNumber.
      * @returns `a + b` as a NonZeroFiniteNumber.
@@ -124,6 +106,7 @@ export declare const NonZeroFiniteNumber: {
     readonly add: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
     /**
      * Subtracts one NonZeroFiniteNumber from another.
+     *
      * @param a The minuend NonZeroFiniteNumber.
      * @param b The subtrahend NonZeroFiniteNumber.
      * @returns `a - b` as a NonZeroFiniteNumber.
@@ -131,6 +114,7 @@ export declare const NonZeroFiniteNumber: {
     readonly sub: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
     /**
      * Multiplies two NonZeroFiniteNumber values.
+     *
      * @param a The first NonZeroFiniteNumber.
      * @param b The second NonZeroFiniteNumber.
      * @returns `a * b` as a NonZeroFiniteNumber.
@@ -138,6 +122,7 @@ export declare const NonZeroFiniteNumber: {
     readonly mul: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
     /**
      * Divides one NonZeroFiniteNumber by another.
+     *
      * @param a The dividend NonZeroFiniteNumber.
      * @param b The divisor NonZeroFiniteNumber.
      * @returns `a / b` as a NonZeroFiniteNumber.

package/dist/number/branded-types/non-zero-finite-number.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AA2DvC;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,yCAAK,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;wBAtHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAwH3D;;;;OAIG;uBAvHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAyH3D;;;;OAIG;wBAxHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA0H3D;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AA2DvC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,yCAAK,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;wBA/FA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAiG3D;;;;;OAKG;uBAjGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAmG3D;;;;;OAKG;wBAnGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAqG3D;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/non-zero-finite-number.mjs

@@ -1,7 +1,7 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a non-zero finite number';
-const { abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: random, is, castType, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
+const { abs, add, castType, div, is, max: max_, min: min_, mul, pow, randomNonZero: random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
     nonZero: true,
     MIN_VALUE: -Number.MAX_VALUE,
     MAX_VALUE: Number.MAX_VALUE,
@@ -9,81 +9,56 @@ const { abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: rando
 });
 // Not provided because reasonable rounding operations that avoid becoming 0 cannot be defined
 const floor = (x) => 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
 Math.floor(x);
 const ceil = (x) => 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
 Math.ceil(x);
 const round = (x) => 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
 Math.round(x);
 /**
  * Checks if a number is a NonZeroFiniteNumber (a finite number that is not 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroFiniteNumber, `false` otherwise.
  */
 const isNonZeroFiniteNumber = is;
 /**
  * Casts a number to a NonZeroFiniteNumber type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroFiniteNumber type.
  * @throws {TypeError} If the value is not a non-zero finite number.
- * @example
- * ```typescript
- * const x = asNonZeroFiniteNumber(5.5); // NonZeroFiniteNumber
- * const y = asNonZeroFiniteNumber(-3.2); // NonZeroFiniteNumber
- * // asNonZeroFiniteNumber(0); // throws TypeError
- * // asNonZeroFiniteNumber(Infinity); // throws TypeError
- * ```
  */
 const asNonZeroFiniteNumber = castType;
 /**
- * Namespace providing type-safe arithmetic operations for non-zero finite numbers.
- *
- * All operations maintain the non-zero constraint while ensuring results remain finite
- * (excluding NaN and Infinity). This type is useful for values that must never be zero,
- * such as denominators, scaling factors, and ratios.
- *
- * @example
- * ```typescript
- * const factor = asNonZeroFiniteNumber(2.5);
- * const multiplier = asNonZeroFiniteNumber(-1.5);
- *
- * // Arithmetic operations that preserve non-zero constraint
- * const result = NonZeroFiniteNumber.add(factor, multiplier);        // NonZeroFiniteNumber (1.0)
- * const difference = NonZeroFiniteNumber.sub(factor, multiplier);    // NonZeroFiniteNumber (4.0)
- * const product = NonZeroFiniteNumber.mul(factor, multiplier);       // NonZeroFiniteNumber (-3.75)
- * const quotient = NonZeroFiniteNumber.div(factor, multiplier);      // NonZeroFiniteNumber (-1.666...)
- *
- * // Utility operations
- * const absolute = NonZeroFiniteNumber.abs(multiplier);              // NonZeroFiniteNumber (1.5)
- * const minimum = NonZeroFiniteNumber.min(factor, multiplier);       // NonZeroFiniteNumber (-1.5)
- * const maximum = NonZeroFiniteNumber.max(factor, multiplier);       // NonZeroFiniteNumber (2.5)
- *
- * // Rounding operations (return NonZeroInt)
- * const rounded = NonZeroFiniteNumber.round(factor);                 // NonZeroInt (3)
- * const floored = NonZeroFiniteNumber.floor(factor);                 // NonZeroInt (2)
- * const ceiled = NonZeroFiniteNumber.ceil(factor);                   // NonZeroInt (3)
+ * Namespace providing type-safe arithmetic operations for non-zero finite
+ * numbers.
  *
- * // Random generation
- * const randomValue = NonZeroFiniteNumber.random();                  // NonZeroFiniteNumber (random non-zero value)
- * ```
+ * All operations maintain the non-zero constraint while ensuring results remain
+ * finite (excluding NaN and Infinity). This type is useful for values that must
+ * never be zero, such as denominators, scaling factors, and ratios.
  */
 const NonZeroFiniteNumber = {
     /**
      * Type guard to check if a value is a NonZeroFiniteNumber.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a non-zero finite number, `false` otherwise.
+     * @returns `true` if the value is a non-zero finite number, `false`
+     *   otherwise.
      */
     is,
     /**
      * Returns the absolute value of a non-zero finite number.
+     *
      * @param a The NonZeroFiniteNumber.
      * @returns The absolute value as a NonZeroFiniteNumber.
      */
     abs,
     /**
      * Returns the smaller of two NonZeroFiniteNumber values.
+     *
      * @param a The first NonZeroFiniteNumber.
      * @param b The second NonZeroFiniteNumber.
      * @returns The minimum value as a NonZeroFiniteNumber.
@@ -91,6 +66,7 @@ const NonZeroFiniteNumber = {
     min: min_,
     /**
      * Returns the larger of two NonZeroFiniteNumber values.
+     *
      * @param a The first NonZeroFiniteNumber.
      * @param b The second NonZeroFiniteNumber.
      * @returns The maximum value as a NonZeroFiniteNumber.
@@ -98,29 +74,34 @@ const NonZeroFiniteNumber = {
     max: max_,
     /**
      * Rounds down a NonZeroFiniteNumber to the nearest integer.
+     *
      * @param x The NonZeroFiniteNumber to round down.
      * @returns The floor value as a NonZeroInt.
      */
     floor,
     /**
      * Rounds up a NonZeroFiniteNumber to the nearest integer.
+     *
      * @param x The NonZeroFiniteNumber to round up.
      * @returns The ceiling value as a NonZeroInt.
      */
     ceil,
     /**
      * Rounds a NonZeroFiniteNumber to the nearest integer.
+     *
      * @param x The NonZeroFiniteNumber to round.
      * @returns The rounded value as a NonZeroInt.
      */
     round,
     /**
      * Generates a random NonZeroFiniteNumber value.
+     *
      * @returns A random non-zero finite number.
      */
     random,
     /**
      * Raises a NonZeroFiniteNumber to the power of another NonZeroFiniteNumber.
+     *
      * @param a The base NonZeroFiniteNumber.
      * @param b The exponent NonZeroFiniteNumber.
      * @returns `a ** b` as a NonZeroFiniteNumber.
@@ -128,6 +109,7 @@ const NonZeroFiniteNumber = {
     pow,
     /**
      * Adds two NonZeroFiniteNumber values.
+     *
      * @param a The first NonZeroFiniteNumber.
      * @param b The second NonZeroFiniteNumber.
      * @returns `a + b` as a NonZeroFiniteNumber.
@@ -135,6 +117,7 @@ const NonZeroFiniteNumber = {
     add,
     /**
      * Subtracts one NonZeroFiniteNumber from another.
+     *
      * @param a The minuend NonZeroFiniteNumber.
      * @param b The subtrahend NonZeroFiniteNumber.
      * @returns `a - b` as a NonZeroFiniteNumber.
@@ -142,6 +125,7 @@ const NonZeroFiniteNumber = {
     sub,
     /**
      * Multiplies two NonZeroFiniteNumber values.
+     *
      * @param a The first NonZeroFiniteNumber.
      * @param b The second NonZeroFiniteNumber.
      * @returns `a * b` as a NonZeroFiniteNumber.
@@ -149,6 +133,7 @@ const NonZeroFiniteNumber = {
     mul,
     /**
      * Divides one NonZeroFiniteNumber by another.
+     *
      * @param a The dividend NonZeroFiniteNumber.
      * @param b The divisor NonZeroFiniteNumber.
      * @returns `a / b` as a NonZeroFiniteNumber.

package/dist/number/branded-types/non-zero-finite-number.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"non-zero-finite-number.mjs","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,EAAE,EACF,QAAQ,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;AAEA,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAc7E;;;;AAIG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;;;AAYG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACI,MAAM,mBAAmB,GAAG;AACjC;;;;AAIG;IACH,EAAE;AAEF;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,IAAI;AAEJ;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-zero-finite-number.mjs","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;AAEA,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAc7E;;;;;AAKG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;AAMG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;AAOG;AACI,MAAM,mBAAmB,GAAG;AACjC;;;;;;AAMG;IACH,EAAE;AAEF;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,22 +1,17 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
  * Checks if a number is a NonZeroInt.
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt, `false` otherwise.
  */
 export declare const isNonZeroInt: (a: number) => a is NonZeroInt;
 /**
  * Casts a number to a NonZeroInt type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroInt type.
  * @throws {TypeError} If the value is not a non-zero integer.
- * @example
- * ```typescript
- * const x = asNonZeroInt(5); // NonZeroInt
- * const y = asNonZeroInt(-3); // NonZeroInt
- * // asNonZeroInt(0); // throws TypeError
- * // asNonZeroInt(1.5); // throws TypeError
- * ```
  */
 export declare const asNonZeroInt: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -29,45 +24,28 @@ export declare const asNonZeroInt: <N extends number>(x: N) => number & {
 /**
  * Namespace providing type-safe arithmetic operations for non-zero integers.
  *
- * All operations maintain the non-zero constraint, ensuring that results are always valid NonZeroInt values.
- * Division operations return floor division results, and all arithmetic maintains integer precision.
- *
- * @example
- * ```typescript
- * const a = asNonZeroInt(10);
- * const b = asNonZeroInt(-5);
- *
- * // Arithmetic operations
- * const sum = NonZeroInt.add(a, b);     // NonZeroInt (5)
- * const diff = NonZeroInt.sub(a, b);    // NonZeroInt (15)
- * const product = NonZeroInt.mul(a, b); // NonZeroInt (-50)
- * const quotient = NonZeroInt.div(a, b); // NonZeroInt (-2)
- *
- * // Utility operations
- * const absolute = NonZeroInt.abs(b);   // NonZeroInt (5)
- * const power = NonZeroInt.pow(a, asNonZeroInt(2)); // NonZeroInt (100)
- * const minimum = NonZeroInt.min(a, b); // NonZeroInt (-5)
- * const maximum = NonZeroInt(a, b); // NonZeroInt (10)
- *
- * // Random generation
- * const randomInt = NonZeroInt.random(); // NonZeroInt (random non-zero integer)
- * ```
+ * All operations maintain the non-zero constraint, ensuring that results are
+ * always valid NonZeroInt values. Division operations return floor division
+ * results, and all arithmetic maintains integer precision.
  */
 export declare const NonZeroInt: {
     /**
      * Type guard to check if a value is a NonZeroInt.
+     *
      * @param value The value to check.
      * @returns `true` if the value is a non-zero integer, `false` otherwise.
      */
     readonly is: (a: number) => a is NonZeroInt;
     /**
      * Returns the absolute value of a non-zero integer.
+     *
      * @param a The non-zero integer.
      * @returns The absolute value as a NonZeroInt.
      */
     readonly abs: (x: WithSmallInt<NonZeroInt, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt>;
     /**
      * Returns the smaller of two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns The minimum value as a NonZeroInt.
@@ -75,6 +53,7 @@ export declare const NonZeroInt: {
     readonly min: (...values: readonly WithSmallInt<NonZeroInt, 40>[]) => NonZeroInt;
     /**
      * Returns the larger of two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns The maximum value as a NonZeroInt.
@@ -82,11 +61,13 @@ export declare const NonZeroInt: {
     readonly max: (...values: readonly WithSmallInt<NonZeroInt, 40>[]) => NonZeroInt;
     /**
      * Generates a random non-zero integer.
+     *
      * @returns A random NonZeroInt value.
      */
     readonly random: (min?: WithSmallInt<NonZeroInt, 40> | undefined, max?: WithSmallInt<NonZeroInt, 40> | undefined) => NonZeroInt;
     /**
      * Raises a non-zero integer to the power of another non-zero integer.
+     *
      * @param a The base non-zero integer.
      * @param b The exponent non-zero integer.
      * @returns `a ** b` as a NonZeroInt.
@@ -94,6 +75,7 @@ export declare const NonZeroInt: {
     readonly pow: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
     /**
      * Adds two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns `a + b` as a NonZeroInt.
@@ -101,6 +83,7 @@ export declare const NonZeroInt: {
     readonly add: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
     /**
      * Subtracts one non-zero integer from another.
+     *
      * @param a The minuend non-zero integer.
      * @param b The subtrahend non-zero integer.
      * @returns `a - b` as a NonZeroInt.
@@ -108,6 +91,7 @@ export declare const NonZeroInt: {
     readonly sub: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
     /**
      * Multiplies two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns `a * b` as a NonZeroInt.
@@ -115,6 +99,7 @@ export declare const NonZeroInt: {
     readonly mul: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
     /**
      * Divides one non-zero integer by another using floor division.
+     *
      * @param a The dividend non-zero integer.
      * @param b The divisor non-zero integer.
      * @returns `⌊a / b⌋` as a NonZeroInt.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA8BnE;;;;GAIG;AACH,eAAO,MAAM,YAAY,gCAAK,CAAC;AAE/B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,UAAU;IACrB;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA8BnE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,gCAAK,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,UAAU;IACrB;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;CAEK,CAAC"}