ts-data-forge 14.6.2 → 14.6.3

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

@@ -6,141 +6,141 @@ const { MAX_VALUE, add, castType, fromNumber, is, max: max_, min: min_, pow, ran
     typeNameInMessage,
 });
 const floor = (x) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 Math.floor(x);
 const ceil = (x) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 Math.ceil(x);
 const round = (x) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+
 Math.round(x);
-/**
- * Type guard that checks if a value is a non-positive finite number.
- *
- * Returns `true` only for a finite value — never `NaN`, `Infinity`, or
- * `-Infinity`.
- *
- * @param value - The value to check
- * @returns `true` if the value is a non-positive finite number, `false` otherwise
- */
+
+
+
+
+
+
+
+
+
 export const isNonPositiveFiniteNumber = is;
-/**
- * Casts a `number` to the `NonPositiveFiniteNumber` branded type.
- *
- * Validates that the value is a non-positive finite number and returns it with
- * the `NonPositiveFiniteNumber` brand. Throws a `TypeError` otherwise.
- *
- * @param value - The value to cast
- * @returns The value as a `NonPositiveFiniteNumber`
- * @throws {TypeError} If the value is not a non-positive finite number
- */
+
+
+
+
+
+
+
+
+
+
 export const asNonPositiveFiniteNumber = castType;
-/**
- * Namespace providing type-safe operations for the `NonPositiveFiniteNumber`
- * branded type.
- *
- * The `NonPositiveFiniteNumber` type represents a non-positive finite number.
- */
+
+
+
+
+
+
 export const NonPositiveFiniteNumber = {
-    /**
-     * Type guard that checks if a value is a non-positive finite number.
-     *
-     * @param value - The value to check
-     * @returns `true` if the value is a non-positive finite number, `false` otherwise
-     * @see {@link isNonPositiveFiniteNumber} for usage examples
-     */
+
+
+
+
+
+
+
     is,
-    /**
-     * The largest value representable as `NonPositiveFiniteNumber` (the upper
-     * saturation target of `fromNumber`).
-     */
+
+
+
+
     MAX_VALUE,
-    /**
-     * Returns the smallest of the given non-positive finite numbers.
-     *
-     * @param values - The non-positive finite numbers to compare (at least one required)
-     * @returns The smallest value as a `NonPositiveFiniteNumber`
-     */
+
+
+
+
+
+
     min: min_,
-    /**
-     * Returns the largest of the given non-positive finite numbers.
-     *
-     * @param values - The non-positive finite numbers to compare (at least one required)
-     * @returns The largest value as a `NonPositiveFiniteNumber`
-     */
+
+
+
+
+
+
     max: max_,
-    /**
-     * Converts an arbitrary `number` into a `NonPositiveFiniteNumber`, saturating
-     * it into the range `[MIN_VALUE, MAX_VALUE]`.
-     *
-     * Unlike `asNonPositiveFiniteNumber`, this is total: out-of-range inputs are
-     * clamped to the nearest representable `NonPositiveFiniteNumber` instead of
-     * throwing.
-     *
-     * @param value - The value to convert
-     * @returns The value as a `NonPositiveFiniteNumber`
-     */
+
+
+
+
+
+
+
+
+
+
+
     fromNumber,
-    /**
-     * Returns the greatest integer less than or equal to a non-positive finite
-     * number.
-     *
-     * @param a - The non-positive finite number value
-     * @returns The floored value as an integer
-     */
+
+
+
+
+
+
+
     floor,
-    /**
-     * Returns the smallest integer greater than or equal to a non-positive finite
-     * number.
-     *
-     * @param a - The non-positive finite number value
-     * @returns The ceiled value as an integer
-     */
+
+
+
+
+
+
+
     ceil,
-    /**
-     * Returns the value of a non-positive finite number rounded to the nearest
-     * integer.
-     *
-     * @param a - The non-positive finite number value
-     * @returns The rounded value as an integer
-     */
+
+
+
+
+
+
+
     round,
-    /**
-     * Generates a random `NonPositiveFiniteNumber` within the given range.
-     *
-     * The range is inclusive on both ends.
-     *
-     * @param min - The minimum value (inclusive)
-     * @param max - The maximum value (inclusive)
-     * @returns A random `NonPositiveFiniteNumber` in `[min, max]`
-     */
+
+
+
+
+
+
+
+
+
     random,
-    /**
-     * Raises `a` to the power `b`, returning `a ** b` as a
-     * `NonPositiveFiniteNumber`.
-     *
-     * @param a - The base non-positive finite number
-     * @param b - The exponent non-positive finite number
-     * @returns `a ** b` as a `NonPositiveFiniteNumber`
-     */
+
+
+
+
+
+
+
+
     pow,
-    /**
-     * Adds two non-positive finite numbers, returning `a + b` as a
-     * `NonPositiveFiniteNumber`.
-     *
-     * @param a - The first non-positive finite number
-     * @param b - The second non-positive finite number
-     * @returns The sum of `a` and `b` as a `NonPositiveFiniteNumber`
-     */
+
+
+
+
+
+
+
+
     add,
-    /**
-     * Subtracts two non-positive finite numbers, returning `a - b` as a
-     * `NonPositiveFiniteNumber`.
-     *
-     * @param a - The first non-positive finite number
-     * @param b - The second non-positive finite number
-     * @returns The difference of `a` and `b` as a `NonPositiveFiniteNumber`
-     */
+
+
+
+
+
+
+
+
     sub,
 };
 //# sourceMappingURL=non-positive-finite-number.mjs.map

