ts-data-forge 14.6.1 → 14.6.2

package/dist/number/num.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"num.mjs","sources":["../../src/number/num.mts"],"sourcesContent":["import {\n  type Decrement,\n  type FiniteNumber,\n  type Increment,\n  type Index,\n  type Int,\n  type Min,\n  type NaNType,\n  type NegativeIndex,\n  type NonNegativeNumber,\n  type NonZeroNumber,\n  type PositiveNumber,\n  type PositiveSafeIntWithSmallInt,\n  type RelaxedExclude,\n  type SmallInt,\n  type SmallUint,\n  type UnknownBrand,\n} from 'ts-type-forge';\nimport { expectType } from '../expect-type.mjs';\nimport { Result } from '../functional/index.mjs';\nimport { type SmallPositiveInt } from '../types.mjs';\nimport {\n  type AddResult,\n  type DivIntResult,\n  type DivResult,\n  type MulResult,\n  type SubResult,\n} from './num-arithmetic-types.mjs';\n\n/**\n * Namespace providing utility functions for number manipulation and validation.\n *\n * This namespace offers a comprehensive set of type-safe number utilities\n * including:\n *\n * - Type conversion and validation\n * - Type guards for numeric constraints (non-zero, non-negative, positive)\n * - Range checking and clamping operations\n * - Mathematical operations with type safety\n * - Rounding utilities\n *\n * Many functions in this namespace leverage TypeScript's type system to provide\n * compile-time guarantees about numeric constraints.\n */\nexport namespace Num {\n  /**\n   * Converts an unknown value to a number. Alias for the `Number` constructor.\n   *\n   * @example\n   *\n   * ```ts\n   * const input = '123.45';\n   *\n   * const result = Num.from(input);\n   *\n   * assert.isTrue(result === 123.45);\n   * ```\n   *\n   * @param n The value to convert.\n   * @returns The numeric representation of `n`.\n   */\n  export const from: (n: unknown) => number = Number;\n\n  /**\n   * Safely parses a base-10 integer from a string, returning a {@link Result}\n   * that is `Ok<Int>` for valid input and `Err<Error>` otherwise.\n   *\n   * This is a stricter alternative to both `parseInt` and `Number`:\n   *\n   * - Unlike `parseInt('12abc', 10)` (which returns `12`), trailing\n   *   non-numeric characters make the whole input invalid and yield `Err`.\n   * - Unlike `Number('')` / `Number('   ')` (which return `0`), empty or\n   *   whitespace-only input yields `Err`.\n   *\n   * The empty-string case is rejected by delegating to `parseInt` (which\n   * returns `NaN` there) rather than hard-coding a check, while the trailing-\n   * garbage case is rejected via `Number`. Valid input is truncated toward\n   * zero, so `'12.9'` becomes `12` and `'-3.5'` becomes `-3`.\n   *\n   * Only base 10 is supported. Use `Result.unwrapOk` (optionally with a\n   * `?? Number.NaN` fallback) or `Result.unwrapOkOr` to get a plain number\n   * back.\n   *\n   * @example\n   *\n   * ```ts\n   * assert.strictEqual(\n   *   Result.unwrapOkOr(Num.safeParseInt('123'), Number.NaN),\n   *   123,\n   * );\n   *\n   * assert.strictEqual(\n   *   Result.unwrapOkOr(Num.safeParseInt('12.9'), Number.NaN),\n   *   12,\n   * );\n   *\n   * assert.strictEqual(\n   *   Result.unwrapOkOr(Num.safeParseInt('-12.9'), Number.NaN),\n   *   -12,\n   * );\n   *\n   * assert.strictEqual(Number.parseInt('-12.9', 10), -12);\n   *\n   * // Native `parseInt` ignores trailing non-numeric characters\n   *\n   * assert.strictEqual(Number.parseInt('123abc', 10), 123);\n   *\n   * assert.isTrue(Number.isNaN(Number('123abc')));\n   *\n   * assert.isTrue(Result.isErr(Num.safeParseInt('123abc')));\n   *\n   * // Whitespace is not a valid integer, so we return an error instead of coercing to 0.\n   *\n   * assert.isTrue(Number.isNaN(Number.parseInt('  ', 10)));\n   *\n   * assert.strictEqual(Number('  '), 0); // Native `Number` coerces whitespace to 0\n   *\n   * assert.isTrue(Result.isErr(Num.safeParseInt('')));\n   *\n   * assert.strictEqual(Result.unwrapOk(Num.safeParseInt('  ')), undefined);\n   * ```\n   *\n   * @param s The string to parse.\n   * @returns `Result.ok(parsedInt)` for valid input, otherwise `Result.err`\n   *   wrapping an `Error` describing the invalid input.\n   */\n  export const safeParseInt = (s: string): Result<Int, Error> => {\n    const viaNumber = Number(s);\n\n    // `Number('')` / `Number('   ')` は 0 を返すが、`parseInt` は NaN を返す。\n    // 末尾不正文字 ('12abc' 等) は `Number` 側が NaN にするので、両者が共に\n    // 有効な場合のみ採用することで空文字・空白のみ・末尾不正をまとめて弾く。\n    return Number.isNaN(viaNumber) || Number.isNaN(Number.parseInt(s, 10))\n      ? Result.err(\n          new Error(`safeParseInt: \"${s}\" is not a valid base-10 integer`),\n        )\n      : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        Result.ok(Math.trunc(viaNumber) as Int);\n  };\n\n  /**\n   * Safely parses a finite floating-point number from a string, returning a\n   * {@link Result} that is `Ok<FiniteNumber>` for valid input and `Err<Error>`\n   * otherwise.\n   *\n   * This is a stricter alternative to both `parseFloat` and `Number`:\n   *\n   * - Unlike `parseFloat('12abc')` (which returns `12`), trailing non-numeric\n   *   characters make the whole input invalid and yield `Err`.\n   * - Unlike `Number('')` / `Number('   ')` (which return `0`), empty or\n   *   whitespace-only input yields `Err`.\n   * - Unlike `Number('Infinity')` (which returns `Infinity`), non-finite values\n   *   yield `Err`.\n   *\n   * The empty-string case is rejected by delegating to `parseFloat` (which\n   * returns `NaN` there) rather than hard-coding a check, while the trailing-\n   * garbage case is rejected via `Number`. Decimal values are preserved as-is,\n   * so `'12.9'` stays `12.9`.\n   *\n   * Use `Result.unwrapOk` (optionally with a `?? Number.NaN` fallback) or\n   * `Result.unwrapOkOr` to get a plain number back.\n   *\n   * @example\n   *\n   * ```ts\n   * assert.strictEqual(\n   *   Result.unwrapOkOr(Num.safeParseFloat('12.9'), Number.NaN),\n   *   12.9,\n   * );\n   *\n   * assert.strictEqual(\n   *   Result.unwrapOkOr(Num.safeParseFloat('-3.5'), Number.NaN),\n   *   -3.5,\n   * );\n   *\n   * assert.strictEqual(\n   *   Result.unwrapOkOr(Num.safeParseFloat('1e3'), Number.NaN),\n   *   1000,\n   * );\n   *\n   * // Native `parseFloat` ignores trailing non-numeric characters\n   *\n   * assert.strictEqual(Number.parseFloat('12px'), 12);\n   *\n   * assert.isTrue(Result.isErr(Num.safeParseFloat('12px')));\n   *\n   * // Whitespace is not a valid number, so we return an error instead of coercing to 0.\n   *\n   * assert.isTrue(Result.isErr(Num.safeParseFloat('')));\n   *\n   * assert.isTrue(Result.isErr(Num.safeParseFloat('   ')));\n   *\n   * // Infinity and NaN are not finite, so they are rejected.\n   *\n   * assert.isTrue(Result.isErr(Num.safeParseFloat('Infinity')));\n   *\n   * assert.isTrue(Result.isErr(Num.safeParseFloat('NaN')));\n   * ```\n   *\n   * @param s The string to parse.\n   * @returns `Result.ok(parsedFloat)` for valid finite input, otherwise\n   *   `Result.err` wrapping an `Error` describing the invalid input.\n   */\n  export const safeParseFloat = (s: string): Result<FiniteNumber, Error> => {\n    const viaNumber = Number(s);\n\n    // `Number('')` / `Number('   ')` は 0 を返すが、`parseFloat` は NaN を返す。\n    // 末尾不正文字 ('12abc' 等) は `Number` 側が NaN にするので、両者が共に\n    // 非 NaN かつ有限の場合のみ採用することで空文字・空白のみ・末尾不正・\n    // Infinity をまとめて弾く。\n    return Number.isNaN(viaNumber) ||\n      !Number.isFinite(viaNumber) ||\n      Number.isNaN(Number.parseFloat(s))\n      ? Result.err(\n          new Error(`safeParseFloat: \"${s}\" is not a valid finite number`),\n        )\n      : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        Result.ok(viaNumber as FiniteNumber);\n  };\n\n  /**\n   * Type guard that checks if a number is non-zero.\n   *\n   * When this function returns `true`, TypeScript narrows the type to exclude\n   * zero, providing compile-time safety for division operations and other\n   * calculations that require non-zero values.\n   *\n   * @example\n   *\n   * ```ts\n   * const value: number = 5;\n   *\n   * if (Num.isNonZero(value)) {\n   *   // Safe to divide now that we know value is non-zero\n   *   // eslint-disable-next-line total-functions/no-partial-division\n   *   const inverted = 1 / value;\n   *\n   *   assert.isTrue(inverted === 0.2);\n   * }\n   *\n   * assert.isFalse(Num.isNonZero(0));\n   * ```\n   *\n   * @template N - The numeric literal type or number type to check\n   * @param num - The number to check\n   * @returns `true` if the number is not zero, `false` otherwise\n   */\n  export const isNonZero = <N extends number>(\n    num: N,\n  ): num is NonZeroNumber & RelaxedExclude<N, 0> => num !== 0;\n\n  expectType<NonZeroNumber & RelaxedExclude<123, 0>, UnknownBrand>('<=');\n\n  /**\n   * Type guard that checks if a number is non-negative (greater than or equal\n   * to zero).\n   *\n   * When this function returns `true`, TypeScript narrows the type to exclude\n   * negative values, which is useful for operations that require non-negative\n   * inputs like array indices or measurements.\n   *\n   * @example\n   *\n   * ```ts\n   * const candidate = 10;\n   *\n   * if (Num.isNonNegative(candidate)) {\n   *   const index: number = candidate;\n   *\n   *   assert.isTrue(index === 10);\n   * }\n   *\n   * assert.isFalse(Num.isNonNegative(-1));\n   * ```\n   *\n   * @template N - The numeric literal type or number type to check\n   * @param num - The number to check\n   * @returns `true` if the number is >= 0, `false` otherwise\n   */\n  export const isNonNegative = <N extends number>(\n    num: N,\n  ): num is NonNegativeNumber & RelaxedExclude<N, NegativeIndex<1024>> =>\n    num >= 0;\n\n  /**\n   * Type guard that checks if a number is positive (greater than zero).\n   *\n   * When this function returns `true`, TypeScript narrows the type to exclude\n   * zero and negative values. This is particularly useful for validating inputs\n   * that must be strictly positive, such as dimensions, counts, or rates.\n   *\n   * @example\n   *\n   * ```ts\n   * const amount = 42;\n   *\n   * if (Num.isPositive(amount)) {\n   *   assert.isTrue(amount > 0);\n   * }\n   *\n   * assert.isFalse(Num.isPositive(0));\n   * ```\n   *\n   * @template N - The numeric literal type or number type to check\n   * @param num - The number to check\n   * @returns `true` if the number is > 0, `false` otherwise\n   */\n  export const isPositive = <N extends number>(\n    num: N,\n  ): num is PositiveNumber & RelaxedExclude<N, NegativeIndex<1024> | 0> =>\n    num > 0;\n\n  /**\n   * Creates a function that checks if a number `x` is within the range\n   * `lowerBound <= x < upperBound`.\n   *\n   * @example\n   *\n   * ```ts\n   * const isGrade = Num.isInRange(0, 100);\n   *\n   * assert.isTrue(isGrade(50));\n   *\n   * assert.isFalse(isGrade(100));\n   * ```\n   *\n   * @param lowerBound The lower bound (inclusive).\n   * @param upperBound The upper bound (exclusive).\n   * @returns A function that takes a number `x` and returns `true` if `x` is in\n   *   the range, `false` otherwise.\n   */\n  export const isInRange =\n    (lowerBound: number, upperBound: number) =>\n    (x: number): boolean =>\n      lowerBound <= x && x < upperBound;\n\n  /**\n   * Creates a function that checks if a number `x` is within the range\n   * `lowerBound <= x <= upperBound`.\n   *\n   * @example\n   *\n   * ```ts\n   * const isPercentage = Num.isInRangeInclusive(0, 100);\n   *\n   * assert.isTrue(isPercentage(100));\n   *\n   * assert.isFalse(isPercentage(-1));\n   * ```\n   *\n   * @param lowerBound The lower bound (inclusive).\n   * @param upperBound The upper bound (inclusive).\n   * @returns A function that takes a number `x` and returns `true` if `x` is in\n   *   the range, `false` otherwise.\n   */\n  export const isInRangeInclusive =\n    (lowerBound: number, upperBound: number) =>\n    (x: number): boolean =>\n      lowerBound <= x && x <= upperBound;\n\n  /**\n   * @template N - A SmallUint representing the exclusive upper bound\n   * @internal\n   * Helper type mapping each SmallUint N to the union of integers from 0 to N-1.\n   * Used internally for type-safe range operations.\n   *\n   * For example:\n   * - LT[3] = 0 | 1 | 2\n   * - LT[5] = 0 | 1 | 2 | 3 | 4\n   */\n  type LT = Readonly<{ [N in SmallUint]: Index<N> }>;\n\n  /**\n   * @template N - A SmallUint representing the inclusive upper bound\n   * @internal\n   * Helper type mapping each SmallUint N to the union of integers from 0 to N (inclusive).\n   * Used internally for type-safe range operations with inclusive upper bounds.\n   *\n   * For example:\n   * - LEQ[3] = 0 | 1 | 2 | 3\n   * - LEQ[5] = 0 | 1 | 2 | 3 | 4 | 5\n   */\n  type LEQ = Readonly<{ [N in SmallUint]: Index<N> | N }>;\n\n  /**\n   * Creates a type guard that checks if a number is an unsigned integer within\n   * a specified range.\n   *\n   * This function returns a predicate that validates whether a number is:\n   *\n   * - A safe integer (no floating point)\n   * - Within the range [lowerBound, upperBound)\n   *\n   * The returned type guard provides precise type narrowing when the bounds are\n   * SmallUint literals, making it ideal for array index validation.\n   *\n   * @example\n   *\n   * ```ts\n   * const indexGuard = Num.isUintInRange(0, 5);\n   *\n   * assert.isTrue(indexGuard(3));\n   *\n   * assert.isFalse(indexGuard(5));\n   *\n   * assert.isFalse(indexGuard(-1));\n   * ```\n   *\n   * @template L - The lower bound as a SmallUint literal type\n   * @template U - The upper bound as a SmallUint literal type\n   * @param lowerBound - The minimum value (inclusive)\n   * @param upperBound - The maximum value (exclusive)\n   * @returns A type guard function that validates and narrows number types\n   */\n  export const isUintInRange =\n    <L extends SmallUint, U extends SmallUint>(lowerBound: L, upperBound: U) =>\n    (x: number): x is RelaxedExclude<LT[U], LT[Min<L>]> =>\n      Number.isSafeInteger(x) && lowerBound <= x && x < upperBound;\n\n  /**\n   * Creates a type guard that checks if a number is an unsigned integer within\n   * a specified inclusive range.\n   *\n   * This function returns a predicate that validates whether a number is:\n   *\n   * - A safe integer (no floating point)\n   * - Within the range [lowerBound, upperBound] (both bounds inclusive)\n   *\n   * The returned type guard provides precise type narrowing when the bounds are\n   * SmallUint literals, useful for validating scores, percentages, or other\n   * bounded values.\n   *\n   * @example\n   *\n   * ```ts\n   * const inclusiveGuard = Num.isUintInRangeInclusive(0, 5);\n   *\n   * assert.isTrue(inclusiveGuard(5));\n   *\n   * assert.isFalse(inclusiveGuard(6));\n   * ```\n   *\n   * @template L - The lower bound as a SmallUint literal type\n   * @template U - The upper bound as a SmallUint literal type\n   * @param lowerBound - The minimum value (inclusive)\n   * @param upperBound - The maximum value (inclusive)\n   * @returns A type guard function that validates and narrows number types\n   */\n  export const isUintInRangeInclusive =\n    <L extends SmallUint, U extends SmallUint>(lowerBound: L, upperBound: U) =>\n    (x: number): x is RelaxedExclude<LEQ[U], LT[Min<L>]> =>\n      Number.isSafeInteger(x) && lowerBound <= x && x <= upperBound;\n\n  /**\n   * Clamps a value within the given range. If the target value is invalid (not\n   * finite), returns the lower bound.\n   *\n   * Provides two usage patterns for maximum flexibility:\n   *\n   * - **Direct usage**: Pass all three arguments to get the clamped value\n   *   immediately\n   * - **Curried usage**: Pass bounds to get a reusable clamping function\n   *\n   * @example\n   *\n   * ```ts\n   * assert.isTrue(Num.clamp(150, 0, 100) === 100);\n   *\n   * assert.isTrue(Num.clamp(-50, 0, 100) === 0);\n   *\n   * const clampToPercentage = Num.clamp(0, 100);\n   *\n   * assert.isTrue(clampToPercentage(75) === 75);\n   *\n   * assert.isTrue(clampToPercentage(150) === 100);\n   * ```\n   */\n  export function clamp(\n    target: number,\n    lowerBound: number,\n    upperBound: number,\n  ): number;\n\n  // Curried version\n  export function clamp(\n    lowerBound: number,\n    upperBound: number,\n  ): (target: number) => number;\n\n  export function clamp(\n    ...args:\n      | readonly [target: number, lowerBound: number, upperBound: number]\n      | readonly [lowerBound: number, upperBound: number]\n  ): number | ((target: number) => number) {\n    switch (args.length) {\n      case 3: {\n        const [target, lowerBound, upperBound] = args;\n\n        return !Number.isFinite(target)\n          ? lowerBound\n          : Math.max(lowerBound, Math.min(upperBound, target));\n      }\n\n      case 2: {\n        const [lowerBound, upperBound] = args;\n\n        return (target: number): number =>\n          clamp(target, lowerBound, upperBound);\n      }\n    }\n  }\n\n  /**\n   * Adds two numbers, returning the tightest sound branded result type.\n   *\n   * The sign of the result is computed exactly (e.g. a non-negative plus a\n   * non-negative is non-negative); the integer/finite level is preserved, with\n   * `SafeInt` operands widening to `Int` because the sum may exceed the safe\n   * range. No clamping is performed — for a result that stays inside a bounded\n   * type, use that type's branded `add` instead.\n   *\n   * @param a - The first addend.\n   * @param b - The second addend.\n   * @returns `a + b`, typed as the tightest branded type guaranteed to contain\n   *   it.\n   */\n  export const add = <A extends number, B extends number>(\n    a: A,\n    b: B,\n  ): AddResult<A, B> =>\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    (a + b) as AddResult<A, B>;\n\n  /**\n   * Subtracts `b` from `a`, returning the tightest sound branded result type.\n   *\n   * The sign is computed exactly; the level is preserved (with `SafeInt`\n   * widening to `Int`). No clamping — for saturating subtraction that stays in a\n   * bounded type (e.g. `Uint.sub` clamping at `0`), use that type's branded\n   * `sub`.\n   *\n   * @param a - The minuend.\n   * @param b - The subtrahend.\n   * @returns `a - b`, typed as the tightest branded type guaranteed to contain\n   *   it.\n   */\n  export const sub = <A extends number, B extends number>(\n    a: A,\n    b: B,\n  ): SubResult<A, B> =>\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    (a - b) as SubResult<A, B>;\n\n  /**\n   * Multiplies two numbers, returning the tightest sound branded result type.\n   *\n   * The sign follows the usual product rule (e.g. negative times negative is\n   * positive); the level is preserved (with `SafeInt` widening to `Int`). No\n   * clamping.\n   *\n   * @param a - The first factor.\n   * @param b - The second factor.\n   * @returns `a * b`, typed as the tightest branded type guaranteed to contain\n   *   it.\n   */\n  export const mul = <A extends number, B extends number>(\n    a: A,\n    b: B,\n  ): MulResult<A, B> =>\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    (a * b) as MulResult<A, B>;\n\n  /**\n   * Performs type-safe exact division with a compile-time zero-check.\n   *\n   * The divisor must be typed as `NonZeroNumber` or a non-zero numeric literal.\n   * The result sign follows the quotient rule; because exact division can be\n   * fractional, the level is `finite` (or `number`).\n   *\n   * @param a - The dividend.\n   * @param b - The divisor (must be non-zero, enforced by types).\n   * @returns `a / b`, typed as the tightest branded type guaranteed to contain\n   *   it.\n   */\n  export const div = <\n    A extends number,\n    B extends NonZeroNumber | SmallInt<'!=0'>,\n  >(\n    a: A,\n    b: B,\n  ): DivResult<A, B> =>\n    // eslint-disable-next-line total-functions/no-partial-division, total-functions/no-unsafe-type-assertion\n    (a / b) as DivResult<A, B>;\n\n  /**\n   * Performs integer division using floor division.\n   *\n   * Computes `⌊a / b⌋` by flooring both operands before division and then\n   * flooring the result. This ensures integer arithmetic semantics.\n   *\n   * Note: Unlike `div`, this function does not enforce non-zero divisor at\n   * compile time. Division by zero returns `NaN`.\n   *\n   * @param a - The dividend\n   * @param b - The divisor\n   * @returns The integer quotient, or `NaN` if b is zero\n   */\n  export const divInt = <\n    A extends number,\n    B extends NonZeroNumber | SmallInt<'!=0'>,\n  >(\n    a: A,\n    b: B,\n  ): DivIntResult<A, B> => {\n    // eslint-disable-next-line total-functions/no-partial-division\n    const quotient = Math.floor(Math.floor(a) / Math.floor(b));\n\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return quotient as DivIntResult<A, B>;\n  };\n\n  /**\n   * Rounds a number to a specified number of decimal places.\n   *\n   * Uses the standard rounding algorithm (round half up) to round the number to\n   * the given precision. The precision must be a positive safe integer.\n   *\n   * @param num - The number to round\n   * @param precision - The number of decimal places (must be positive)\n   * @returns The rounded number\n   */\n  export const roundAt = (\n    num: number,\n    precision: PositiveSafeIntWithSmallInt,\n  ): number => {\n    const digit = 10 ** precision;\n\n    // eslint-disable-next-line total-functions/no-partial-division\n    return Math.round(num * digit) / digit;\n  };\n\n  /**\n   * Rounds a number to the nearest integer using bitwise operations.\n   *\n   * This function uses a bitwise OR trick for potentially faster rounding.\n   * Note: This implementation rounds half up for positive numbers but may\n   * behave differently for negative numbers compared to Math.round.\n   *\n   * @param num - The number to round\n   * @returns The rounded integer as an Int branded type\n   */\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  export const roundToInt = (num: number): Int => Math.trunc(num + 0.5) as Int;\n\n  /**\n   * Creates a reusable rounding function with a fixed precision.\n   *\n   * This is a curried version of roundAt that returns a function configured to\n   * always round to the specified number of decimal places. Useful for creating\n   * consistent rounding behavior across multiple values.\n   *\n   * @param digit - The number of decimal places for rounding\n   * @returns A function that rounds numbers to the specified precision\n   */\n  export const round = (\n    digit: PositiveSafeIntWithSmallInt,\n  ): ((num: number) => number) => {\n    const powAmount = 10 ** digit;\n\n    return (target: number) =>\n      // eslint-disable-next-line total-functions/no-partial-division\n      roundToInt(powAmount * target) / powAmount;\n  };\n\n  /**\n   * Converts NaN values to undefined while preserving all other numbers.\n   *\n   * This function is useful for handling potentially invalid numeric operations\n   * in a type-safe way, converting NaN results to undefined for easier handling\n   * with optional chaining or nullish coalescing.\n   *\n   * @template N - The numeric type (literal or number)\n   * @param num - The number to check\n   * @returns The original number if not NaN, otherwise undefined\n   */\n  export const mapNaN2Undefined = <N extends number>(\n    num: N,\n  ): RelaxedExclude<N, NaNType> | undefined =>\n    Number.isNaN(num)\n      ? undefined\n      : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        (num as RelaxedExclude<N, NaNType>);\n\n  /**\n   * Type-safe increment operation for SmallUint values.\n   *\n   * Increments a SmallUint (0-40) by 1 with the result type computed at compile\n   * time. This provides type-level arithmetic for small unsigned integers,\n   * useful for type-safe counter operations.\n   *\n   * @template N - A SmallUint literal type (0-40)\n   * @param n - The SmallUint value to increment\n   * @returns The incremented value with type Increment<N>\n   */\n  export const increment = <N extends SmallUint>(n: N): Increment<N> =>\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    (n + 1) as Increment<N>;\n\n  /**\n   * Type-safe decrement operation for positive SmallInt values.\n   *\n   * Decrements a positive SmallInt (1-40) by 1 with the result type computed at\n   * compile time. This provides type-level arithmetic for small positive\n   * integers, useful for type-safe countdown operations.\n   *\n   * @template N - A positive SmallInt literal type (1-40)\n   * @param n - The positive SmallInt value to decrement\n   * @returns The decremented value with type Decrement<N>\n   */\n  export const decrement = <N extends SmallPositiveInt>(n: N): Decrement<N> =>\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    (n - 1) as Decrement<N>;\n}\n"],"names":["Num","Result.err","Result.ok"],"mappings":";;;;IA4CiB;AAAA,CAAV,CAAUA,IAAAA,KAAV;AAiBE,EAAMA,KAAA,IAAA,GAA+B,MAAA;AAiErC,EAAMA,IAAAA,CAAA,YAAA,GAAe,CAAC,CAAA,KAAkC;AAC7D,IAAA,MAAM,SAAA,GAAY,OAAO,CAAC,CAAA;AAK1B,IAAA,OAAO,MAAA,CAAO,KAAA,CAAM,SAAS,CAAA,IAAK,MAAA,CAAO,KAAA,CAAM,MAAA,CAAO,QAAA,CAAS,CAAA,EAAG,EAAE,CAAC,CAAA,GACjEC,GAAO;AAAA,MACL,IAAI,KAAA,CAAM,CAAA,eAAA,EAAkB,CAAC,CAAA,gCAAA,CAAkC;AAAA,KACjE;AAAA;AAAA,MAEAC,EAAO,CAAG,IAAA,CAAK,KAAA,CAAM,SAAS,CAAQ;AAAA,KAAA;AAAA,EAAA,CAC5C;AAiEO,EAAMF,IAAAA,CAAA,cAAA,GAAiB,CAAC,CAAA,KAA2C;AACxE,IAAA,MAAM,SAAA,GAAY,OAAO,CAAC,CAAA;AAM1B,IAAA,OAAO,OAAO,KAAA,CAAM,SAAS,CAAA,IAC3B,CAAC,OAAO,QAAA,CAAS,SAAS,CAAA,IAC1B,MAAA,CAAO,MAAM,MAAA,CAAO,UAAA,CAAW,CAAC,CAAC,IAC/BC,GAAO;AAAA,MACL,IAAI,KAAA,CAAM,CAAA,iBAAA,EAAoB,CAAC,CAAA,8BAAA,CAAgC;AAAA,KACjE;AAAA;AAAA,MAEAC,GAAU,SAAyB;AAAA,KAAA;AAAA,EAAA,CACzC;AA6BO,EAAMF,IAAAA,CAAA,SAAA,GAAY,CACvB,GAAA,KACgD,GAAA,KAAQ,CAAA;AA8BnD,EAAMA,IAAAA,CAAA,aAAA,GAAgB,CAC3B,GAAA,KAEA,GAAA,IAAO,CAAA;AAyBF,EAAMA,IAAAA,CAAA,UAAA,GAAa,CACxB,GAAA,KAEA,GAAA,GAAM,CAAA;AAqBD,EAAMA,IAAAA,CAAA,YACX,CAAC,UAAA,EAAoB,eACrB,CAAC,CAAA,KACC,UAAA,IAAc,CAAA,IAAK,CAAA,GAAI,UAAA;AAqBpB,EAAMA,IAAAA,CAAA,qBACX,CAAC,UAAA,EAAoB,eACrB,CAAC,CAAA,KACC,UAAA,IAAc,CAAA,IAAK,CAAA,IAAK,UAAA;AAwDrB,EAAMA,IAAAA,CAAA,aAAA,GACX,CAA2C,UAAA,EAAe,UAAA,KAC1D,CAAC,CAAA,KACC,MAAA,CAAO,aAAA,CAAc,CAAC,CAAA,IAAK,UAAA,IAAc,KAAK,CAAA,GAAI,UAAA;AA+B/C,EAAMA,IAAAA,CAAA,sBAAA,GACX,CAA2C,UAAA,EAAe,UAAA,KAC1D,CAAC,CAAA,KACC,MAAA,CAAO,aAAA,CAAc,CAAC,CAAA,IAAK,UAAA,IAAc,KAAK,CAAA,IAAK,UAAA;AAsChD,EAAA,SAAS,SACX,IAAA,EAGoC;AACvC,IAAA,QAAQ,KAAK,MAAA;AAAQ,MACnB,KAAK,CAAA,EAAG;AACN,QAAA,MAAM,CAAC,MAAA,EAAQ,UAAA,EAAY,UAAU,CAAA,GAAI,IAAA;AAEzC,QAAA,OAAO,CAAC,MAAA,CAAO,QAAA,CAAS,MAAM,CAAA,GAC1B,UAAA,GACA,IAAA,CAAK,GAAA,CAAI,UAAA,EAAY,IAAA,CAAK,GAAA,CAAI,UAAA,EAAY,MAAM,CAAC,CAAA;AAAA,MAAA;AACvD,MAEA,KAAK,CAAA,EAAG;AACN,QAAA,MAAM,CAAC,UAAA,EAAY,UAAU,CAAA,GAAI,IAAA;AAEjC,QAAA,OAAO,CAAC,MAAA,KACN,KAAA,CAAM,MAAA,EAAQ,YAAY,UAAU,CAAA;AAAA,MAAA;AACxC;AACF,EAAA;AApBK,EAAAA,IAAAA,CAAS,KAAA,GAAA,KAAA;AAqCT,EAAMA,IAAAA,CAAA,GAAA,GAAM,CACjB,CAAA,EACA,CAAA;AAAA;AAAA,IAGC,CAAA,GAAI;AAAA,GAAA;AAeA,EAAMA,IAAAA,CAAA,GAAA,GAAM,CACjB,CAAA,EACA,CAAA;AAAA;AAAA,IAGC,CAAA,GAAI;AAAA,GAAA;AAcA,EAAMA,IAAAA,CAAA,GAAA,GAAM,CACjB,CAAA,EACA,CAAA;AAAA;AAAA,IAGC,CAAA,GAAI;AAAA,GAAA;AAcA,EAAMA,IAAAA,CAAA,GAAA,GAAM,CAIjB,CAAA,EACA,CAAA;AAAA;AAAA,IAGC,CAAA,GAAI;AAAA,GAAA;AAeA,EAAMA,IAAAA,CAAA,MAAA,GAAS,CAIpB,CAAA,EACA,CAAA,KACuB;AAEvB,IAAA,MAAM,QAAA,GAAW,IAAA,CAAK,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,CAAC,CAAA,GAAI,IAAA,CAAK,KAAA,CAAM,CAAC,CAAC,CAAA;AAGzD,IAAA,OAAO,QAAA;AAAA,EAAA,CACT;AAYO,EAAMA,IAAAA,CAAA,OAAA,GAAU,CACrB,GAAA,EACA,SAAA,KACW;AACX,IAAA,MAAM,QAAQ,EAAA,IAAM,SAAA;AAGpB,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,GAAA,GAAM,KAAK,CAAA,GAAI,KAAA;AAAA,EAAA,CACnC;AAaO,EAAMA,KAAA,UAAA,GAAa,CAAC,QAAqB,IAAA,CAAK,KAAA,CAAM,MAAM,GAAG,CAAA;AAY7D,EAAMA,IAAAA,CAAA,KAAA,GAAQ,CACnB,KAAA,KAC8B;AAC9B,IAAA,MAAM,YAAY,EAAA,IAAM,KAAA;AAExB,IAAA,OAAO,CAAC,MAAA;AAAA;AAAA,MAAA,IAENA,IAAAA,CAAA,UAAA,EAAW,SAAA,GAAY,MAAM,CAAA,GAAI;AAAA,KAAA;AAAA,EAAA,CACrC;AAaO,EAAMA,KAAA,gBAAA,GAAmB,CAC9B,QAEA,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA,GACZ,MAAA;AAAA;AAAA,IAEC;AAAA,GAAA;AAaA,EAAMA,IAAAA,CAAA,YAAY,CAAsB,CAAA;AAAA;AAAA,IAE5C,CAAA,GAAI;AAAA,GAAA;AAaA,EAAMA,IAAAA,CAAA,YAAY,CAA6B,CAAA;AAAA;AAAA,IAEnD,CAAA,GAAI;AAAA,GAAA;AAAA,CAAA,EArqBQ,GAAA,KAAA,GAAA,GAAA,EAAA,CAAA,CAAA;;;;"}
+{"version":3,"file":"num.mjs","sourceRoot":"","sources":["../../src/number/num.mts"],"names":[],"mappings":"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"}

