ts-data-forge 11.0.1 → 12.0.0

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

@@ -23,12 +23,12 @@ var TsDataForgeInternals;
     }) => {
       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 clamp = pipe(
+      const fromNumber = pipe(
         clampFnOrUndefined(MIN_VALUE, MAX_VALUE)
       ).mapNullable(
         (cl) => (x) => castType(Math.round(cl(x)))
       ).value;
-      const clampOrCastFn = clamp ?? castType;
+      const clampOrCastFn = fromNumber ?? castType;
       const abs = (x) => (
         // eslint-disable-next-line total-functions/no-unsafe-type-assertion
         Math.abs(clampOrCastFn(x))
@@ -68,9 +68,9 @@ var TsDataForgeInternals;
         random,
         randomNonZero,
         castType,
-        clamp: (
+        fromNumber: (
           // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          clamp
+          fromNumber
         )
       };
     };
@@ -82,12 +82,12 @@ var TsDataForgeInternals;
     }) => {
       const is = (a) => Number.isFinite(a) && (nonZero === true ? a !== 0 : true) && (isFnOrUndefined(MIN_VALUE, MAX_VALUE)?.(a) ?? true);
       const castType = castTypeImpl(is, typeNameInMessage);
-      const clamp = pipe(
+      const fromNumber = pipe(
         clampFnOrUndefined(MIN_VALUE, MAX_VALUE)
       ).mapNullable(
         (cl) => (x) => castType(cl(x))
       ).value;
-      const clampOrCastFn = clamp ?? castType;
+      const clampOrCastFn = fromNumber ?? castType;
       const abs = (x) => (
         // eslint-disable-next-line total-functions/no-unsafe-type-assertion
         Math.abs(x)
@@ -126,7 +126,7 @@ var TsDataForgeInternals;
         randomNonZero,
         castType,
         // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        clamp
+        fromNumber
       };
     };
   })(TsDataForgeInternals2.RefinedNumberUtils || (TsDataForgeInternals2.RefinedNumberUtils = {}));

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 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            clamp: (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            clamp: (a: number) => N;\n          }>\n        : unknown) &\n      ('range' extends classes\n        ? Readonly<{\n            MIN_VALUE: number;\n            MAX_VALUE: number;\n            clamp: (a: number) => N;\n          }>\n        : unknown) &\n      Pick<\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 | 'clamp' | 'MIN_VALUE'\n    >('=');\n\n    expectType<\n      keyof NumberClass<UnknownNumberBrand, 'positive'>,\n      BaseKeys | FloatMethods | 'clamp' | 'MIN_VALUE'\n    >('=');\n\n    expectType<\n      keyof NumberClass<UnknownNumberBrand, 'int' | 'range'>,\n      BaseKeys | 'abs' | 'clamp' | '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      clamp: 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 roundedClamp = intOps.clamp(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(roundedClamp === 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 clamp: ((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 = clamp ?? 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        clamp:\n          // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n          clamp 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      clamp: 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 clamped = floatOps.clamp(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(clamped >= 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 clamp: ((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 = clamp ?? 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        clamp: clamp as TypeEq<MAX_VALUE | MIN_VALUE, undefined> 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","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 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      Pick<\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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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "11.0.1",
+  "version": "12.0.0",
   "private": false,
   "keywords": [
     "typescript",

package/src/number/branded-types/int16.mts

@@ -14,8 +14,8 @@ const {
   abs,
   add,
   castType,
-  clamp,
   div,
+  fromNumber,
   is,
   max: max_,
   min: min_,
@@ -74,12 +74,14 @@ export const Int16 = {
   is,
 
   /**
-   * The smallest value representable as `Int16`.
+   * The smallest value representable as `Int16` (the lower saturation target of
+   * `fromNumber`).
    */
   MIN_VALUE,
 
   /**
-   * The largest value representable as `Int16`.
+   * The largest value representable as `Int16` (the upper saturation target of
+   * `fromNumber`).
    */
   MAX_VALUE,
 
@@ -110,13 +112,16 @@ export const Int16 = {
   max: max_,
 
   /**
-   * Clamps a `number` into the `Int16` range, rounding to the nearest integer
-   * and constraining the result to `[MIN_VALUE, MAX_VALUE]`.
+   * Converts an arbitrary `number` into an `Int16`, rounding to the nearest
+   * integer and saturating the result into the range `[MIN_VALUE, MAX_VALUE]`.
    *
-   * @param value - The value to clamp
-   * @returns The clamped value as an `Int16`
+   * Unlike `asInt16`, this is total: out-of-range inputs are clamped to the
+   * nearest representable `Int16` instead of throwing.
+   *
+   * @param value - The value to convert
+   * @returns The value as an `Int16`
    */
-  clamp,
+  fromNumber,
 
   /**
    * Generates a random `Int16` within the given range.

package/src/number/branded-types/int32.mts

@@ -14,8 +14,8 @@ const {
   abs,
   add,
   castType,
-  clamp,
   div,
+  fromNumber,
   is,
   max: max_,
   min: min_,
@@ -74,12 +74,14 @@ export const Int32 = {
   is,
 
   /**
-   * The smallest value representable as `Int32`.
+   * The smallest value representable as `Int32` (the lower saturation target of
+   * `fromNumber`).
    */
   MIN_VALUE,
 
   /**
-   * The largest value representable as `Int32`.
+   * The largest value representable as `Int32` (the upper saturation target of
+   * `fromNumber`).
    */
   MAX_VALUE,
 
@@ -110,13 +112,16 @@ export const Int32 = {
   max: max_,
 
   /**
-   * Clamps a `number` into the `Int32` range, rounding to the nearest integer
-   * and constraining the result to `[MIN_VALUE, MAX_VALUE]`.
+   * Converts an arbitrary `number` into an `Int32`, rounding to the nearest
+   * integer and saturating the result into the range `[MIN_VALUE, MAX_VALUE]`.
    *
-   * @param value - The value to clamp
-   * @returns The clamped value as an `Int32`
+   * Unlike `asInt32`, this is total: out-of-range inputs are clamped to the
+   * nearest representable `Int32` instead of throwing.
+   *
+   * @param value - The value to convert
+   * @returns The value as an `Int32`
    */
-  clamp,
+  fromNumber,
 
   /**
    * Generates a random `Int32` within the given range.

package/src/number/branded-types/negative-finite-number.mts

@@ -12,7 +12,7 @@ const {
   MAX_VALUE,
   add,
   castType,
-  clamp,
+  fromNumber,
   is,
   max: max_,
   min: min_,
@@ -31,7 +31,7 @@ const {
 } as const);
 
 const abs = (x: ElementType): PositiveFiniteNumber =>
-  PositiveFiniteNumber.clamp(Math.abs(x));
+  PositiveFiniteNumber.fromNumber(Math.abs(x));
 
 const floor = (
   x: ElementType,
@@ -101,7 +101,10 @@ export const NegativeFiniteNumber = {
   is,
 
   /**
-   * The largest value representable as `NegativeFiniteNumber`.
+   * The largest value representable as `NegativeFiniteNumber` (the upper
+   * saturation target of `fromNumber`). The domain is open at `0` (excluded),
+   * so this is `-Number.MIN_VALUE` — the negative double closest to `0` —
+   * rather than `0`.
    */
   MAX_VALUE,
 
@@ -132,13 +135,17 @@ export const NegativeFiniteNumber = {
   max: max_,
 
   /**
-   * Clamps a `number` into the `NegativeFiniteNumber` range `[MIN_VALUE,
-   * MAX_VALUE]`.
+   * Converts an arbitrary `number` into a `NegativeFiniteNumber`, saturating it
+   * into the range `[MIN_VALUE, MAX_VALUE]`.
    *
-   * @param value - The value to clamp
-   * @returns The clamped value as a `NegativeFiniteNumber`
+   * Unlike `asNegativeFiniteNumber`, this is total: out-of-range inputs are
+   * clamped to the nearest representable `NegativeFiniteNumber` instead of
+   * throwing.
+   *
+   * @param value - The value to convert
+   * @returns The value as a `NegativeFiniteNumber`
    */
-  clamp,
+  fromNumber,
 
   /**
    * Returns the greatest integer less than or equal to a negative finite

package/src/number/branded-types/negative-finite-number.test.mts

@@ -93,13 +93,13 @@ describe('NegativeFiniteNumber test', () => {
     });
   });
 
-  describe('NegativeFiniteNumber.clamp', () => {
+  describe('NegativeFiniteNumber.fromNumber', () => {
     test('clamps non-negative values into range', () => {
-      expect(NegativeFiniteNumber.clamp(-5.5)).toBeCloseTo(-5.5, 5);
+      expect(NegativeFiniteNumber.fromNumber(-5.5)).toBeCloseTo(-5.5, 5);
 
-      expect(NegativeFiniteNumber.clamp(0)).toBeLessThan(0);
+      expect(NegativeFiniteNumber.fromNumber(0)).toBeLessThan(0);
 
-      expect(NegativeFiniteNumber.clamp(5)).toBeLessThan(0);
+      expect(NegativeFiniteNumber.fromNumber(5)).toBeLessThan(0);
     });
   });
 

package/src/number/branded-types/negative-int.mts

@@ -15,7 +15,7 @@ const {
   MAX_VALUE,
   add,
   castType,
-  clamp,
+  fromNumber,
   is,
   max: max_,
   min: min_,
@@ -35,7 +35,7 @@ const {
 } as const);
 
 const abs = (x: WithSmallInt<ElementType>): PositiveInt =>
-  PositiveInt.clamp(Math.abs(x));
+  PositiveInt.fromNumber(Math.abs(x));
 
 /**
  * Type guard that checks if a value is a negative integer.
@@ -81,7 +81,8 @@ export const NegativeInt = {
   is,
 
   /**
-   * The largest value representable as `NegativeInt`.
+   * The largest value representable as `NegativeInt` (the upper saturation
+   * target of `fromNumber`).
    */
   MAX_VALUE,
 
@@ -114,13 +115,17 @@ export const NegativeInt = {
   max: max_,
 
   /**
-   * Clamps a `number` into the `NegativeInt` range, rounding to the nearest
-   * integer and constraining the result to `[MIN_VALUE, MAX_VALUE]`.
+   * Converts an arbitrary `number` into a `NegativeInt`, rounding to the
+   * nearest integer and saturating the result into the range `[MIN_VALUE,
+   * MAX_VALUE]`.
    *
-   * @param value - The value to clamp
-   * @returns The clamped value as a `NegativeInt`
+   * Unlike `asNegativeInt`, this is total: out-of-range inputs are clamped to
+   * the nearest representable `NegativeInt` instead of throwing.
+   *
+   * @param value - The value to convert
+   * @returns The value as a `NegativeInt`
    */
-  clamp,
+  fromNumber,
 
   /**
    * Generates a random `NegativeInt` within the given range.

package/src/number/branded-types/negative-int.test.mts

@@ -96,17 +96,17 @@ describe('NegativeInt test', () => {
     });
   });
 
-  describe('NegativeInt.clamp', () => {
+  describe('NegativeInt.fromNumber', () => {
     test('returns the same value if within range', () => {
-      expect(NegativeInt.clamp(-5)).toBe(-5);
+      expect(NegativeInt.fromNumber(-5)).toBe(-5);
 
-      expect(NegativeInt.clamp(-1000)).toBe(-1000);
+      expect(NegativeInt.fromNumber(-1000)).toBe(-1000);
     });
 
     test('clamps non-negative values to MAX_VALUE (-1)', () => {
-      expect(NegativeInt.clamp(0)).toBe(-1);
+      expect(NegativeInt.fromNumber(0)).toBe(-1);
 
-      expect(NegativeInt.clamp(5)).toBe(-1);
+      expect(NegativeInt.fromNumber(5)).toBe(-1);
     });
   });
 

package/src/number/branded-types/negative-safe-int.mts

@@ -16,7 +16,7 @@ const {
   MIN_VALUE,
   add,
   castType,
-  clamp,
+  fromNumber,
   is,
   max: max_,
   min: min_,
@@ -36,7 +36,7 @@ const {
 } as const);
 
 const abs = (x: WithSmallInt<ElementType>): PositiveSafeInt =>
-  PositiveSafeInt.clamp(Math.abs(x));
+  PositiveSafeInt.fromNumber(Math.abs(x));
 
 /**
  * Type guard that checks if a value is a negative safe integer.
@@ -79,12 +79,14 @@ export const NegativeSafeInt = {
   is,
 
   /**
-   * The smallest value representable as `NegativeSafeInt`.
+   * The smallest value representable as `NegativeSafeInt` (the lower saturation
+   * target of `fromNumber`).
    */
   MIN_VALUE,
 
   /**
-   * The largest value representable as `NegativeSafeInt`.
+   * The largest value representable as `NegativeSafeInt` (the upper saturation
+   * target of `fromNumber`).
    */
   MAX_VALUE,
 
@@ -115,13 +117,17 @@ export const NegativeSafeInt = {
   max: max_,
 
   /**
-   * Clamps a `number` into the `NegativeSafeInt` range, rounding to the nearest
-   * integer and constraining the result to `[MIN_VALUE, MAX_VALUE]`.
+   * Converts an arbitrary `number` into a `NegativeSafeInt`, rounding to the
+   * nearest integer and saturating the result into the range `[MIN_VALUE,
+   * MAX_VALUE]`.
    *
-   * @param value - The value to clamp
-   * @returns The clamped value as a `NegativeSafeInt`
+   * Unlike `asNegativeSafeInt`, this is total: out-of-range inputs are clamped
+   * to the nearest representable `NegativeSafeInt` instead of throwing.
+   *
+   * @param value - The value to convert
+   * @returns The value as a `NegativeSafeInt`
    */
-  clamp,
+  fromNumber,
 
   /**
    * Generates a random `NegativeSafeInt` within the given range.

package/src/number/branded-types/negative-safe-int.test.mts

@@ -86,13 +86,13 @@ describe('NegativeSafeInt test', () => {
     });
   });
 
-  describe('NegativeSafeInt.clamp', () => {
+  describe('NegativeSafeInt.fromNumber', () => {
     test('clamps to the valid range', () => {
-      expect(NegativeSafeInt.clamp(-5)).toBe(-5);
+      expect(NegativeSafeInt.fromNumber(-5)).toBe(-5);
 
-      expect(NegativeSafeInt.clamp(0)).toBe(-1);
+      expect(NegativeSafeInt.fromNumber(0)).toBe(-1);
 
-      expect(NegativeSafeInt.clamp(Number.MIN_SAFE_INTEGER - 100)).toBe(
+      expect(NegativeSafeInt.fromNumber(Number.MIN_SAFE_INTEGER - 100)).toBe(
         Number.MIN_SAFE_INTEGER,
       );
     });

package/src/number/branded-types/non-negative-finite-number.mts

@@ -15,8 +15,8 @@ const {
   MIN_VALUE,
   add,
   castType,
-  clamp,
   div,
+  fromNumber,
   is,
   max: max_,
   min: min_,
@@ -96,7 +96,8 @@ export const NonNegativeFiniteNumber = {
   is,
 
   /**
-   * The smallest value representable as `NonNegativeFiniteNumber`.
+   * The smallest value representable as `NonNegativeFiniteNumber` (the lower
+   * saturation target of `fromNumber`).
    */
   MIN_VALUE,
 
@@ -117,13 +118,17 @@ export const NonNegativeFiniteNumber = {
   max: max_,
 
   /**
-   * Clamps a `number` into the `NonNegativeFiniteNumber` range `[MIN_VALUE,
-   * MAX_VALUE]`.
+   * Converts an arbitrary `number` into a `NonNegativeFiniteNumber`, saturating
+   * it into the range `[MIN_VALUE, MAX_VALUE]`.
    *
-   * @param value - The value to clamp
-   * @returns The clamped value as a `NonNegativeFiniteNumber`
+   * Unlike `asNonNegativeFiniteNumber`, this is total: out-of-range inputs are
+   * clamped to the nearest representable `NonNegativeFiniteNumber` instead of
+   * throwing.
+   *
+   * @param value - The value to convert
+   * @returns The value as a `NonNegativeFiniteNumber`
    */
-  clamp,
+  fromNumber,
 
   /**
    * Returns the greatest integer less than or equal to a non-negative finite

package/src/number/branded-types/non-negative-int16.mts

@@ -13,8 +13,8 @@ const {
   MIN_VALUE,
   add,
   castType,
-  clamp,
   div,
+  fromNumber,
   is,
   max: max_,
   min: min_,
@@ -74,12 +74,14 @@ export const NonNegativeInt16 = {
   is,
 
   /**
-   * The smallest value representable as `NonNegativeInt16`.
+   * The smallest value representable as `NonNegativeInt16` (the lower
+   * saturation target of `fromNumber`).
    */
   MIN_VALUE,
 
   /**
-   * The largest value representable as `NonNegativeInt16`.
+   * The largest value representable as `NonNegativeInt16` (the upper saturation
+   * target of `fromNumber`).
    */
   MAX_VALUE,
 
@@ -100,13 +102,17 @@ export const NonNegativeInt16 = {
   max: max_,
 
   /**
-   * Clamps a `number` into the `NonNegativeInt16` range, rounding to the
-   * nearest integer and constraining the result to `[MIN_VALUE, MAX_VALUE]`.
+   * Converts an arbitrary `number` into a `NonNegativeInt16`, rounding to the
+   * nearest integer and saturating the result into the range `[MIN_VALUE,
+   * MAX_VALUE]`.
    *
-   * @param value - The value to clamp
-   * @returns The clamped value as a `NonNegativeInt16`
+   * Unlike `asNonNegativeInt16`, this is total: out-of-range inputs are clamped
+   * to the nearest representable `NonNegativeInt16` instead of throwing.
+   *
+   * @param value - The value to convert
+   * @returns The value as a `NonNegativeInt16`
    */
-  clamp,
+  fromNumber,
 
   /**
    * Generates a random `NonNegativeInt16` within the given range.