ts-data-forge 3.3.0 → 3.3.1

package/dist/number/num.mjs

@@ -1,7 +1,9 @@
 /**
  * Namespace providing utility functions for number manipulation and validation.
  *
- * This namespace offers a comprehensive set of type-safe number utilities including:
+ * This namespace offers a comprehensive set of type-safe number utilities
+ * including:
+ *
  * - Type conversion and validation
  * - Type guards for numeric constraints (non-zero, non-negative, positive)
  * - Range checking and clamping operations
@@ -10,203 +12,197 @@
  *
  * Many functions in this namespace leverage TypeScript's type system to provide
  * compile-time guarantees about numeric constraints.
- *
- * @example
- * ```typescript
- * // Type conversion
- * const num = Num.from('123.45'); // 123.45
- * const invalid = Num.from('abc'); // NaN
- *
- * // Type guards
- * const value = 5;
- * if (Num.isPositive(value)) {
- *   // value is typed as PositiveNumber & 5
- * }
- *
- * // Range checking
- * const isValid = Num.isInRange(0, 100)(50); // true
- *
- * // Clamping
- * const clamped = Num.clamp(150, 0, 100); // 100
- * const clampFn = Num.clamp(0, 100);
- * const result = clampFn(150); // 100
- * ```
  */
 var Num;
 (function (Num) {
     /**
      * Converts an unknown value to a number. Alias for the `Number` constructor.
-     * @param n The value to convert.
-     * @returns The numeric representation of `n`.
+     *
      * @example
-     * ```typescript
-     * Num.from('123.45'); // 123.45
-     * Num.from('hello'); // NaN
+     *
+     * ```ts
+     * const input = '123.45';
+     *
+     * const result = Num.from(input);
+     *
+     * assert(result === 123.45);
      * ```
+     *
+     * @param n The value to convert.
+     * @returns The numeric representation of `n`.
      */
     Num.from = Number;
     /**
      * Type guard that checks if a number is non-zero.
      *
-     * When this function returns `true`, TypeScript narrows the type to exclude zero,
-     * providing compile-time safety for division operations and other calculations
-     * that require non-zero values.
-     *
-     * @template N - The numeric literal type or number type to check
-     * @param num - The number to check
-     * @returns `true` if the number is not zero, `false` otherwise
+     * When this function returns `true`, TypeScript narrows the type to exclude
+     * zero, providing compile-time safety for division operations and other
+     * calculations that require non-zero values.
      *
      * @example
-     * ```typescript
-     * const value = 5;
+     *
+     * ```ts
+     * const value: number = 5;
+     *
      * if (Num.isNonZero(value)) {
-     *   // value is typed as NonZeroNumber & 5
-     *   const result = 10 / value; // Safe division
+     *   // 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);
      * }
      *
-     * // Works with numeric literals
-     * const literal = 0 as 0 | 1 | 2;
-     * if (Num.isNonZero(literal)) {
-     *   // literal is typed as 1 | 2
-     * }
+     * assert.notOk(Num.isNonZero(0));
      * ```
+     *
+     * @template N - The numeric literal type or number type to check
+     * @param num - The number to check
+     * @returns `true` if the number is not zero, `false` otherwise
      */
     Num.isNonZero = (num) => num !== 0;
     /**
-     * Type guard that checks if a number is non-negative (greater than or equal to zero).
+     * Type guard that checks if a number is non-negative (greater than or equal
+     * to zero).
      *
-     * When this function returns `true`, TypeScript narrows the type to exclude negative
-     * values, which is useful for operations that require non-negative inputs like
-     * array indices or measurements.
-     *
-     * @template N - The numeric literal type or number type to check
-     * @param num - The number to check
-     * @returns `true` if the number is >= 0, `false` otherwise
+     * When this function returns `true`, TypeScript narrows the type to exclude
+     * negative values, which is useful for operations that require non-negative
+     * inputs like array indices or measurements.
      *
      * @example
-     * ```typescript
-     * const value = 10;
-     * if (Num.isNonNegative(value)) {
-     *   // value is typed as NonNegativeNumber & 10
-     *   const arr = new Array(value); // Safe array creation
-     * }
      *
-     * // Type narrowing with unions
-     * const index = -1 as -1 | 0 | 1;
-     * if (Num.isNonNegative(index)) {
-     *   // index is typed as 0 | 1
+     * ```ts
+     * const candidate = 10;
+     *
+     * if (Num.isNonNegative(candidate)) {
+     *   const index: number = candidate;
+     *   assert(index === 10);
      * }
+     *
+     * assert.notOk(Num.isNonNegative(-1));
      * ```
+     *
+     * @template N - The numeric literal type or number type to check
+     * @param num - The number to check
+     * @returns `true` if the number is >= 0, `false` otherwise
      */
     Num.isNonNegative = (num) => num >= 0;
     /**
      * Type guard that checks if a number is positive (greater than zero).
      *
-     * When this function returns `true`, TypeScript narrows the type to exclude zero
-     * and negative values. This is particularly useful for validating inputs that
-     * must be strictly positive, such as dimensions, counts, or rates.
-     *
-     * @template N - The numeric literal type or number type to check
-     * @param num - The number to check
-     * @returns `true` if the number is > 0, `false` otherwise
+     * When this function returns `true`, TypeScript narrows the type to exclude
+     * zero and negative values. This is particularly useful for validating inputs
+     * that must be strictly positive, such as dimensions, counts, or rates.
      *
      * @example
-     * ```typescript
-     * const count = 5;
-     * if (Num.isPositive(count)) {
-     *   // count is typed as PositiveNumber & 5
-     *   const average = total / count; // Safe division
-     * }
      *
-     * // Type narrowing with numeric literals
-     * const value = 0 as -1 | 0 | 1 | 2;
-     * if (Num.isPositive(value)) {
-     *   // value is typed as 1 | 2
+     * ```ts
+     * const amount = 42;
+     *
+     * if (Num.isPositive(amount)) {
+     *   assert.ok(amount > 0);
      * }
+     *
+     * assert.notOk(Num.isPositive(0));
      * ```
+     *
+     * @template N - The numeric literal type or number type to check
+     * @param num - The number to check
+     * @returns `true` if the number is > 0, `false` otherwise
      */
     Num.isPositive = (num) => num > 0;
     /**
-     * Creates a function that checks if a number `x` is within the range `lowerBound <= x < upperBound`.
-     * @param lowerBound The lower bound (inclusive).
-     * @param upperBound The upper bound (exclusive).
-     * @returns A function that takes a number `x` and returns `true` if `x` is in the range, `false` otherwise.
+     * Creates a function that checks if a number `x` is within the range
+     * `lowerBound <= x < upperBound`.
+     *
      * @example
-     * ```typescript
-     * const isInRange0to10 = Num.isInRange(0, 10);
-     * isInRange0to10(5); // true
-     * isInRange0to10(0); // true (inclusive lower bound)
-     * isInRange0to10(10); // false (exclusive upper bound)
-     * isInRange0to10(-1); // false
+     *
+     * ```ts
+     * const isGrade = Num.isInRange(0, 100);
+     *
+     * assert.ok(isGrade(50));
+     * assert.notOk(isGrade(100));
      * ```
+     *
+     * @param lowerBound The lower bound (inclusive).
+     * @param upperBound The upper bound (exclusive).
+     * @returns A function that takes a number `x` and returns `true` if `x` is in
+     *   the range, `false` otherwise.
      */
     Num.isInRange = (lowerBound, upperBound) => (x) => lowerBound <= x && x < upperBound;
     /**
-     * Creates a function that checks if a number `x` is within the range `lowerBound <= x <= upperBound`.
-     * @param lowerBound The lower bound (inclusive).
-     * @param upperBound The upper bound (inclusive).
-     * @returns A function that takes a number `x` and returns `true` if `x` is in the range, `false` otherwise.
+     * Creates a function that checks if a number `x` is within the range
+     * `lowerBound <= x <= upperBound`.
+     *
      * @example
-     * ```typescript
-     * const inRange = Num.isInRangeInclusive(1, 10);
-     * console.log(inRange(1));   // true (lower bound)
-     * console.log(inRange(5));   // true
-     * console.log(inRange(10));  // true (upper bound)
-     * console.log(inRange(11));  // false
+     *
+     * ```ts
+     * const isPercentage = Num.isInRangeInclusive(0, 100);
+     *
+     * assert.ok(isPercentage(100));
+     * assert.notOk(isPercentage(-1));
      * ```
+     *
+     * @param lowerBound The lower bound (inclusive).
+     * @param upperBound The upper bound (inclusive).
+     * @returns A function that takes a number `x` and returns `true` if `x` is in
+     *   the range, `false` otherwise.
      */
     Num.isInRangeInclusive = (lowerBound, upperBound) => (x) => lowerBound <= x && x <= upperBound;
     /**
-     * Creates a type guard that checks if a number is an unsigned integer within a specified range.
+     * Creates a type guard that checks if a number is an unsigned integer within
+     * a specified range.
      *
      * This function returns a predicate that validates whether a number is:
+     *
      * - A safe integer (no floating point)
      * - Within the range [lowerBound, upperBound)
      *
      * The returned type guard provides precise type narrowing when the bounds are
      * SmallUint literals, making it ideal for array index validation.
      *
+     * @example
+     *
+     * ```ts
+     * const indexGuard = Num.isUintInRange(0, 5);
+     *
+     * assert.ok(indexGuard(3));
+     * assert.notOk(indexGuard(5));
+     * assert.notOk(indexGuard(-1));
+     * ```
+     *
      * @template L - The lower bound as a SmallUint literal type
      * @template U - The upper bound as a SmallUint literal type
      * @param lowerBound - The minimum value (inclusive)
      * @param upperBound - The maximum value (exclusive)
      * @returns A type guard function that validates and narrows number types
-     *
-     * @example
-     * ```typescript
-     * // Custom range validation
-     * const isValidPercentage = Num.isUintInRange(0, 101);
-     * if (isValidPercentage(value)) {
-     *   // value is typed as 0 | 1 | ... | 100
-     * }
-     * ```
      */
     Num.isUintInRange = (lowerBound, upperBound) => (x) => Number.isSafeInteger(x) && lowerBound <= x && x < upperBound;
     /**
-     * Creates a type guard that checks if a number is an unsigned integer within a specified inclusive range.
+     * Creates a type guard that checks if a number is an unsigned integer within
+     * a specified inclusive range.
      *
      * This function returns a predicate that validates whether a number is:
+     *
      * - A safe integer (no floating point)
      * - Within the range [lowerBound, upperBound] (both bounds inclusive)
      *
      * The returned type guard provides precise type narrowing when the bounds are
-     * SmallUint literals, useful for validating scores, percentages, or other bounded values.
+     * SmallUint literals, useful for validating scores, percentages, or other
+     * bounded values.
+     *
+     * @example
+     *
+     * ```ts
+     * const inclusiveGuard = Num.isUintInRangeInclusive(0, 5);
+     *
+     * assert.ok(inclusiveGuard(5));
+     * assert.notOk(inclusiveGuard(6));
+     * ```
      *
      * @template L - The lower bound as a SmallUint literal type
      * @template U - The upper bound as a SmallUint literal type
      * @param lowerBound - The minimum value (inclusive)
      * @param upperBound - The maximum value (inclusive)
      * @returns A type guard function that validates and narrows number types
-     *
-     * @example
-     * ```typescript
-     * const isValidScore = Num.isUintInRangeInclusive(0, 100);
-     * const score: number = getTestScore();
-     * if (isValidScore(score)) {
-     *   // score is typed as 0 | 1 | 2 | ... | 100
-     *   const grade = calculateGrade(score);
-     * }
-     * ```
      */
     Num.isUintInRangeInclusive = (lowerBound, upperBound) => (x) => Number.isSafeInteger(x) && lowerBound <= x && x <= upperBound;
     function clamp(...args) {
@@ -227,31 +223,17 @@ var Num;
     /**
      * Performs type-safe division with compile-time zero-check.
      *
-     * This function leverages TypeScript's type system to prevent division by zero
-     * at compile time. The divisor must be typed as NonZeroNumber or a non-zero
-     * numeric literal.
+     * This function leverages TypeScript's type system to prevent division by
+     * zero at compile time. The divisor must be typed as NonZeroNumber or a
+     * non-zero numeric literal.
      *
      * @param a - The dividend
      * @param b - The divisor (must be non-zero, enforced by types)
      * @returns The quotient of a / b
-     *
-     * @example
-     * ```typescript
-     * const result = Num.div(10, 2); // 5
-     * // Num.div(10, 0); // ❌ TypeScript error: Type '0' is not assignable
-     *
-     * // With type guards
-     * const divisor: number = getDivisor();
-     * if (Num.isNonZero(divisor)) {
-     *   const result = Num.div(100, divisor); // ✅ Safe
-     * }
-     *
-     * // With branded types
-     * const nonZero = asNonZeroNumber(5);
-     * const result3 = Num.div(20, nonZero); // 4
-     * ```
      */
-    Num.div = (a, b) => a / b;
+    Num.div = (a, b) => 
+    // eslint-disable-next-line total-functions/no-partial-division
+    a / b;
     /**
      * Performs integer division using floor division.
      *
@@ -264,32 +246,23 @@ var Num;
      * @param a - The dividend
      * @param b - The divisor
      * @returns The integer quotient, or `NaN` if b is zero
-     *
-     * @example
-     * ```typescript
-     * Num.divInt(10, 3);   // 3
-     * Num.divInt(10, -3);  // -4 (floor division)
-     * ```
      */
-    Num.divInt = (a, b) => Math.floor(Math.floor(a) / Math.floor(b));
+    Num.divInt = (a, b) => 
+    // eslint-disable-next-line total-functions/no-partial-division
+    Math.floor(Math.floor(a) / Math.floor(b));
     /**
      * Rounds a number to a specified number of decimal places.
      *
-     * Uses the standard rounding algorithm (round half up) to round the number
-     * to the given precision. The precision must be a positive safe integer.
+     * Uses the standard rounding algorithm (round half up) to round the number to
+     * the given precision. The precision must be a positive safe integer.
      *
      * @param num - The number to round
      * @param precision - The number of decimal places (must be positive)
      * @returns The rounded number
-     *
-     * @example
-     * ```typescript
-     * Num.roundAt(3.14159, 2);   // 3.14
-     * Num.roundAt(10.5, 0);      // 11
-     * ```
      */
     Num.roundAt = (num, precision) => {
         const digit = 10 ** precision;
+        // eslint-disable-next-line total-functions/no-partial-division
         return Math.round(num * digit) / digit;
     };
     /**
@@ -301,35 +274,24 @@ var Num;
      *
      * @param num - The number to round
      * @returns The rounded integer as an Int branded type
-     *
-     * @example
-     * ```typescript
-     * Num.roundToInt(3.2);   // 3
-     * Num.roundToInt(3.5);   // 4
-     * ```
      */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     Num.roundToInt = (num) => (0 | (num + 0.5));
     /**
      * Creates a reusable rounding function with a fixed precision.
      *
-     * This is a curried version of roundAt that returns a function configured
-     * to always round to the specified number of decimal places. Useful for
-     * creating consistent rounding behavior across multiple values.
+     * This is a curried version of roundAt that returns a function configured to
+     * always round to the specified number of decimal places. Useful for creating
+     * consistent rounding behavior across multiple values.
      *
      * @param digit - The number of decimal places for rounding
      * @returns A function that rounds numbers to the specified precision
-     *
-     * @example
-     * ```typescript
-     * const roundTo2 = Num.round(2);
-     * roundTo2(3.14159);  // 3.14
-     * roundTo2(2.71828);  // 2.72
-     * ```
      */
     Num.round = (digit) => {
         const powAmount = 10 ** digit;
-        return (target) => Num.roundToInt(powAmount * target) / powAmount;
+        return (target) => 
+        // eslint-disable-next-line total-functions/no-partial-division
+        Num.roundToInt(powAmount * target) / powAmount;
     };
     /**
      * Converts NaN values to undefined while preserving all other numbers.
@@ -341,56 +303,38 @@ var Num;
      * @template N - The numeric type (literal or number)
      * @param num - The number to check
      * @returns The original number if not NaN, otherwise undefined
-     *
-     * @example
-     * ```typescript
-     * Num.mapNaN2Undefined(42);   // 42
-     * Num.mapNaN2Undefined(NaN);  // undefined
-     * ```
      */
     Num.mapNaN2Undefined = (num) => Number.isNaN(num)
         ? undefined
-        : // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
             num;
     /**
      * Type-safe increment operation for SmallUint values.
      *
-     * Increments a SmallUint (0-40) by 1 with the result type computed at
-     * compile time. This provides type-level arithmetic for small unsigned
-     * integers, useful for type-safe counter operations.
+     * Increments a SmallUint (0-40) by 1 with the result type computed at compile
+     * time. This provides type-level arithmetic for small unsigned integers,
+     * useful for type-safe counter operations.
      *
      * @template N - A SmallUint literal type (0-40)
      * @param n - The SmallUint value to increment
      * @returns The incremented value with type Increment<N>
-     *
-     * @example
-     * ```typescript
-     * const zero = 0 as 0;
-     * const one = Num.increment(zero); // type is 1, value is 1
-     * ```
      */
     Num.increment = (n) => 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     (n + 1);
     /**
      * Type-safe decrement operation for positive SmallInt values.
      *
-     * Decrements a positive SmallInt (1-40) by 1 with the result type computed
-     * at compile time. This provides type-level arithmetic for small positive
+     * Decrements a positive SmallInt (1-40) by 1 with the result type computed at
+     * compile time. This provides type-level arithmetic for small positive
      * integers, useful for type-safe countdown operations.
      *
      * @template N - A positive SmallInt literal type (1-40)
      * @param n - The positive SmallInt value to decrement
      * @returns The decremented value with type Decrement<N>
-     *
-     * @example
-     * ```typescript
-     * const three = 3 as 3;
-     * const two = Num.decrement(three); // type is 2, value is 2
-     * ```
      */
     Num.decrement = (n) => 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     (n - 1);
 })(Num || (Num = {}));
 

package/dist/number/num.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"num.mjs","sources":["../../src/number/num.mts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;IACc;AAAjB,CAAA,UAAiB,GAAG,EAAA;AAClB;;;;;;;;;AASG;IACU,GAAA,CAAA,IAAI,GAA2B,MAAM;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;IACU,GAAA,CAAA,SAAS,GAAG,CACvB,GAAM,KAC0C,GAAG,KAAK,CAAC;AAI3D;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;IACU,GAAA,CAAA,aAAa,GAAG,CAC3B,GAAM,KAEN,GAAG,IAAI,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;IACU,GAAA,CAAA,UAAU,GAAG,CACxB,GAAM,KAEN,GAAG,GAAG,CAAC;AAET;;;;;;;;;;;;;AAaG;IACU,GAAA,CAAA,SAAS,GACpB,CAAC,UAAkB,EAAE,UAAkB,KACvC,CAAC,CAAS,KACR,UAAU,IAAI,CAAC,IAAI,CAAC,GAAG,UAAU;AAErC;;;;;;;;;;;;;AAaG;IACU,GAAA,CAAA,kBAAkB,GAC7B,CAAC,UAAkB,EAAE,UAAkB,KACvC,CAAC,CAAS,KACR,UAAU,IAAI,CAAC,IAAI,CAAC,IAAI,UAAU;AAgCtC;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACU,GAAA,CAAA,aAAa,GACxB,CAA2C,UAAa,EAAE,UAAa,KACvE,CAAC,CAAS,KACR,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,UAAU,IAAI,CAAC,IAAI,CAAC,GAAG,UAAU;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;IACU,GAAA,CAAA,sBAAsB,GACjC,CAA2C,UAAa,EAAE,UAAa,KACvE,CAAC,CAAS,KACR,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,UAAU,IAAI,CAAC,IAAI,CAAC,IAAI,UAAU;IAgCjE,SAAgB,KAAK,CACnB,GAAG,IAEkD,EAAA;AAErD,QAAA,QAAQ,IAAI,CAAC,MAAM;YACjB,KAAK,CAAC,EAAE;gBACN,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,GAAG,IAAI;AAC7C,gBAAA,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM;AAC5B,sBAAE;AACF,sBAAE,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;;YAGxD,KAAK,CAAC,EAAE;AACN,gBAAA,MAAM,CAAC,UAAU,EAAE,UAAU,CAAC,GAAG,IAAI;AACrC,gBAAA,OAAO,CAAC,MAAc,KACpB,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC;;;;AAhB7B,IAAA,GAAA,CAAA,KAAK,QAmBpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;IACU,GAAA,CAAA,GAAG,GAAG,CAAC,CAAS,EAAE,CAAkC,KAC/D,CAAC,GAAG,CAAC;AAEP;;;;;;;;;;;;;;;;;;AAkBG;IACU,GAAA,CAAA,MAAM,GAAG,CACpB,CAAS,EACT,CAAkC,KACvB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAEtD;;;;;;;;;;;;;;;AAeG;AACU,IAAA,GAAA,CAAA,OAAO,GAAG,CACrB,GAAW,EACX,SAAsC,KAC5B;AACV,QAAA,MAAM,KAAK,GAAG,EAAE,IAAI,SAAS;QAE7B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,KAAK;AACxC,IAAA,CAAC;AAED;;;;;;;;;;;;;;;AAeG;;AAEU,IAAA,GAAA,CAAA,UAAU,GAAG,CAAC,GAAW,MAAW,CAAC,IAAI,GAAG,GAAG,GAAG,CAAC,CAAQ;AAExE;;;;;;;;;;;;;;;;AAgBG;AACU,IAAA,GAAA,CAAA,KAAK,GAAG,CACnB,KAAkC,KACL;AAC7B,QAAA,MAAM,SAAS,GAAG,EAAE,IAAI,KAAK;AAE7B,QAAA,OAAO,CAAC,MAAc,KAAK,GAAA,CAAA,UAAU,CAAC,SAAS,GAAG,MAAM,CAAC,GAAG,SAAS;AACvE,IAAA,CAAC;AAED;;;;;;;;;;;;;;;;AAgBG;IACU,GAAA,CAAA,gBAAgB,GAAG,CAC9B,GAAM,KAEN,MAAM,CAAC,KAAK,CAAC,GAAG;AACd,UAAE;AACF;AACG,YAAA,GAAkC;AAEzC;;;;;;;;;;;;;;;;AAgBG;AACU,IAAA,GAAA,CAAA,SAAS,GAAG,CAAsB,CAAI;;AAEjD,KAAC,CAAC,GAAG,CAAC,CAAiB;AAEzB;;;;;;;;;;;;;;;;AAgBG;AACU,IAAA,GAAA,CAAA,SAAS,GAAG,CAA6B,CAAI;;AAExD,KAAC,CAAC,GAAG,CAAC,CAAiB;AAC3B,CAAC,EA5dgB,GAAG,KAAH,GAAG,GAAA,EAAA,CAAA,CAAA;;;;"}
+{"version":3,"file":"num.mjs","sources":["../../src/number/num.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}