ts-data-forge 11.0.0 → 12.0.0

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.0",
+  "version": "12.0.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -67,6 +67,7 @@
     "fmt": "format-uncommitted --cwd .",
     "fmt:diff": "format-diff-from origin/main --cwd .",
     "fmt:full": "pnpm run z:prettier .",
+    "gen:branded-number": "tsx ./scripts/gen-branded-number/generate.mts && pnpm run doc:embed:jsdoc && pnpm run z:prettier 'src/number/branded-types/*.mts' 'src/number/enum/*.mts'",
     "gi": "run-s gi:src fmt",
     "gi:src": "tsx scripts/cmd/gen-index.mts",
     "lint": "eslint .",

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

@@ -59,47 +59,37 @@ expectType<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>, Int>(
 /**
  * Type guard that checks if a value is a finite number.
  *
- * Returns `true` if the value is a finite number (not NaN, Infinity, or
- * -Infinity). This is stricter than the standard number type, which includes
- * these special values.
+ * Returns `true` only for a finite value — never `NaN`, `Infinity`, or
+ * `-Infinity`.
  *
  * @param value - The value to check
- * @returns `true` if the value is finite, `false` otherwise
+ * @returns `true` if the value is a finite number, `false` otherwise
  */
 export const isFiniteNumber = is;
 
 /**
- * Casts a number to a FiniteNumber branded type.
+ * Casts a `number` to the `FiniteNumber` branded type.
  *
- * This function validates that the input is finite (not NaN, Infinity, or
- * -Infinity) and returns it with the FiniteNumber brand. This ensures type
- * safety for operations that require finite numeric values.
+ * Validates that the value is a finite number and returns it with the
+ * `FiniteNumber` brand. Throws a `TypeError` otherwise.
  *
  * @param value - The value to cast
- * @returns The value as a FiniteNumber branded type
- * @throws {TypeError} If the value is NaN, Infinity, or -Infinity
+ * @returns The value as a `FiniteNumber`
+ * @throws {TypeError} If the value is not a finite number
  */
 export const asFiniteNumber = castType;
 
 /**
- * Namespace providing type-safe operations for FiniteNumber branded types.
+ * Namespace providing type-safe operations for the `FiniteNumber` branded type.
  *
- * The FiniteNumber type represents any finite numeric value, excluding the
- * special values NaN, Infinity, and -Infinity. All operations are guaranteed to
- * maintain the finite constraint when given finite inputs.
- *
- * This type is essential for:
- *
- * - Mathematical operations that require real numbers
- * - Preventing NaN/Infinity propagation in calculations
- * - Ensuring numeric stability in algorithms
+ * The `FiniteNumber` type represents a finite number.
  */
 export const FiniteNumber = {
   /**
    * Type guard that checks if a value is a finite number.
    *
    * @param value - The value to check
-   * @returns `true` if the value is finite, `false` otherwise
+   * @returns `true` if the value is a finite number, `false` otherwise
    * @see {@link isFiniteNumber} for usage examples
    */
   is,
@@ -107,110 +97,106 @@ export const FiniteNumber = {
   /**
    * Returns the absolute value of a finite number.
    *
-   * @param x - The finite number to get the absolute value of
-   * @returns The absolute value as a FiniteNumber
+   * The result is non-negative and keeps the `FiniteNumber` brand.
+   *
+   * @param a - The finite number value
+   * @returns The absolute value as a non-negative `FiniteNumber`
    */
   abs,
 
   /**
-   * Returns the minimum value from a list of finite numbers.
+   * Returns the smallest of the given finite numbers.
    *
    * @param values - The finite numbers to compare (at least one required)
-   * @returns The smallest value as a FiniteNumber
+   * @returns The smallest value as a `FiniteNumber`
    */
   min: min_,
 
   /**
-   * Returns the maximum value from a list of finite numbers.
+   * Returns the largest of the given finite numbers.
    *
    * @param values - The finite numbers to compare (at least one required)
-   * @returns The largest value as a FiniteNumber
+   * @returns The largest value as a `FiniteNumber`
    */
   max: max_,
 
   /**
-   * Returns the largest integer less than or equal to the given finite number.
+   * Returns the greatest integer less than or equal to a finite number.
    *
-   * @param x - The finite number to floor
-   * @returns The floor value as an Int
+   * @param a - The finite number value
+   * @returns The floored value as an integer
    */
   floor,
 
   /**
-   * Returns the smallest integer greater than or equal to the given finite
-   * number.
+   * Returns the smallest integer greater than or equal to a finite number.
    *
-   * @param x - The finite number to ceil
-   * @returns The ceiling value as an Int
+   * @param a - The finite number value
+   * @returns The ceiled value as an integer
    */
   ceil,
 
   /**
-   * Rounds a finite number to the nearest integer.
+   * Returns the value of a finite number rounded to the nearest integer.
    *
-   * @param x - The finite number to round
-   * @returns The rounded value as an Int
+   * @param a - The finite number value
+   * @returns The rounded value as an integer
    */
   round,
 
   /**
-   * Generates a random finite number within the specified range.
+   * Generates a random `FiniteNumber` within the given range.
    *
-   * The generated value is uniformly distributed in the range [min, max]. Both
-   * bounds are inclusive.
+   * The range is inclusive on both ends.
    *
    * @param min - The minimum value (inclusive)
    * @param max - The maximum value (inclusive)
-   * @returns A random FiniteNumber in the range [min, max]
+   * @returns A random `FiniteNumber` in `[min, max]`
    */
   random,
 
   /**
-   * Raises a finite number to a power.
+   * Raises `a` to the power `b`, returning `a ** b` as a `FiniteNumber`.
    *
    * @param a - The base finite number
    * @param b - The exponent finite number
-   * @returns `a ** b` as a FiniteNumber
+   * @returns `a ** b` as a `FiniteNumber`
    */
   pow,
 
   /**
-   * Adds two finite numbers.
+   * Adds two finite numbers, returning `a + b` as a `FiniteNumber`.
    *
-   * @param a - First finite number
-   * @param b - Second finite number
-   * @returns `a + b` as a FiniteNumber
+   * @param a - The first finite number
+   * @param b - The second finite number
+   * @returns The sum of `a` and `b` as a `FiniteNumber`
    */
   add,
 
   /**
-   * Subtracts two finite numbers.
+   * Subtracts two finite numbers, returning `a - b` as a `FiniteNumber`.
    *
-   * @param a - First finite number
-   * @param b - Second finite number
-   * @returns `a - b` as a FiniteNumber
+   * @param a - The first finite number
+   * @param b - The second finite number
+   * @returns The difference of `a` and `b` as a `FiniteNumber`
    */
   sub,
 
   /**
-   * Multiplies two finite numbers.
+   * Multiplies two finite numbers, returning `a * b` as a `FiniteNumber`.
    *
-   * @param a - First finite number
-   * @param b - Second finite number
-   * @returns `a * b` as a FiniteNumber
+   * @param a - The first finite number
+   * @param b - The second finite number
+   * @returns The product of `a` and `b` as a `FiniteNumber`
    */
   mul,
 
   /**
-   * Divides two finite numbers.
-   *
-   * The divisor must be non-zero (enforced by type constraints). The result is
-   * guaranteed to be finite when both inputs are finite and the divisor is
-   * non-zero.
+   * Divides two finite numbers, returning `a / b` as a `FiniteNumber`.
    *
    * @param a - The dividend
    * @param b - The divisor (must be non-zero)
-   * @returns The quotient `a / b` as a FiniteNumber
+   * @returns `a / b` as a `FiniteNumber`
    */
   div,
 } as const;

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

@@ -34,9 +34,8 @@ const {
 /**
  * Type guard that checks if a value is an integer.
  *
- * Returns `true` if the value is any integer (positive, negative, or zero),
- * with no fractional component. This includes values outside the safe integer
- * range, unlike SafeInt.
+ * Returns `true` for an integer — a value with no fractional component,
+ * including values outside the safe integer range (unlike `SafeInt`).
  *
  * @example
  *
@@ -54,11 +53,10 @@ const {
 export const isInt = is;
 
 /**
- * Casts a number to an Int branded type.
+ * Casts a `number` to the `Int` branded type.
  *
- * This function validates that the input is an integer and returns it with the
- * Int brand. Throws a TypeError if the value has a fractional component or is
- * not a finite number.
+ * Validates that the value is an integer and returns it with the `Int` brand.
+ * Throws a `TypeError` otherwise.
  *
  * @example
  *
@@ -71,21 +69,19 @@ export const isInt = is;
  * ```
  *
  * @param value - The value to cast
- * @returns The value as an Int branded type
+ * @returns The value as an `Int`
  * @throws {TypeError} If the value is not an integer
  */
 export const asInt = castType;
 
 /**
- * Namespace providing type-safe operations for Int branded types.
+ * Namespace providing type-safe operations for the `Int` branded type.
  *
- * The Int type represents any integer value (no fractional component) without
- * range restrictions. All operations preserve the integer constraint, using
- * floor division for division operations.
+ * The `Int` type represents an integer. Division (`div`) uses floor division.
  *
- * Unlike SafeInt, Int allows values outside the safe integer range (±2^53 - 1),
- * but be aware that very large integers may lose precision in JavaScript's
- * number type.
+ * Unlike `SafeInt`, `Int` allows values outside the safe integer range (±2^53 −
+ * 1), so very large magnitudes may lose precision in JavaScript's `number`
+ * type.
  */
 export const Int = {
   /**
@@ -110,9 +106,9 @@ export const Int = {
   /**
    * Returns the absolute value of an integer.
    *
-   * The result is always non-negative and maintains the Int brand. Note that
-   * Math.abs(Number.MIN_SAFE_INTEGER) exceeds Number.MAX_SAFE_INTEGER, so use
-   * SafeInt for guaranteed precision.
+   * The result is non-negative and keeps the `Int` brand. Note that
+   * `Math.abs(Number.MIN_SAFE_INTEGER)` exceeds `Number.MAX_SAFE_INTEGER`, so
+   * use `SafeInt` for guaranteed precision.
    *
    * @example
    *
@@ -127,12 +123,12 @@ export const Int = {
    * ```
    *
    * @param a - The integer value
-   * @returns The absolute value as a non-negative Int
+   * @returns The absolute value as a non-negative `Int`
    */
   abs,
 
   /**
-   * Returns the minimum value from a list of integers.
+   * Returns the smallest of the given integers.
    *
    * @example
    *
@@ -143,12 +139,12 @@ export const Int = {
    * ```
    *
    * @param values - The integers to compare (at least one required)
-   * @returns The smallest value as an Int
+   * @returns The smallest value as an `Int`
    */
   min: min_,
 
   /**
-   * Returns the maximum value from a list of integers.
+   * Returns the largest of the given integers.
    *
    * @example
    *
@@ -159,15 +155,14 @@ export const Int = {
    * ```
    *
    * @param values - The integers to compare (at least one required)
-   * @returns The largest value as an Int
+   * @returns The largest value as an `Int`
    */
   max: max_,
 
   /**
-   * Generates a random integer within the specified range (inclusive).
+   * Generates a random `Int` within the given range.
    *
-   * The range is inclusive on both ends, so random(1, 6) can return any of: 1,
-   * 2, 3, 4, 5, or 6.
+   * The range is inclusive on both ends.
    *
    * @example
    *
@@ -185,12 +180,13 @@ export const Int = {
    *
    * @param min - The minimum value (inclusive)
    * @param max - The maximum value (inclusive)
-   * @returns A random Int in the range [min, max]
+   * @returns A random `Int` in `[min, max]`
    */
   random,
 
   /**
-   * Raises an integer to a power.
+   * Raises `a` to the power `b`, returning `a ** b` as an `Int` (floored to an
+   * integer).
    *
    * @example
    *
@@ -206,12 +202,12 @@ export const Int = {
    *
    * @param a - The base integer
    * @param b - The exponent integer
-   * @returns `a ** b` as an Int
+   * @returns `a ** b` as an `Int`
    */
   pow,
 
   /**
-   * Adds two integers.
+   * Adds two integers, returning `a + b` as an `Int`.
    *
    * @example
    *
@@ -221,14 +217,14 @@ export const Int = {
    * assert.isTrue(sum === 20);
    * ```
    *
-   * @param a - First integer
-   * @param b - Second integer
-   * @returns `a + b` as an Int
+   * @param a - The first integer
+   * @param b - The second integer
+   * @returns The sum of `a` and `b` as an `Int`
    */
   add,
 
   /**
-   * Subtracts two integers.
+   * Subtracts two integers, returning `a - b` as an `Int`.
    *
    * @example
    *
@@ -238,14 +234,14 @@ export const Int = {
    * assert.isTrue(difference === 4);
    * ```
    *
-   * @param a - First integer
-   * @param b - Second integer
-   * @returns `a - b` as an Int
+   * @param a - The first integer
+   * @param b - The second integer
+   * @returns The difference of `a` and `b` as an `Int`
    */
   sub,
 
   /**
-   * Multiplies two integers.
+   * Multiplies two integers, returning `a * b` as an `Int`.
    *
    * @example
    *
@@ -255,17 +251,15 @@ export const Int = {
    * assert.isTrue(product === -24);
    * ```
    *
-   * @param a - First integer
-   * @param b - Second integer
-   * @returns `a * b` as an Int
+   * @param a - The first integer
+   * @param b - The second integer
+   * @returns The product of `a` and `b` as an `Int`
    */
   mul,
 
   /**
-   * Divides two integers using floor division.
-   *
-   * Performs mathematical floor division: `⌊a / b⌋`. The result is always an
-   * integer, rounding toward negative infinity.
+   * Divides two integers using floor division (`⌊a / b⌋`): the result is `a /
+   * b` rounded toward negative infinity, as an `Int`.
    *
    * @example
    *
@@ -281,7 +275,7 @@ export const Int = {
    *
    * @param a - The dividend
    * @param b - The divisor (must be non-zero)
-   * @returns The integer quotient as an Int
+   * @returns The floored quotient as an `Int`
    */
   div,
 } as const;