ts-data-forge 3.3.0 → 4.0.0

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

@@ -3,47 +3,24 @@ type ElementType = FiniteNumber;
 /**
  * Type guard that checks if a value is a finite number.
  *
- * Returns `true` if the value is a finite number (not NaN, Infinity, or -Infinity).
- * This is stricter than the standard number type, which includes these special values.
+ * Returns `true` if the value is a finite number (not NaN, Infinity, or
+ * -Infinity). This is stricter than the standard number type, which includes
+ * these special values.
  *
  * @param value - The value to check
  * @returns `true` if the value is finite, `false` otherwise
- *
- * @example
- * ```typescript
- * isFiniteNumber(42);          // true
- * isFiniteNumber(3.14);        // true
- * isFiniteNumber(-0);          // true
- * isFiniteNumber(Infinity);    // false
- * isFiniteNumber(-Infinity);   // false
- * isFiniteNumber(NaN);         // false
- * isFiniteNumber(1/0);         // false (Infinity)
- * ```
  */
 export declare const isFiniteNumber: (a: number) => a is FiniteNumber;
 /**
  * Casts a number to a FiniteNumber branded type.
  *
- * This function validates that the input is finite (not NaN, Infinity, or -Infinity)
- * and returns it with the FiniteNumber brand. This ensures type safety for operations
- * that require finite numeric values.
+ * This function validates that the input is finite (not NaN, Infinity, or
+ * -Infinity) and returns it with the FiniteNumber brand. This ensures type
+ * safety for operations that require finite numeric values.
  *
  * @param value - The value to cast
  * @returns The value as a FiniteNumber branded type
  * @throws {TypeError} If the value is NaN, Infinity, or -Infinity
- *
- * @example
- * ```typescript
- * const x = asFiniteNumber(5.5);   // FiniteNumber
- * const y = asFiniteNumber(-10);   // FiniteNumber
- * const z = asFiniteNumber(0);     // FiniteNumber
- *
- * // These throw TypeError:
- * // asFiniteNumber(Infinity);     // Not finite
- * // asFiniteNumber(-Infinity);    // Not finite
- * // asFiniteNumber(NaN);          // Not a number
- * // asFiniteNumber(Math.sqrt(-1)); // Results in NaN
- * ```
  */
 export declare const asFiniteNumber: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -55,45 +32,14 @@ export declare const asFiniteNumber: <N extends number>(x: N) => number & {
  * Namespace providing type-safe operations for FiniteNumber branded types.
  *
  * The FiniteNumber type represents any finite numeric value, excluding the
- * special values NaN, Infinity, and -Infinity. All operations are guaranteed
- * to maintain the finite constraint when given finite inputs.
+ * special values NaN, Infinity, and -Infinity. All operations are guaranteed to
+ * maintain the finite constraint when given finite inputs.
  *
  * This type is essential for:
+ *
  * - Mathematical operations that require real numbers
  * - Preventing NaN/Infinity propagation in calculations
  * - Ensuring numeric stability in algorithms
- *
- * @example
- * ```typescript
- * // Type validation
- * FiniteNumber.is(3.14);       // true
- * FiniteNumber.is(Infinity);   // false
- * FiniteNumber.is(0/0);        // false (NaN)
- *
- * // Arithmetic with guaranteed finite results
- * const a = asFiniteNumber(10.5);
- * const b = asFiniteNumber(3.2);
- *
- * const sum = FiniteNumber.add(a, b);      // FiniteNumber (13.7)
- * const diff = FiniteNumber.sub(a, b);     // FiniteNumber (7.3)
- * const product = FiniteNumber.mul(a, b);  // FiniteNumber (33.6)
- * const quotient = FiniteNumber.div(a, b); // FiniteNumber (3.28125)
- * const power = FiniteNumber.pow(a, asFiniteNumber(2)); // FiniteNumber (110.25)
- *
- * // Rounding to integers
- * const value = asFiniteNumber(5.7);
- * const floored = FiniteNumber.floor(value);  // Int (5)
- * const ceiled = FiniteNumber.ceil(value);    // Int (6)
- * const rounded = FiniteNumber.round(value);  // Int (6)
- *
- * // Utility operations
- * const absolute = FiniteNumber.abs(asFiniteNumber(-42.5)); // FiniteNumber (42.5)
- * const minimum = FiniteNumber.min(a, b, asFiniteNumber(5)); // FiniteNumber (3.2)
- * const maximum = FiniteNumber.max(a, b, asFiniteNumber(5)); // FiniteNumber (10.5)
- *
- * // Random generation
- * const rand = FiniteNumber.random(asFiniteNumber(0), asFiniteNumber(1)); // Random in [0, 1]
- * ```
  */
 export declare const FiniteNumber: {
     /**
@@ -101,19 +47,14 @@ export declare const FiniteNumber: {
      *
      * @param value - The value to check
      * @returns `true` if the value is finite, `false` otherwise
-     *
      * @see {@link isFiniteNumber} for usage examples
      */
     readonly is: (a: number) => a is FiniteNumber;
     /**
      * Returns the absolute value of a finite number.
+     *
      * @param x - The finite number to get the absolute value of
      * @returns The absolute value as a FiniteNumber
-     * @example
-     * ```typescript
-     * FiniteNumber.abs(asFiniteNumber(-5.5)); // FiniteNumber (5.5)
-     * FiniteNumber.abs(asFiniteNumber(3.2)); // FiniteNumber (3.2)
-     * ```
      */
     readonly abs: (x: FiniteNumber) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<FiniteNumber>;
     /**
@@ -121,16 +62,6 @@ export declare const FiniteNumber: {
      *
      * @param values - The finite numbers to compare (at least one required)
      * @returns The smallest value as a FiniteNumber
-     *
-     * @example
-     * ```typescript
-     * const a = asFiniteNumber(5.5);
-     * const b = asFiniteNumber(3.2);
-     * const c = asFiniteNumber(7.8);
-     *
-     * FiniteNumber.min(a, b);      // FiniteNumber (3.2)
-     * FiniteNumber.min(a, b, c);   // FiniteNumber (3.2)
-     * ```
      */
     readonly min: (...values: readonly FiniteNumber[]) => FiniteNumber;
     /**
@@ -138,146 +69,83 @@ export declare const FiniteNumber: {
      *
      * @param values - The finite numbers to compare (at least one required)
      * @returns The largest value as a FiniteNumber
-     *
-     * @example
-     * ```typescript
-     * const a = asFiniteNumber(5.5);
-     * const b = asFiniteNumber(3.2);
-     * const c = asFiniteNumber(7.8);
-     *
-     * FiniteNumber.max(a, b);      // FiniteNumber (7.8)
-     * FiniteNumber.max(a, b, c);   // FiniteNumber (7.8)
-     * ```
      */
     readonly max: (...values: readonly FiniteNumber[]) => FiniteNumber;
     /**
      * Returns the largest integer less than or equal to the given finite number.
+     *
      * @param x - The finite number to floor
      * @returns The floor value as an Int
-     * @example
-     * ```typescript
-     * FiniteNumber.floor(asFiniteNumber(5.8)); // Int (5)
-     * FiniteNumber.floor(asFiniteNumber(-5.2)); // Int (-6)
-     * ```
      */
     readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
-     * Returns the smallest integer greater than or equal to the given finite number.
+     * Returns the smallest integer greater than or equal to the given finite
+     * number.
+     *
      * @param x - The finite number to ceil
      * @returns The ceiling value as an Int
-     * @example
-     * ```typescript
-     * FiniteNumber.ceil(asFiniteNumber(5.2)); // Int (6)
-     * FiniteNumber.ceil(asFiniteNumber(-5.8)); // Int (-5)
-     * ```
      */
     readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds a finite number to the nearest integer.
+     *
      * @param x - The finite number to round
      * @returns The rounded value as an Int
-     * @example
-     * ```typescript
-     * FiniteNumber.round(asFiniteNumber(5.4)); // Int (5)
-     * FiniteNumber.round(asFiniteNumber(5.6)); // Int (6)
-     * FiniteNumber.round(asFiniteNumber(5.5)); // Int (6)
-     * ```
      */
     readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Generates a random finite number within the specified range.
      *
-     * The generated value is uniformly distributed in the range [min, max].
-     * Both bounds are inclusive.
+     * The generated value is uniformly distributed in the range [min, max]. Both
+     * bounds are inclusive.
      *
      * @param min - The minimum value (inclusive)
      * @param max - The maximum value (inclusive)
      * @returns A random FiniteNumber in the range [min, max]
-     *
-     * @example
-     * ```typescript
-     * // Random percentage (0-100)
-     * const pct = FiniteNumber.random(
-     *   asFiniteNumber(0),
-     *   asFiniteNumber(100)
-     * );
-     *
-     * // Random coordinate (-1 to 1)
-     * const coord = FiniteNumber.random(
-     *   asFiniteNumber(-1),
-     *   asFiniteNumber(1)
-     * );
-     * ```
      */
     readonly random: (min?: FiniteNumber | undefined, max?: FiniteNumber | undefined) => FiniteNumber;
     /**
      * Raises a finite number to a power.
+     *
      * @param a - The base finite number
      * @param b - The exponent finite number
      * @returns `a ** b` as a FiniteNumber
-     * @example
-     * ```typescript
-     * FiniteNumber.pow(asFiniteNumber(2.5), asFiniteNumber(3)); // FiniteNumber (15.625)
-     * ```
      */
     readonly pow: (x: FiniteNumber, y: FiniteNumber) => FiniteNumber;
     /**
      * Adds two finite numbers.
+     *
      * @param a - First finite number
      * @param b - Second finite number
      * @returns `a + b` as a FiniteNumber
-     * @example
-     * ```typescript
-     * FiniteNumber.add(asFiniteNumber(5.5), asFiniteNumber(3.2)); // FiniteNumber (8.7)
-     * ```
      */
     readonly add: (x: FiniteNumber, y: FiniteNumber) => FiniteNumber;
     /**
      * Subtracts two finite numbers.
+     *
      * @param a - First finite number
      * @param b - Second finite number
      * @returns `a - b` as a FiniteNumber
-     * @example
-     * ```typescript
-     * FiniteNumber.sub(asFiniteNumber(8.7), asFiniteNumber(3.2)); // FiniteNumber (5.5)
-     * ```
      */
     readonly sub: (x: FiniteNumber, y: FiniteNumber) => FiniteNumber;
     /**
      * Multiplies two finite numbers.
+     *
      * @param a - First finite number
      * @param b - Second finite number
      * @returns `a * b` as a FiniteNumber
-     * @example
-     * ```typescript
-     * FiniteNumber.mul(asFiniteNumber(5.5), asFiniteNumber(2)); // FiniteNumber (11)
-     * ```
      */
     readonly mul: (x: FiniteNumber, y: FiniteNumber) => FiniteNumber;
     /**
      * Divides two finite numbers.
      *
-     * The divisor must be non-zero (enforced by type constraints).
-     * The result is guaranteed to be finite when both inputs are finite
-     * and the divisor is non-zero.
+     * The divisor must be non-zero (enforced by type constraints). The result is
+     * guaranteed to be finite when both inputs are finite and the divisor is
+     * non-zero.
      *
      * @param a - The dividend
      * @param b - The divisor (must be non-zero)
      * @returns The quotient `a / b` as a FiniteNumber
-     *
-     * @example
-     * ```typescript
-     * const a = asFiniteNumber(11);
-     * const b = asFiniteNumber(2);
-     *
-     * FiniteNumber.div(a, b); // FiniteNumber (5.5)
-     *
-     * // With non-zero type guard
-     * const divisor = asFiniteNumber(userInput);
-     * if (Num.isNonZero(divisor)) {
-     *   const result = FiniteNumber.div(a, divisor);
-     * }
-     * ```
      */
     readonly div: (x: FiniteNumber, y: number & {
         readonly NaNValue: false;

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

@@ -1 +1 @@
-{"version":3,"file":"finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,YAAY,CAAC;AAgDhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;OAOG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;OASG;wBArLA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAuL3D;;;;;;;;;OASG;uBA3LA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA6L3D;;;;;;;;;;OAUG;wBAlMA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAoM3D;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,YAAY,CAAC;AAgDhC;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;wBAlGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAoG3D;;;;;;OAMG;uBArGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAuG3D;;;;;OAKG;wBAvGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAyG3D;;;;;;;;;OASG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;;;OAUG;;;;;;;;CAEK,CAAC"}

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

@@ -1,109 +1,55 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a finite number';
-const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
+const { abs, add, castType, div, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
     MIN_VALUE: -Number.MAX_VALUE,
     MAX_VALUE: Number.MAX_VALUE,
     typeNameInMessage,
 });
 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);
 /**
  * Type guard that checks if a value is a finite number.
  *
- * Returns `true` if the value is a finite number (not NaN, Infinity, or -Infinity).
- * This is stricter than the standard number type, which includes these special values.
+ * Returns `true` if the value is a finite number (not NaN, Infinity, or
+ * -Infinity). This is stricter than the standard number type, which includes
+ * these special values.
  *
  * @param value - The value to check
  * @returns `true` if the value is finite, `false` otherwise
- *
- * @example
- * ```typescript
- * isFiniteNumber(42);          // true
- * isFiniteNumber(3.14);        // true
- * isFiniteNumber(-0);          // true
- * isFiniteNumber(Infinity);    // false
- * isFiniteNumber(-Infinity);   // false
- * isFiniteNumber(NaN);         // false
- * isFiniteNumber(1/0);         // false (Infinity)
- * ```
  */
 const isFiniteNumber = is;
 /**
  * Casts a number to a FiniteNumber branded type.
  *
- * This function validates that the input is finite (not NaN, Infinity, or -Infinity)
- * and returns it with the FiniteNumber brand. This ensures type safety for operations
- * that require finite numeric values.
+ * This function validates that the input is finite (not NaN, Infinity, or
+ * -Infinity) and returns it with the FiniteNumber brand. This ensures type
+ * safety for operations that require finite numeric values.
  *
  * @param value - The value to cast
  * @returns The value as a FiniteNumber branded type
  * @throws {TypeError} If the value is NaN, Infinity, or -Infinity
- *
- * @example
- * ```typescript
- * const x = asFiniteNumber(5.5);   // FiniteNumber
- * const y = asFiniteNumber(-10);   // FiniteNumber
- * const z = asFiniteNumber(0);     // FiniteNumber
- *
- * // These throw TypeError:
- * // asFiniteNumber(Infinity);     // Not finite
- * // asFiniteNumber(-Infinity);    // Not finite
- * // asFiniteNumber(NaN);          // Not a number
- * // asFiniteNumber(Math.sqrt(-1)); // Results in NaN
- * ```
  */
 const asFiniteNumber = castType;
 /**
  * Namespace providing type-safe operations for FiniteNumber branded types.
  *
  * The FiniteNumber type represents any finite numeric value, excluding the
- * special values NaN, Infinity, and -Infinity. All operations are guaranteed
- * to maintain the finite constraint when given finite inputs.
+ * special values NaN, Infinity, and -Infinity. All operations are guaranteed to
+ * maintain the finite constraint when given finite inputs.
  *
  * This type is essential for:
+ *
  * - Mathematical operations that require real numbers
  * - Preventing NaN/Infinity propagation in calculations
  * - Ensuring numeric stability in algorithms
- *
- * @example
- * ```typescript
- * // Type validation
- * FiniteNumber.is(3.14);       // true
- * FiniteNumber.is(Infinity);   // false
- * FiniteNumber.is(0/0);        // false (NaN)
- *
- * // Arithmetic with guaranteed finite results
- * const a = asFiniteNumber(10.5);
- * const b = asFiniteNumber(3.2);
- *
- * const sum = FiniteNumber.add(a, b);      // FiniteNumber (13.7)
- * const diff = FiniteNumber.sub(a, b);     // FiniteNumber (7.3)
- * const product = FiniteNumber.mul(a, b);  // FiniteNumber (33.6)
- * const quotient = FiniteNumber.div(a, b); // FiniteNumber (3.28125)
- * const power = FiniteNumber.pow(a, asFiniteNumber(2)); // FiniteNumber (110.25)
- *
- * // Rounding to integers
- * const value = asFiniteNumber(5.7);
- * const floored = FiniteNumber.floor(value);  // Int (5)
- * const ceiled = FiniteNumber.ceil(value);    // Int (6)
- * const rounded = FiniteNumber.round(value);  // Int (6)
- *
- * // Utility operations
- * const absolute = FiniteNumber.abs(asFiniteNumber(-42.5)); // FiniteNumber (42.5)
- * const minimum = FiniteNumber.min(a, b, asFiniteNumber(5)); // FiniteNumber (3.2)
- * const maximum = FiniteNumber.max(a, b, asFiniteNumber(5)); // FiniteNumber (10.5)
- *
- * // Random generation
- * const rand = FiniteNumber.random(asFiniteNumber(0), asFiniteNumber(1)); // Random in [0, 1]
- * ```
  */
 const FiniteNumber = {
     /**
@@ -111,19 +57,14 @@ const FiniteNumber = {
      *
      * @param value - The value to check
      * @returns `true` if the value is finite, `false` otherwise
-     *
      * @see {@link isFiniteNumber} for usage examples
      */
     is,
     /**
      * Returns the absolute value of a finite number.
+     *
      * @param x - The finite number to get the absolute value of
      * @returns The absolute value as a FiniteNumber
-     * @example
-     * ```typescript
-     * FiniteNumber.abs(asFiniteNumber(-5.5)); // FiniteNumber (5.5)
-     * FiniteNumber.abs(asFiniteNumber(3.2)); // FiniteNumber (3.2)
-     * ```
      */
     abs,
     /**
@@ -131,16 +72,6 @@ const FiniteNumber = {
      *
      * @param values - The finite numbers to compare (at least one required)
      * @returns The smallest value as a FiniteNumber
-     *
-     * @example
-     * ```typescript
-     * const a = asFiniteNumber(5.5);
-     * const b = asFiniteNumber(3.2);
-     * const c = asFiniteNumber(7.8);
-     *
-     * FiniteNumber.min(a, b);      // FiniteNumber (3.2)
-     * FiniteNumber.min(a, b, c);   // FiniteNumber (3.2)
-     * ```
      */
     min: min_,
     /**
@@ -148,146 +79,83 @@ const FiniteNumber = {
      *
      * @param values - The finite numbers to compare (at least one required)
      * @returns The largest value as a FiniteNumber
-     *
-     * @example
-     * ```typescript
-     * const a = asFiniteNumber(5.5);
-     * const b = asFiniteNumber(3.2);
-     * const c = asFiniteNumber(7.8);
-     *
-     * FiniteNumber.max(a, b);      // FiniteNumber (7.8)
-     * FiniteNumber.max(a, b, c);   // FiniteNumber (7.8)
-     * ```
      */
     max: max_,
     /**
      * Returns the largest integer less than or equal to the given finite number.
+     *
      * @param x - The finite number to floor
      * @returns The floor value as an Int
-     * @example
-     * ```typescript
-     * FiniteNumber.floor(asFiniteNumber(5.8)); // Int (5)
-     * FiniteNumber.floor(asFiniteNumber(-5.2)); // Int (-6)
-     * ```
      */
     floor,
     /**
-     * Returns the smallest integer greater than or equal to the given finite number.
+     * Returns the smallest integer greater than or equal to the given finite
+     * number.
+     *
      * @param x - The finite number to ceil
      * @returns The ceiling value as an Int
-     * @example
-     * ```typescript
-     * FiniteNumber.ceil(asFiniteNumber(5.2)); // Int (6)
-     * FiniteNumber.ceil(asFiniteNumber(-5.8)); // Int (-5)
-     * ```
      */
     ceil,
     /**
      * Rounds a finite number to the nearest integer.
+     *
      * @param x - The finite number to round
      * @returns The rounded value as an Int
-     * @example
-     * ```typescript
-     * FiniteNumber.round(asFiniteNumber(5.4)); // Int (5)
-     * FiniteNumber.round(asFiniteNumber(5.6)); // Int (6)
-     * FiniteNumber.round(asFiniteNumber(5.5)); // Int (6)
-     * ```
      */
     round,
     /**
      * Generates a random finite number within the specified range.
      *
-     * The generated value is uniformly distributed in the range [min, max].
-     * Both bounds are inclusive.
+     * The generated value is uniformly distributed in the range [min, max]. Both
+     * bounds are inclusive.
      *
      * @param min - The minimum value (inclusive)
      * @param max - The maximum value (inclusive)
      * @returns A random FiniteNumber in the range [min, max]
-     *
-     * @example
-     * ```typescript
-     * // Random percentage (0-100)
-     * const pct = FiniteNumber.random(
-     *   asFiniteNumber(0),
-     *   asFiniteNumber(100)
-     * );
-     *
-     * // Random coordinate (-1 to 1)
-     * const coord = FiniteNumber.random(
-     *   asFiniteNumber(-1),
-     *   asFiniteNumber(1)
-     * );
-     * ```
      */
     random,
     /**
      * Raises a finite number to a power.
+     *
      * @param a - The base finite number
      * @param b - The exponent finite number
      * @returns `a ** b` as a FiniteNumber
-     * @example
-     * ```typescript
-     * FiniteNumber.pow(asFiniteNumber(2.5), asFiniteNumber(3)); // FiniteNumber (15.625)
-     * ```
      */
     pow,
     /**
      * Adds two finite numbers.
+     *
      * @param a - First finite number
      * @param b - Second finite number
      * @returns `a + b` as a FiniteNumber
-     * @example
-     * ```typescript
-     * FiniteNumber.add(asFiniteNumber(5.5), asFiniteNumber(3.2)); // FiniteNumber (8.7)
-     * ```
      */
     add,
     /**
      * Subtracts two finite numbers.
+     *
      * @param a - First finite number
      * @param b - Second finite number
      * @returns `a - b` as a FiniteNumber
-     * @example
-     * ```typescript
-     * FiniteNumber.sub(asFiniteNumber(8.7), asFiniteNumber(3.2)); // FiniteNumber (5.5)
-     * ```
      */
     sub,
     /**
      * Multiplies two finite numbers.
+     *
      * @param a - First finite number
      * @param b - Second finite number
      * @returns `a * b` as a FiniteNumber
-     * @example
-     * ```typescript
-     * FiniteNumber.mul(asFiniteNumber(5.5), asFiniteNumber(2)); // FiniteNumber (11)
-     * ```
      */
     mul,
     /**
      * Divides two finite numbers.
      *
-     * The divisor must be non-zero (enforced by type constraints).
-     * The result is guaranteed to be finite when both inputs are finite
-     * and the divisor is non-zero.
+     * The divisor must be non-zero (enforced by type constraints). The result is
+     * guaranteed to be finite when both inputs are finite and the divisor is
+     * non-zero.
      *
      * @param a - The dividend
      * @param b - The divisor (must be non-zero)
      * @returns The quotient `a / b` as a FiniteNumber
-     *
-     * @example
-     * ```typescript
-     * const a = asFiniteNumber(11);
-     * const b = asFiniteNumber(2);
-     *
-     * FiniteNumber.div(a, b); // FiniteNumber (5.5)
-     *
-     * // With non-zero type guard
-     * const divisor = asFiniteNumber(userInput);
-     * if (Num.isNonZero(divisor)) {
-     *   const result = FiniteNumber.div(a, divisor);
-     * }
-     * ```
      */
     div,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"finite-number.mjs","sources":["../../../src/number/branded-types/finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iBAAiB;AAE3C,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,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;AAM7E;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;AASG;IACH,KAAK;AAEL;;;;;;;;;AASG;IACH,IAAI;AAEJ;;;;;;;;;;AAUG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"finite-number.mjs","sources":["../../../src/number/branded-types/finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iBAAiB;AAE3C,MAAM,EACJ,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,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;AAM7E;;;;;;;;;AASG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;AAUG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;AAYG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;AAMG;IACH,EAAE;AAEF;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;;AAMG;IACH,IAAI;AAEJ;;;;;AAKG;IACH,KAAK;AAEL;;;;;;;;;AASG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;;;;AAUG;IACH,GAAG;;;;;"}