package/dist/number/refined-number-utils.mjs

@@ -1,136 +1,297 @@
-import '@sindresorhus/is';
-import { pipe } from '../functional/pipe.mjs';
+
+import { pipe } from '../functional/index.mjs';
 import { Num } from './num.mjs';
+/** @internal */
+export var TsDataForgeInternals;
+(function (TsDataForgeInternals) {
+    /**
+     * Internal utilities for creating and managing refined (branded) number
+     * types.
+     *
+     * This namespace provides factory functions and type utilities for building
+     * type-safe numeric operations with compile-time constraints. It serves as
+     * the foundation for all branded number types in the library, including:
+     *
+     * - Integer types (Int, SafeInt, Int8, Int16, Int32)
+     * - Unsigned types (UInt, UInt8, UInt16, UInt32)
+     * - Constrained types (NonZero, NonNegative, Positive)
+     * - Range-bounded types
+     *
+     * The utilities handle:
+     *
+     * - Type validation and narrowing
+     * - Arithmetic operations that preserve type constraints
+     * - Automatic clamping for bounded types
+     * - Random number generation within type bounds
+     *
+     * @internal This namespace is not part of the public API
+     */
+    let RefinedNumberUtils;
+    (function (RefinedNumberUtils) {
+        const castTypeImpl = (is, typeNameInErrorMessage) => (a) => {
+            if (!is(a)) {
+                throw new TypeError(`Expected ${typeNameInErrorMessage}, got: ${a}`);
+            }
+            return a;
+        };
+        const isNonZero = (n) => n !== 0;
+
 
-var TsDataForgeInternals;
-((TsDataForgeInternals2) => {
-  ((RefinedNumberUtils2) => {
-    const castTypeImpl = (is, typeNameInErrorMessage) => (a) => {
-      if (!is(a)) {
-        throw new TypeError(`Expected ${typeNameInErrorMessage}, got: ${a}`);
-      }
-      return a;
-    };
-    const isNonZero = (n) => n !== 0;
-    const isFnOrUndefined = (min, max) => min === void 0 ? max === void 0 ? void 0 : (n) => n <= max : max === void 0 ? (n) => min <= n : Num.isInRangeInclusive(min, max);
-    const clampFnOrUndefined = (min, max) => min === void 0 ? max === void 0 ? void 0 : (n) => Math.min(max, n) : max === void 0 ? (n) => Math.max(min, n) : Num.clamp(min, max);
-    RefinedNumberUtils2.operatorsForInteger = ({
-      integerOrSafeInteger,
-      nonZero,
-      MIN_VALUE,
-      MAX_VALUE,
-      typeNameInMessage
-    }) => {
-      const is = (a) => (integerOrSafeInteger === "Integer" ? Number.isInteger(a) : Number.isSafeInteger(a)) && (nonZero === true ? a !== 0 : true) && (isFnOrUndefined(MIN_VALUE, MAX_VALUE)?.(a) ?? true);
-      const castType = castTypeImpl(is, typeNameInMessage);
-      const fromNumber = pipe(
-        clampFnOrUndefined(MIN_VALUE, MAX_VALUE)
-      ).mapNullable(
-        (cl) => (x) => castType(Math.round(cl(x)))
-      ).value;
-      const clampOrCastFn = fromNumber ?? castType;
-      const abs = (x) => (
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        Math.abs(clampOrCastFn(x))
-      );
-      const min_ = (...values) => clampOrCastFn(Math.min(...values));
-      const max_ = (...values) => clampOrCastFn(Math.max(...values));
-      const pow = (x, y) => clampOrCastFn(x ** y);
-      const add = (x, y) => clampOrCastFn(x + y);
-      const sub = (x, y) => clampOrCastFn(x - y);
-      const mul = (x, y) => clampOrCastFn(x * y);
-      const div = (x, y) => clampOrCastFn(
-        Math.floor(
-          // eslint-disable-next-line total-functions/no-partial-division
-          x / y
-        )
-      );
-      const randomImpl = (min = MIN_VALUE, max = MAX_VALUE) => min + Math.floor((Math.max(max, min) - min + 1) * Math.random());
-      const random = (min, max) => clampOrCastFn(randomImpl(min, max));
-      const randomNonZero = (min, max) => {
-        while (true) {
-          const r = randomImpl(min, max);
-          if (Num.isNonZero(r)) return clampOrCastFn(r);
-        }
-      };
-      return {
-        MIN_VALUE,
-        MAX_VALUE,
-        is,
-        abs,
-        min: min_,
-        max: max_,
-        pow,
-        add,
-        sub,
-        mul,
-        div,
-        random,
-        randomNonZero,
-        castType,
-        fromNumber: (
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          fromNumber
-        )
-      };
-    };
-    RefinedNumberUtils2.operatorsForFloat = ({
-      nonZero,
-      MIN_VALUE,
-      MAX_VALUE,
-      typeNameInMessage
-    }) => {
-      const is = (a) => Number.isFinite(a) && (nonZero === true ? a !== 0 : true) && (isFnOrUndefined(MIN_VALUE, MAX_VALUE)?.(a) ?? true);
-      const castType = castTypeImpl(is, typeNameInMessage);
-      const fromNumber = pipe(
-        clampFnOrUndefined(MIN_VALUE, MAX_VALUE)
-      ).mapNullable(
-        (cl) => (x) => castType(cl(x))
-      ).value;
-      const clampOrCastFn = fromNumber ?? castType;
-      const abs = (x) => (
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        Math.abs(x)
-      );
-      const min_ = (...values) => clampOrCastFn(Math.min(...values));
-      const max_ = (...values) => clampOrCastFn(Math.max(...values));
-      const pow = (x, y) => clampOrCastFn(x ** y);
-      const add = (x, y) => clampOrCastFn(x + y);
-      const sub = (x, y) => clampOrCastFn(x - y);
-      const mul = (x, y) => clampOrCastFn(x * y);
-      const div = (x, y) => (
-        // eslint-disable-next-line total-functions/no-partial-division
-        clampOrCastFn(x / y)
-      );
-      const randomImpl = (min = MIN_VALUE, max = MAX_VALUE) => min + (Math.max(max, min) - min) * Math.random();
-      const random = (min, max) => clampOrCastFn(randomImpl(min, max));
-      const randomNonZero = (min, max) => {
-        while (true) {
-          const r = random(min, max);
-          if (isNonZero(r)) return r;
-        }
-      };
-      return {
-        MIN_VALUE,
-        MAX_VALUE,
-        is,
-        abs,
-        min: min_,
-        max: max_,
-        pow,
-        add,
-        sub,
-        mul,
-        div,
-        random,
-        randomNonZero,
-        castType,
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        fromNumber
-      };
-    };
-  })(TsDataForgeInternals2.RefinedNumberUtils || (TsDataForgeInternals2.RefinedNumberUtils = {}));
-})(TsDataForgeInternals || (TsDataForgeInternals = {}));
 
-export { TsDataForgeInternals };
-//# sourceMappingURL=refined-number-utils.mjs.map
+
+
+        const isFnOrUndefined = (min, max) => min === undefined
+            ? max === undefined
+                ? undefined
+                : (n) => n <= max
+            : max === undefined
+                ? (n) => min <= n
+                : Num.isInRangeInclusive(min, max);
+        const clampFnOrUndefined = (min, max) => min === undefined
+            ? max === undefined
+                ? undefined
+                : (n) => Math.min(max, n)
+            : max === undefined
+                ? (n) => Math.max(min, n)
+                : Num.clamp(min, max);
+        /**
+         * Factory function that creates a complete set of type-safe operations for
+         * integer types.
+         *
+         * This function generates:
+         *
+         * - Type guards and validators
+         * - Arithmetic operations that preserve type constraints
+         * - Utility functions (min, max, abs, random)
+         * - Automatic clamping for bounded types
+         *
+         * All operations ensure results remain within the type's constraints, using
+         * clamping when bounds are specified.
+         *
+         * @example
+         *
+         * ```ts
+         * const intOps = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<
+         *   SafeInt,
+         *   number,
+         *   number
+         * >({
+         *   integerOrSafeInteger: 'SafeInteger',
+         *   MIN_VALUE: Number.MIN_SAFE_INTEGER,
+         *   MAX_VALUE: Number.MAX_SAFE_INTEGER,
+         *   typeNameInMessage: 'SafeInt',
+         * } as const);
+         *
+         * const six = intOps.castType(6);
+         *
+         * const four = intOps.castType(4);
+         *
+         * const sum = intOps.add(six, four);
+         *
+         * const difference = intOps.sub(six, four);
+         *
+         * const product = intOps.mul(six, four);
+         *
+         * const quotient = intOps.div(six, intOps.castType(2));
+         *
+         * const coerced = intOps.fromNumber(1.5);
+         *
+         * const randomValue = intOps.random();
+         *
+         * assert.isTrue(sum === 10);
+         *
+         * assert.isTrue(difference === 2);
+         *
+         * assert.isTrue(product === 24);
+         *
+         * assert.isTrue(quotient === 3);
+         *
+         * assert.isTrue(coerced === 2);
+         *
+         * assert.isTrue(Number.isSafeInteger(randomValue));
+         * ```
+         *
+         * @template ElementType - The integer branded type
+         * @template MIN_VALUE - Optional minimum value for bounded types
+         * @template MAX_VALUE - Optional maximum value for bounded types
+         * @param config - Configuration object
+         * @param config.integerOrSafeInteger - Whether to use Number.isInteger or
+         *   Number.isSafeInteger
+         * @param config.nonZero - If true, excludes zero from valid values
+         * @param config.MIN_VALUE - Minimum valid value (inclusive)
+         * @param config.MAX_VALUE - Maximum valid value (inclusive)
+         * @param config.typeNameInMessage - Human-readable type name for error
+         *   messages
+         * @returns Object containing all type-safe operations for the integer type
+         * @internal
+         */
+        RefinedNumberUtils.operatorsForInteger = ({ integerOrSafeInteger, nonZero, MIN_VALUE, MAX_VALUE, typeNameInMessage, }) => {
+            const is = (a) => (integerOrSafeInteger === 'Integer'
+                ? Number.isInteger(a)
+                : Number.isSafeInteger(a)) &&
+                (nonZero === true ? a !== 0 : true) &&
+                (isFnOrUndefined(MIN_VALUE, MAX_VALUE)?.(a) ?? true);
+            const castType = castTypeImpl(is, typeNameInMessage);
+            const fromNumber = pipe(clampFnOrUndefined(MIN_VALUE, MAX_VALUE)).mapNullable((cl) => (x) => castType(Math.round(cl(x)))).value;
+            const clampOrCastFn = fromNumber ?? castType;
+            const abs = (x) => 
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            Math.abs(clampOrCastFn(x));
+            const min_ = (...values) => clampOrCastFn(Math.min(...values));
+            const max_ = (...values) => clampOrCastFn(Math.max(...values));
+            const pow = (x, y) => clampOrCastFn(x ** y);
+            const add = (x, y) => clampOrCastFn(x + y);
+            const sub = (x, y) => clampOrCastFn(x - y);
+            const mul = (x, y) => clampOrCastFn(x * y);
+            const div = (x, y) => clampOrCastFn(Math.floor(
+            // eslint-disable-next-line total-functions/no-partial-division
+            x / y));
+            const randomImpl = (min = MIN_VALUE, max = MAX_VALUE) => min + Math.floor((Math.max(max, min) - min + 1) * Math.random());
+            // [-5, 5] -> floor(11 * Math.random()) + (-5)
+            const random = (min, max) => clampOrCastFn(randomImpl(min, max));
+            const randomNonZero = (min, max) => {
+                while (true) {
+                    const r = randomImpl(min, max);
+                    if (Num.isNonZero(r))
+                        return clampOrCastFn(r);
+                }
+            };
+            return {
+                MIN_VALUE,
+                MAX_VALUE,
+                is,
+                abs,
+                min: min_,
+                max: max_,
+                pow,
+                add,
+                sub,
+                mul,
+                div,
+                random,
+                randomNonZero,
+                castType,
+                fromNumber: 
+                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+                fromNumber,
+            };
+        };
+        /**
+         * Factory function that creates a complete set of type-safe operations for
+         * floating-point types.
+         *
+         * This function generates:
+         *
+         * - Type guards and validators (checking for finite values)
+         * - Arithmetic operations that preserve type constraints
+         * - Utility functions (min, max, abs, random)
+         * - Automatic clamping for bounded types
+         *
+         * All operations ensure results remain finite and within any specified
+         * bounds. Division by zero is prevented through type constraints.
+         *
+         * @example
+         *
+         * ```ts
+         * const floatOps = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<
+         *   PositiveFiniteNumber,
+         *   number,
+         *   number
+         * >({
+         *   nonZero: true,
+         *   MIN_VALUE: Number.MIN_VALUE,
+         *   MAX_VALUE: Number.MAX_VALUE,
+         *   typeNameInMessage: 'PositiveFiniteNumber',
+         * } as const);
+         *
+         * const fortyTwo = floatOps.castType(42.5);
+         *
+         * const seven = floatOps.castType(7.5);
+         *
+         * const sum = floatOps.add(fortyTwo, seven);
+         *
+         * const ratio = floatOps.div(sum, floatOps.castType(10));
+         *
+         * const coerced = floatOps.fromNumber(0);
+         *
+         * const boundedRandom = floatOps.random(
+         *   floatOps.castType(10),
+         *   floatOps.castType(20),
+         * );
+         *
+         * const nonZeroRandom = floatOps.randomNonZero();
+         *
+         * assert.isTrue(sum === 50);
+         *
+         * assert.isTrue(ratio === 5);
+         *
+         * assert.isTrue(coerced >= Number.MIN_VALUE);
+         *
+         * assert.isTrue(boundedRandom >= 10 && boundedRandom <= 20);
+         *
+         * assert.isTrue(nonZeroRandom > 0);
+         * ```
+         *
+         * @template ElementType - The floating-point branded type
+         * @template MIN_VALUE - Optional minimum value for bounded types
+         * @template MAX_VALUE - Optional maximum value for bounded types
+         * @param config - Configuration object
+         * @param config.nonZero - If true, excludes zero from valid values
+         * @param config.MIN_VALUE - Minimum valid value (inclusive)
+         * @param config.MAX_VALUE - Maximum valid value (inclusive)
+         * @param config.typeNameInMessage - Human-readable type name for error
+         *   messages
+         * @returns Object containing all type-safe operations for the
+         *   floating-point type
+         * @internal
+         */
+        RefinedNumberUtils.operatorsForFloat = ({ nonZero, MIN_VALUE, MAX_VALUE, typeNameInMessage, }) => {
+            const is = (a) => Number.isFinite(a) &&
+                (nonZero === true ? a !== 0 : true) &&
+                (isFnOrUndefined(MIN_VALUE, MAX_VALUE)?.(a) ?? true);
+            const castType = castTypeImpl(is, typeNameInMessage);
+            const fromNumber = pipe(clampFnOrUndefined(MIN_VALUE, MAX_VALUE)).mapNullable((cl) => (x) => castType(cl(x))).value;
+            const clampOrCastFn = fromNumber ?? castType;
+            const abs = (x) => 
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            Math.abs(x);
+            const min_ = (...values) => clampOrCastFn(Math.min(...values));
+            const max_ = (...values) => clampOrCastFn(Math.max(...values));
+            const pow = (x, y) => clampOrCastFn(x ** y);
+            const add = (x, y) => clampOrCastFn(x + y);
+            const sub = (x, y) => clampOrCastFn(x - y);
+            const mul = (x, y) => clampOrCastFn(x * y);
+            const div = (x, y) => 
+            // eslint-disable-next-line total-functions/no-partial-division
+            clampOrCastFn(x / y);
+            const randomImpl = (min = MIN_VALUE, max = MAX_VALUE) => min + (Math.max(max, min) - min) * Math.random();
+            const random = (min, max) => clampOrCastFn(randomImpl(min, max));
+            const randomNonZero = (min, max) => {
+                while (true) {
+                    const r = random(min, max);
+                    if (isNonZero(r))
+                        return r;
+                }
+            };
+            return {
+                MIN_VALUE,
+                MAX_VALUE,
+                is,
+                abs,
+                min: min_,
+                max: max_,
+                pow,
+                add,
+                sub,
+                mul,
+                div,
+                random,
+                randomNonZero,
+                castType,
+                // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+                fromNumber: fromNumber,
+            };
+        };
+    })(RefinedNumberUtils = TsDataForgeInternals.RefinedNumberUtils || (TsDataForgeInternals.RefinedNumberUtils = {}));
+})(TsDataForgeInternals || (TsDataForgeInternals = {}));
+//# sourceMappingURL=refined-number-utils.mjs.map