package/dist/number/branded-types/non-positive-int.mjs

@@ -6,114 +6,114 @@ const { MAX_VALUE, add, castType, fromNumber, is, max: max_, min: min_, pow, ran
     MAX_VALUE: 0,
     typeNameInMessage,
 });
-/**
- * Type guard that checks if a value is a non-positive integer.
- *
- * Returns `true` for a non-positive integer — a value with no fractional
- * component, including values outside the safe integer range (unlike
- * `SafeInt`).
- *
- * @param value - The value to check
- * @returns `true` if the value is a non-positive integer, `false` otherwise
- */
+
+
+
+
+
+
+
+
+
+
 export const isNonPositiveInt = is;
-/**
- * Casts a `number` to the `NonPositiveInt` branded type.
- *
- * Validates that the value is a non-positive integer and returns it with the
- * `NonPositiveInt` brand. Throws a `TypeError` otherwise.
- *
- * @param value - The value to cast
- * @returns The value as a `NonPositiveInt`
- * @throws {TypeError} If the value is not a non-positive integer
- */
+
+
+
+
+
+
+
+
+
+
 export const asNonPositiveInt = castType;
-/**
- * Namespace providing type-safe operations for the `NonPositiveInt` branded
- * type.
- *
- * The `NonPositiveInt` type represents a non-positive integer. Division (`div`)
- * uses floor division.
- *
- * Unlike `SafeInt`, `NonPositiveInt` allows values outside the safe integer
- * range (±2^53 − 1), so very large magnitudes may lose precision in
- * JavaScript's `number` type.
- */
+
+
+
+
+
+
+
+
+
+
+
 export const NonPositiveInt = {
-    /**
-     * Type guard that checks if a value is a non-positive integer.
-     *
-     * @param value - The value to check
-     * @returns `true` if the value is a non-positive integer, `false` otherwise
-     * @see {@link isNonPositiveInt} for usage examples
-     */
+
+
+
+
+
+
+
     is,
-    /**
-     * The largest value representable as `NonPositiveInt` (the upper saturation
-     * target of `fromNumber`).
-     */
+
+
+
+
     MAX_VALUE,
-    /**
-     * Returns the smallest of the given non-positive integers.
-     *
-     * @param values - The non-positive integers to compare (at least one required)
-     * @returns The smallest value as a `NonPositiveInt`
-     */
+
+
+
+
+
+
     min: min_,
-    /**
-     * Returns the largest of the given non-positive integers.
-     *
-     * @param values - The non-positive integers to compare (at least one required)
-     * @returns The largest value as a `NonPositiveInt`
-     */
+
+
+
+
+
+
     max: max_,
-    /**
-     * Converts an arbitrary `number` into a `NonPositiveInt`, rounding to the
-     * nearest integer and saturating the result into the range `[MIN_VALUE,
-     * MAX_VALUE]`.
-     *
-     * Unlike `asNonPositiveInt`, this is total: out-of-range inputs are clamped
-     * to the nearest representable `NonPositiveInt` instead of throwing.
-     *
-     * @param value - The value to convert
-     * @returns The value as a `NonPositiveInt`
-     */
+
+
+
+
+
+
+
+
+
+
+
     fromNumber,
-    /**
-     * Generates a random `NonPositiveInt` within the given range.
-     *
-     * The range is inclusive on both ends.
-     *
-     * @param min - The minimum value (inclusive)
-     * @param max - The maximum value (inclusive)
-     * @returns A random `NonPositiveInt` in `[min, max]`
-     */
+
+
+
+
+
+
+
+
+
     random,
-    /**
-     * Raises `a` to the power `b`, returning `a ** b` as a `NonPositiveInt`
-     * (floored to an integer).
-     *
-     * @param a - The base non-positive integer
-     * @param b - The exponent non-positive integer
-     * @returns `a ** b` as a `NonPositiveInt`
-     */
+
+
+
+
+
+
+
+
     pow,
-    /**
-     * Adds two non-positive integers, returning `a + b` as a `NonPositiveInt`.
-     *
-     * @param a - The first non-positive integer
-     * @param b - The second non-positive integer
-     * @returns The sum of `a` and `b` as a `NonPositiveInt`
-     */
+
+
+
+
+
+
+
     add,
-    /**
-     * Subtracts two non-positive integers, returning `a - b` as a
-     * `NonPositiveInt`.
-     *
-     * @param a - The first non-positive integer
-     * @param b - The second non-positive integer
-     * @returns The difference of `a` and `b` as a `NonPositiveInt`
-     */
+
+
+
+
+
+
+
+
     sub,
 };
 //# sourceMappingURL=non-positive-int.mjs.map