package/dist/number/refined-number-utils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"refined-number-utils.mjs","sources":["../../src/number/refined-number-utils.mts"],"sourcesContent":["import {\n  type Brand,\n  type ChangeBaseBrand,\n  type GetBrandValuePart,\n  type Int,\n  type IntersectBrand,\n  type NonNegativeNumber,\n  type NonZeroNumber,\n  type PositiveNumber,\n  type RelaxedExclude,\n  type StrictPick,\n  type TypeEq,\n  type UnknownBrand,\n  type UnwrapBrandFalseKeys,\n  type UnwrapBrandTrueKeys,\n  type WithSmallInt,\n} from 'ts-type-forge';\nimport { expectType } from '../expect-type.mjs';\nimport { pipe } from '../functional/index.mjs';\nimport { Num } from './num.mjs';\n\n/** @internal */\nexport namespace TsDataForgeInternals {\n  /**\n   * Internal utilities for creating and managing refined (branded) number\n   * types.\n   *\n   * This namespace provides factory functions and type utilities for building\n   * type-safe numeric operations with compile-time constraints. It serves as\n   * the foundation for all branded number types in the library, including:\n   *\n   * - Integer types (Int, SafeInt, Int8, Int16, Int32)\n   * - Unsigned types (UInt, UInt8, UInt16, UInt32)\n   * - Constrained types (NonZero, NonNegative, Positive)\n   * - Range-bounded types\n   *\n   * The utilities handle:\n   *\n   * - Type validation and narrowing\n   * - Arithmetic operations that preserve type constraints\n   * - Automatic clamping for bounded types\n   * - Random number generation within type bounds\n   *\n   * @internal This namespace is not part of the public API\n   */\n  export namespace RefinedNumberUtils {\n    const castTypeImpl =\n      <BrandedType extends number>(\n        is: (n: number) => n is BrandedType,\n        typeNameInErrorMessage: string,\n      ) =>\n      <N extends number>(a: N): BrandedType & N => {\n        if (!is(a)) {\n          throw new TypeError(`Expected ${typeNameInErrorMessage}, got: ${a}`);\n        }\n\n        return a;\n      };\n\n    type UnknownNumberBrand = ChangeBaseBrand<UnknownBrand, number>;\n\n    /**\n     * Converts a branded number type to include the Int brand.\n     *\n     * @template N - A branded number type\n     * @internal\n     */\n    export type ToInt<N extends UnknownNumberBrand> = IntersectBrand<N, Int>;\n\n    type ToNonZero<N extends UnknownNumberBrand> = IntersectBrand<\n      N,\n      NonZeroNumber\n    >;\n\n    const isNonZero = <N extends UnknownNumberBrand>(\n      n: N,\n    ): n is N & ToNonZero<N> => n !== 0;\n\n    type ToNonZeroIntWithSmallInt<N extends Int> = WithSmallInt<\n      CastToInt<ToNonZero<N>>\n    >;\n\n    /**\n     * Converts a branded number type to include the NonNegativeNumber brand.\n     *\n     * @template N - A branded number type\n     * @internal\n     */\n    export type ToNonNegative<N extends UnknownNumberBrand> =\n      '!=0' extends UnwrapBrandTrueKeys<N>\n        ? IntersectBrand<N, PositiveNumber>\n        : IntersectBrand<N, NonNegativeNumber>;\n\n    /**\n     * Removes the non-zero brand constraint from a branded number type. Used\n     * when operations may produce zero values.\n     *\n     * @template N - A branded number type\n     * @internal\n     */\n    export type RemoveNonZeroBrandKey<N extends UnknownNumberBrand> = Brand<\n      GetBrandValuePart<N>,\n      RelaxedExclude<UnwrapBrandTrueKeys<N>, '!=0'> & string,\n      RelaxedExclude<UnwrapBrandFalseKeys<N>, '<=0' | '>=0'> & string\n    >;\n\n    type CastToInt<N> = N extends Int ? N : never;\n\n    /**\n     * Generates a type-safe API for a branded number type based on its\n     * characteristics.\n     *\n     * This type dynamically constructs an object type with appropriate methods\n     * based on the number class. For example:\n     *\n     * - Integer types don't get floor/ceil/round methods\n     * - Non-negative types don't get abs method\n     * - Range-bounded types get MIN_VALUE/MAX_VALUE constants\n     *\n     * @template N - The branded number type\n     * @template classes - Union of characteristics: 'int' | 'non-negative' |\n     *   'positive' | 'range'\n     * @internal\n     */\n    /** The closed binary arithmetic operations a branded namespace may expose. */\n    export type NumberClassBinOp = 'add' | 'div' | 'mul' | 'sub';\n\n    export type NumberClass<\n      N extends UnknownNumberBrand,\n      classes extends 'int' | 'non-negative' | 'positive' | 'range',\n      binOps extends NumberClassBinOp = NumberClassBinOp,\n    > = ('int' extends classes\n      ? unknown\n      : 'positive' extends classes\n        ? Readonly<{\n            floor: (x: N, y: N) => RemoveNonZeroBrandKey<ToInt<N>>;\n            ceil: (x: N, y: N) => ToInt<N>;\n            round: (x: N, y: N) => RemoveNonZeroBrandKey<ToInt<N>>;\n          }>\n        : Readonly<{\n            floor: (x: N, y: N) => ToInt<N>;\n            ceil: (x: N, y: N) => ToInt<N>;\n            round: (x: N, y: N) => ToInt<N>;\n          }>) &\n      ('non-negative' extends classes\n        ? Readonly<{\n            MIN_VALUE: number;\n            fromNumber: (a: number) => N;\n          }>\n        : unknown) &\n      ('non-negative' extends classes\n        ? unknown\n        : 'positive' extends classes\n          ? unknown\n          : Readonly<{\n              abs: (x: N) => ToNonNegative<N>;\n            }>) &\n      ('positive' extends classes\n        ? Readonly<{\n            MIN_VALUE: number;\n            fromNumber: (a: number) => N;\n          }>\n        : unknown) &\n      ('range' extends classes\n        ? Readonly<{\n            MIN_VALUE: number;\n            MAX_VALUE: number;\n            fromNumber: (a: number) => N;\n          }>\n        : unknown) &\n      StrictPick<\n        Readonly<{\n          add: (x: N, y: N) => N;\n          sub: (x: N, y: N) => N;\n          mul: (x: N, y: N) => N;\n          div: (x: N, y: ToNonZero<N>) => N;\n        }>,\n        binOps\n      > &\n      Readonly<{\n        is: (a: number) => a is N;\n        min: (...values: readonly N[]) => N;\n        max: (...values: readonly N[]) => N;\n        random: (min: N, max: N) => N;\n        pow: (x: N, y: N) => N;\n      }>;\n\n    type BaseKeys =\n      'add' | 'div' | 'is' | 'max' | 'min' | 'mul' | 'pow' | 'random' | 'sub';\n\n    type FloatMethods = 'ceil' | 'floor' | 'round';\n\n    expectType<keyof NumberClass<UnknownNumberBrand, 'int'>, BaseKeys | 'abs'>(\n      '=',\n    );\n\n    expectType<\n      keyof NumberClass<UnknownNumberBrand, never>,\n      BaseKeys | FloatMethods | 'abs'\n    >('=');\n\n    expectType<\n      keyof NumberClass<UnknownNumberBrand, 'non-negative'>,\n      BaseKeys | FloatMethods | 'fromNumber' | 'MIN_VALUE'\n    >('=');\n\n    expectType<\n      keyof NumberClass<UnknownNumberBrand, 'positive'>,\n      BaseKeys | FloatMethods | 'fromNumber' | 'MIN_VALUE'\n    >('=');\n\n    expectType<\n      keyof NumberClass<UnknownNumberBrand, 'int' | 'range'>,\n      BaseKeys | 'abs' | 'fromNumber' | 'MAX_VALUE' | 'MIN_VALUE'\n    >('=');\n\n    const isFnOrUndefined = (\n      min: number | undefined,\n      max: number | undefined,\n    ): ((n: number) => boolean) | undefined =>\n      min === undefined\n        ? max === undefined\n          ? undefined\n          : (n) => n <= max\n        : max === undefined\n          ? (n) => min <= n\n          : Num.isInRangeInclusive(min, max);\n\n    const clampFnOrUndefined = (\n      min: number | undefined,\n      max: number | undefined,\n    ): ((n: number) => number) | undefined =>\n      min === undefined\n        ? max === undefined\n          ? undefined\n          : (n) => Math.min(max, n)\n        : max === undefined\n          ? (n) => Math.max(min, n)\n          : Num.clamp(min, max);\n\n    type OperatorsForInteger<\n      ElementType extends Int,\n      MIN_VALUE extends number,\n      MAX_VALUE extends number,\n      ElementTypeWithSmallInt extends WithSmallInt<ElementType> =\n        WithSmallInt<ElementType>,\n    > = Readonly<{\n      MIN_VALUE: MIN_VALUE;\n      MAX_VALUE: MAX_VALUE;\n\n      is: (a: number) => a is ElementType;\n\n      abs: (x: ElementTypeWithSmallInt) => ToNonNegative<ElementType>;\n\n      min: (...values: readonly ElementTypeWithSmallInt[]) => ElementType;\n\n      max: (...values: readonly ElementTypeWithSmallInt[]) => ElementType;\n\n      pow: (\n        x: ElementTypeWithSmallInt,\n        y: ElementTypeWithSmallInt,\n      ) => ElementType;\n\n      add: (\n        x: ElementTypeWithSmallInt,\n        y: ElementTypeWithSmallInt,\n      ) => ElementType;\n\n      sub: (\n        x: ElementTypeWithSmallInt,\n        y: ElementTypeWithSmallInt,\n      ) => ElementType;\n\n      mul: (\n        x: ElementTypeWithSmallInt,\n        y: ElementTypeWithSmallInt,\n      ) => ElementType;\n\n      div: (\n        x: ElementTypeWithSmallInt,\n        y: ToNonZeroIntWithSmallInt<ElementType>,\n      ) => ElementType;\n\n      random: (\n        min?: ElementTypeWithSmallInt,\n        max?: ElementTypeWithSmallInt,\n      ) => ElementType;\n\n      randomNonZero: (\n        min?: ElementTypeWithSmallInt,\n        max?: ElementTypeWithSmallInt,\n      ) => ElementType;\n\n      castType: <N extends number>(x: N) => ElementType & N;\n\n      fromNumber: TypeEq<MAX_VALUE | MIN_VALUE, undefined> extends true\n        ? undefined\n        : (x: number) => ElementType;\n    }>;\n\n    /**\n     * Factory function that creates a complete set of type-safe operations for\n     * integer types.\n     *\n     * This function generates:\n     *\n     * - Type guards and validators\n     * - Arithmetic operations that preserve type constraints\n     * - Utility functions (min, max, abs, random)\n     * - Automatic clamping for bounded types\n     *\n     * All operations ensure results remain within the type's constraints, using\n     * clamping when bounds are specified.\n     *\n     * @example\n     *\n     * ```ts\n     * const intOps = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<\n     *   SafeInt,\n     *   number,\n     *   number\n     * >({\n     *   integerOrSafeInteger: 'SafeInteger',\n     *   MIN_VALUE: Number.MIN_SAFE_INTEGER,\n     *   MAX_VALUE: Number.MAX_SAFE_INTEGER,\n     *   typeNameInMessage: 'SafeInt',\n     * } as const);\n     *\n     * const six = intOps.castType(6);\n     *\n     * const four = intOps.castType(4);\n     *\n     * const sum = intOps.add(six, four);\n     *\n     * const difference = intOps.sub(six, four);\n     *\n     * const product = intOps.mul(six, four);\n     *\n     * const quotient = intOps.div(six, intOps.castType(2));\n     *\n     * const coerced = intOps.fromNumber(1.5);\n     *\n     * const randomValue = intOps.random();\n     *\n     * assert.isTrue(sum === 10);\n     *\n     * assert.isTrue(difference === 2);\n     *\n     * assert.isTrue(product === 24);\n     *\n     * assert.isTrue(quotient === 3);\n     *\n     * assert.isTrue(coerced === 2);\n     *\n     * assert.isTrue(Number.isSafeInteger(randomValue));\n     * ```\n     *\n     * @template ElementType - The integer branded type\n     * @template MIN_VALUE - Optional minimum value for bounded types\n     * @template MAX_VALUE - Optional maximum value for bounded types\n     * @param config - Configuration object\n     * @param config.integerOrSafeInteger - Whether to use Number.isInteger or\n     *   Number.isSafeInteger\n     * @param config.nonZero - If true, excludes zero from valid values\n     * @param config.MIN_VALUE - Minimum valid value (inclusive)\n     * @param config.MAX_VALUE - Maximum valid value (inclusive)\n     * @param config.typeNameInMessage - Human-readable type name for error\n     *   messages\n     * @returns Object containing all type-safe operations for the integer type\n     * @internal\n     */\n    export const operatorsForInteger = <\n      ElementType extends Int,\n      MIN_VALUE extends number,\n      MAX_VALUE extends number,\n    >({\n      integerOrSafeInteger,\n      nonZero,\n      MIN_VALUE,\n      MAX_VALUE,\n      typeNameInMessage,\n    }: Readonly<{\n      integerOrSafeInteger: 'Integer' | 'SafeInteger';\n      nonZero?: boolean;\n      MIN_VALUE: MIN_VALUE;\n      MAX_VALUE: MAX_VALUE;\n      typeNameInMessage: string;\n    }>): OperatorsForInteger<ElementType, MIN_VALUE, MAX_VALUE> => {\n      type ElementTypeWithSmallInt = WithSmallInt<ElementType>;\n\n      const is = (a: number): a is ElementType =>\n        (integerOrSafeInteger === 'Integer'\n          ? Number.isInteger(a)\n          : Number.isSafeInteger(a)) &&\n        (nonZero === true ? a !== 0 : true) &&\n        (isFnOrUndefined(MIN_VALUE, MAX_VALUE)?.(a) ?? true);\n\n      const castType = castTypeImpl<ElementType>(is, typeNameInMessage);\n\n      const fromNumber: ((a: number) => ElementType) | undefined = pipe(\n        clampFnOrUndefined(MIN_VALUE, MAX_VALUE),\n      ).mapNullable(\n        (cl) =>\n          (x: number): ElementType =>\n            castType(Math.round(cl(x))),\n      ).value;\n\n      const clampOrCastFn: (a: number) => ElementType = fromNumber ?? castType;\n\n      const abs = (x: ElementTypeWithSmallInt): ToNonNegative<ElementType> =>\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        Math.abs(clampOrCastFn(x)) as ToNonNegative<ElementType>;\n\n      const min_ = (\n        ...values: readonly ElementTypeWithSmallInt[]\n      ): ElementType => clampOrCastFn(Math.min(...values));\n\n      const max_ = (\n        ...values: readonly ElementTypeWithSmallInt[]\n      ): ElementType => clampOrCastFn(Math.max(...values));\n\n      const pow = (\n        x: ElementTypeWithSmallInt,\n        y: ElementTypeWithSmallInt,\n      ): ElementType => clampOrCastFn(x ** y);\n\n      const add = (\n        x: ElementTypeWithSmallInt,\n        y: ElementTypeWithSmallInt,\n      ): ElementType => clampOrCastFn(x + y);\n\n      const sub = (\n        x: ElementTypeWithSmallInt,\n        y: ElementTypeWithSmallInt,\n      ): ElementType => clampOrCastFn(x - y);\n\n      const mul = (\n        x: ElementTypeWithSmallInt,\n        y: ElementTypeWithSmallInt,\n      ): ElementType => clampOrCastFn(x * y);\n\n      const div = (\n        x: ElementTypeWithSmallInt,\n        y: ToNonZeroIntWithSmallInt<ElementType>,\n      ): ElementType =>\n        clampOrCastFn(\n          Math.floor(\n            // eslint-disable-next-line total-functions/no-partial-division\n            x / y,\n          ),\n        );\n\n      const randomImpl = (\n        min: number = MIN_VALUE,\n        max: number = MAX_VALUE,\n      ): number =>\n        min + Math.floor((Math.max(max, min) - min + 1) * Math.random());\n\n      // [-5, 5] -> floor(11 * Math.random()) + (-5)\n      const random = (\n        min?: ElementTypeWithSmallInt,\n        max?: ElementTypeWithSmallInt,\n      ): ElementType => clampOrCastFn(randomImpl(min, max));\n\n      const randomNonZero = (\n        min?: ElementTypeWithSmallInt,\n        max?: ElementTypeWithSmallInt,\n      ): ElementType => {\n        while (true) {\n          const r = randomImpl(min, max);\n\n          if (Num.isNonZero(r)) return clampOrCastFn(r);\n        }\n      };\n\n      return {\n        MIN_VALUE,\n        MAX_VALUE,\n        is,\n        abs,\n        min: min_,\n        max: max_,\n        pow,\n        add,\n        sub,\n        mul,\n        div,\n        random,\n        randomNonZero,\n        castType,\n\n        fromNumber:\n          // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n          fromNumber as TypeEq<MAX_VALUE | MIN_VALUE, undefined> extends true\n            ? undefined\n            : (x: number) => ElementType,\n      } as const;\n    };\n\n    type OperatorsForFloat<\n      ElementType extends UnknownNumberBrand,\n      MIN_VALUE extends number | undefined,\n      MAX_VALUE extends number | undefined,\n    > = Readonly<{\n      MIN_VALUE: MIN_VALUE;\n      MAX_VALUE: MAX_VALUE;\n\n      is: (a: number) => a is ElementType;\n\n      abs: (x: ElementType) => ToNonNegative<ElementType>;\n      min: (...values: readonly ElementType[]) => ElementType;\n      max: (...values: readonly ElementType[]) => ElementType;\n      pow: (x: ElementType, y: ElementType) => ElementType;\n      add: (x: ElementType, y: ElementType) => ElementType;\n      sub: (x: ElementType, y: ElementType) => ElementType;\n      mul: (x: ElementType, y: ElementType) => ElementType;\n      div: (x: ElementType, y: ToNonZero<ElementType>) => ElementType;\n      random: (min?: ElementType, max?: ElementType) => ElementType;\n      randomNonZero: (min?: ElementType, max?: ElementType) => ElementType;\n\n      castType: <N extends number>(x: N) => ElementType & N;\n\n      fromNumber: TypeEq<MAX_VALUE | MIN_VALUE, undefined> extends true\n        ? undefined\n        : (x: number) => ElementType;\n    }>;\n\n    /**\n     * Factory function that creates a complete set of type-safe operations for\n     * floating-point types.\n     *\n     * This function generates:\n     *\n     * - Type guards and validators (checking for finite values)\n     * - Arithmetic operations that preserve type constraints\n     * - Utility functions (min, max, abs, random)\n     * - Automatic clamping for bounded types\n     *\n     * All operations ensure results remain finite and within any specified\n     * bounds. Division by zero is prevented through type constraints.\n     *\n     * @example\n     *\n     * ```ts\n     * const floatOps = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<\n     *   PositiveFiniteNumber,\n     *   number,\n     *   number\n     * >({\n     *   nonZero: true,\n     *   MIN_VALUE: Number.MIN_VALUE,\n     *   MAX_VALUE: Number.MAX_VALUE,\n     *   typeNameInMessage: 'PositiveFiniteNumber',\n     * } as const);\n     *\n     * const fortyTwo = floatOps.castType(42.5);\n     *\n     * const seven = floatOps.castType(7.5);\n     *\n     * const sum = floatOps.add(fortyTwo, seven);\n     *\n     * const ratio = floatOps.div(sum, floatOps.castType(10));\n     *\n     * const coerced = floatOps.fromNumber(0);\n     *\n     * const boundedRandom = floatOps.random(\n     *   floatOps.castType(10),\n     *   floatOps.castType(20),\n     * );\n     *\n     * const nonZeroRandom = floatOps.randomNonZero();\n     *\n     * assert.isTrue(sum === 50);\n     *\n     * assert.isTrue(ratio === 5);\n     *\n     * assert.isTrue(coerced >= Number.MIN_VALUE);\n     *\n     * assert.isTrue(boundedRandom >= 10 && boundedRandom <= 20);\n     *\n     * assert.isTrue(nonZeroRandom > 0);\n     * ```\n     *\n     * @template ElementType - The floating-point branded type\n     * @template MIN_VALUE - Optional minimum value for bounded types\n     * @template MAX_VALUE - Optional maximum value for bounded types\n     * @param config - Configuration object\n     * @param config.nonZero - If true, excludes zero from valid values\n     * @param config.MIN_VALUE - Minimum valid value (inclusive)\n     * @param config.MAX_VALUE - Maximum valid value (inclusive)\n     * @param config.typeNameInMessage - Human-readable type name for error\n     *   messages\n     * @returns Object containing all type-safe operations for the\n     *   floating-point type\n     * @internal\n     */\n    export const operatorsForFloat = <\n      ElementType extends UnknownNumberBrand,\n      MIN_VALUE extends number,\n      MAX_VALUE extends number,\n    >({\n      nonZero,\n      MIN_VALUE,\n      MAX_VALUE,\n      typeNameInMessage,\n    }: Readonly<{\n      nonZero?: boolean;\n      MIN_VALUE: MIN_VALUE;\n      MAX_VALUE: MAX_VALUE;\n      typeNameInMessage: string;\n    }>): OperatorsForFloat<ElementType, MIN_VALUE, MAX_VALUE> => {\n      const is = (a: number): a is ElementType =>\n        Number.isFinite(a) &&\n        (nonZero === true ? a !== 0 : true) &&\n        (isFnOrUndefined(MIN_VALUE, MAX_VALUE)?.(a) ?? true);\n\n      const castType = castTypeImpl<ElementType>(is, typeNameInMessage);\n\n      const fromNumber: ((a: number) => ElementType) | undefined = pipe(\n        clampFnOrUndefined(MIN_VALUE, MAX_VALUE),\n      ).mapNullable(\n        (cl) =>\n          (x: number): ElementType =>\n            castType(cl(x)),\n      ).value;\n\n      const clampOrCastFn: (a: number) => ElementType = fromNumber ?? castType;\n\n      const abs = (x: ElementType): ToNonNegative<ElementType> =>\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        Math.abs(x) as ToNonNegative<ElementType>;\n\n      const min_ = (...values: readonly ElementType[]): ElementType =>\n        clampOrCastFn(Math.min(...values));\n\n      const max_ = (...values: readonly ElementType[]): ElementType =>\n        clampOrCastFn(Math.max(...values));\n\n      const pow = (x: ElementType, y: ElementType): ElementType =>\n        clampOrCastFn(x ** y);\n\n      const add = (x: ElementType, y: ElementType): ElementType =>\n        clampOrCastFn(x + y);\n\n      const sub = (x: ElementType, y: ElementType): ElementType =>\n        clampOrCastFn(x - y);\n\n      const mul = (x: ElementType, y: ElementType): ElementType =>\n        clampOrCastFn(x * y);\n\n      const div = (x: ElementType, y: ToNonZero<ElementType>): ElementType =>\n        // eslint-disable-next-line total-functions/no-partial-division\n        clampOrCastFn(x / y);\n\n      const randomImpl = (\n        min: number = MIN_VALUE,\n        max: number = MAX_VALUE,\n      ): number => min + (Math.max(max, min) - min) * Math.random();\n\n      const random = (min?: ElementType, max?: ElementType): ElementType =>\n        clampOrCastFn(randomImpl(min, max));\n\n      const randomNonZero = (\n        min?: ElementType,\n        max?: ElementType,\n      ): ElementType => {\n        while (true) {\n          const r = random(min, max);\n\n          if (isNonZero(r)) return r;\n        }\n      };\n\n      return {\n        MIN_VALUE,\n        MAX_VALUE,\n        is,\n        abs,\n        min: min_,\n        max: max_,\n        pow,\n        add,\n        sub,\n        mul,\n        div,\n        random,\n        randomNonZero,\n        castType,\n\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        fromNumber: fromNumber as TypeEq<\n          MAX_VALUE | MIN_VALUE,\n          undefined\n        > extends true\n          ? undefined\n          : (x: number) => ElementType,\n      } as const;\n    };\n  }\n}\n"],"names":["TsDataForgeInternals","RefinedNumberUtils"],"mappings":"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"}
+{"version":3,"file":"refined-number-utils.mjs","sourceRoot":"","sources":["../../src/number/refined-number-utils.mts"],"names":[],"mappings":"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"}

package/dist/object/index.mjs

@@ -1,2 +1,2 @@
-export { Obj } from './object.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './object.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/object/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/object/index.mts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}