package/dist/number/branded-types/non-positive-safe-int.mjs

@@ -6,116 +6,116 @@ const { MAX_VALUE, MIN_VALUE, add, castType, fromNumber, is, max: max_, min: min
     MAX_VALUE: 0,
     typeNameInMessage,
 });
-/**
- * Type guard that checks if a value is a non-positive safe integer.
- *
- * Returns `true` for a non-positive safe integer — a value with no fractional
- * component.
- *
- * @param value - The value to check
- * @returns `true` if the value is a non-positive safe integer, `false` otherwise
- */
+
+
+
+
+
+
+
+
+
 export const isNonPositiveSafeInt = is;
-/**
- * Casts a `number` to the `NonPositiveSafeInt` branded type.
- *
- * Validates that the value is a non-positive safe integer and returns it with
- * the `NonPositiveSafeInt` brand. Throws a `TypeError` otherwise.
- *
- * @param value - The value to cast
- * @returns The value as a `NonPositiveSafeInt`
- * @throws {TypeError} If the value is not a non-positive safe integer
- */
+
+
+
+
+
+
+
+
+
+
 export const asNonPositiveSafeInt = castType;
-/**
- * Namespace providing type-safe operations for the `NonPositiveSafeInt` branded
- * type.
- *
- * The `NonPositiveSafeInt` type represents a non-positive safe integer.
- * Division (`div`) uses floor division.
- */
+
+
+
+
+
+
+
 export const NonPositiveSafeInt = {
-    /**
-     * Type guard that checks if a value is a non-positive safe integer.
-     *
-     * @param value - The value to check
-     * @returns `true` if the value is a non-positive safe integer, `false` otherwise
-     * @see {@link isNonPositiveSafeInt} for usage examples
-     */
+
+
+
+
+
+
+
     is,
-    /**
-     * The smallest value representable as `NonPositiveSafeInt` (the lower
-     * saturation target of `fromNumber`).
-     */
+
+
+
+
     MIN_VALUE,
-    /**
-     * The largest value representable as `NonPositiveSafeInt` (the upper
-     * saturation target of `fromNumber`).
-     */
+
+
+
+
     MAX_VALUE,
-    /**
-     * Returns the smallest of the given non-positive safe integers.
-     *
-     * @param values - The non-positive safe integers to compare (at least one required)
-     * @returns The smallest value as a `NonPositiveSafeInt`
-     */
+
+
+
+
+
+
     min: min_,
-    /**
-     * Returns the largest of the given non-positive safe integers.
-     *
-     * @param values - The non-positive safe integers to compare (at least one required)
-     * @returns The largest value as a `NonPositiveSafeInt`
-     */
+
+
+
+
+
+
     max: max_,
-    /**
-     * Converts an arbitrary `number` into a `NonPositiveSafeInt`, rounding to the
-     * nearest integer and saturating the result into the range `[MIN_VALUE,
-     * MAX_VALUE]`.
-     *
-     * Unlike `asNonPositiveSafeInt`, this is total: out-of-range inputs are
-     * clamped to the nearest representable `NonPositiveSafeInt` instead of
-     * throwing.
-     *
-     * @param value - The value to convert
-     * @returns The value as a `NonPositiveSafeInt`
-     */
+
+
+
+
+
+
+
+
+
+
+
+
     fromNumber,
-    /**
-     * Generates a random `NonPositiveSafeInt` within the given range.
-     *
-     * The range is inclusive on both ends.
-     *
-     * @param min - The minimum value (inclusive)
-     * @param max - The maximum value (inclusive)
-     * @returns A random `NonPositiveSafeInt` in `[min, max]`
-     */
+
+
+
+
+
+
+
+
+
     random,
-    /**
-     * Raises `a` to the power `b`, returning `a ** b` as a `NonPositiveSafeInt`
-     * (floored to an integer).
-     *
-     * @param a - The base non-positive safe integer
-     * @param b - The exponent non-positive safe integer
-     * @returns `a ** b` as a `NonPositiveSafeInt`
-     */
+
+
+
+
+
+
+
+
     pow,
-    /**
-     * Adds two non-positive safe integers, returning `a + b` as a
-     * `NonPositiveSafeInt`.
-     *
-     * @param a - The first non-positive safe integer
-     * @param b - The second non-positive safe integer
-     * @returns The sum of `a` and `b` as a `NonPositiveSafeInt`
-     */
+
+
+
+
+
+
+
+
     add,
-    /**
-     * Subtracts two non-positive safe integers, returning `a - b` as a
-     * `NonPositiveSafeInt`.
-     *
-     * @param a - The first non-positive safe integer
-     * @param b - The second non-positive safe integer
-     * @returns The difference of `a` and `b` as a `NonPositiveSafeInt`
-     */
+
+
+
+
+
+
+
+
     sub,
 };
 //# sourceMappingURL=non-positive-safe-int.mjs.map