ts-data-forge 14.6.2 → 14.6.4

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

@@ -8,138 +8,138 @@ const { abs, castType, div, is, max: max_, min: min_, mul, pow, randomNonZero: r
     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-zero 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-zero finite number, `false` otherwise
- */
+
+
+
+
+
+
+
+
+
 export const isNonZeroFiniteNumber = is;
-/**
- * Casts a `number` to the `NonZeroFiniteNumber` branded type.
- *
- * Validates that the value is a non-zero finite number and returns it with the
- * `NonZeroFiniteNumber` brand. Throws a `TypeError` otherwise.
- *
- * @param value - The value to cast
- * @returns The value as a `NonZeroFiniteNumber`
- * @throws {TypeError} If the value is not a non-zero finite number
- */
+
+
+
+
+
+
+
+
+
+
 export const asNonZeroFiniteNumber = castType;
-/**
- * Namespace providing type-safe operations for the `NonZeroFiniteNumber`
- * branded type.
- *
- * The `NonZeroFiniteNumber` type represents a non-zero finite number.
- */
+
+
+
+
+
+
 export const NonZeroFiniteNumber = {
-    /**
-     * Type guard that checks if a value is a non-zero finite number.
-     *
-     * @param value - The value to check
-     * @returns `true` if the value is a non-zero finite number, `false` otherwise
-     * @see {@link isNonZeroFiniteNumber} for usage examples
-     */
+
+
+
+
+
+
+
     is,
-    /**
-     * Returns the absolute value of a non-zero finite number.
-     *
-     * The result is non-negative and keeps the `NonZeroFiniteNumber` brand.
-     *
-     * @param a - The non-zero finite number value
-     * @returns The absolute value as a non-negative `NonZeroFiniteNumber`
-     */
+
+
+
+
+
+
+
+
     abs,
-    /**
-     * Returns the smallest of the given non-zero finite numbers.
-     *
-     * @param values - The non-zero finite numbers to compare (at least one required)
-     * @returns The smallest value as a `NonZeroFiniteNumber`
-     */
+
+
+
+
+
+
     min: min_,
-    /**
-     * Returns the largest of the given non-zero finite numbers.
-     *
-     * @param values - The non-zero finite numbers to compare (at least one required)
-     * @returns The largest value as a `NonZeroFiniteNumber`
-     */
+
+
+
+
+
+
     max: max_,
-    /**
-     * Returns the greatest integer less than or equal to a non-zero finite
-     * number.
-     *
-     * @param a - The non-zero finite number value
-     * @returns The floored value as an integer
-     */
+
+
+
+
+
+
+
     floor,
-    /**
-     * Returns the smallest integer greater than or equal to a non-zero finite
-     * number.
-     *
-     * @param a - The non-zero finite number value
-     * @returns The ceiled value as an integer
-     */
+
+
+
+
+
+
+
     ceil,
-    /**
-     * Returns the value of a non-zero finite number rounded to the nearest
-     * integer.
-     *
-     * @param a - The non-zero finite number value
-     * @returns The rounded value as an integer
-     */
+
+
+
+
+
+
+
     round,
-    /**
-     * Generates a random `NonZeroFiniteNumber` 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 `NonZeroFiniteNumber` in `[min, max]`
-     */
+
+
+
+
+
+
+
+
+
     random,
-    /**
-     * Raises `a` to the power `b`, returning `a ** b` as a `NonZeroFiniteNumber`.
-     *
-     * @param a - The base non-zero finite number
-     * @param b - The exponent non-zero finite number
-     * @returns `a ** b` as a `NonZeroFiniteNumber`
-     */
+
+
+
+
+
+
+
     pow,
-    /**
-     * Multiplies two non-zero finite numbers, returning `a * b` as a
-     * `NonZeroFiniteNumber`.
-     *
-     * @param a - The first non-zero finite number
-     * @param b - The second non-zero finite number
-     * @returns The product of `a` and `b` as a `NonZeroFiniteNumber`
-     */
+
+
+
+
+
+
+
+
     mul,
-    /**
-     * Divides two non-zero finite numbers, returning `a / b` as a
-     * `NonZeroFiniteNumber`.
-     *
-     * Exact (non-flooring) division of two non-zero finite numbers is always
-     * non-zero, so this stays closed. For the non-closed operations (`add`/`sub`,
-     * whose result may be `0`) use {@link Num.add}/{@link Num.sub}.
-     *
-     * @param a - The dividend
-     * @param b - The divisor (must be non-zero)
-     * @returns `a / b` as a `NonZeroFiniteNumber`
-     */
+
+
+
+
+
+
+
+
+
+
+
+
     div,
 };
 

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

@@ -8,97 +8,97 @@ const { abs, castType, is, max: max_, min: min_, mul, pow, randomNonZero: random
     MAX_VALUE: Number.MAX_VALUE,
     typeNameInMessage,
 });
-/**
- * Type guard that checks if a value is a non-zero integer.
- *
- * Returns `true` for a non-zero 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-zero integer, `false` otherwise
- */
+
+
+
+
+
+
+
+
+
 export const isNonZeroInt = is;
-/**
- * Casts a `number` to the `NonZeroInt` branded type.
- *
- * Validates that the value is a non-zero integer and returns it with the
- * `NonZeroInt` brand. Throws a `TypeError` otherwise.
- *
- * @param value - The value to cast
- * @returns The value as a `NonZeroInt`
- * @throws {TypeError} If the value is not a non-zero integer
- */
+
+
+
+
+
+
+
+
+
+
 export const asNonZeroInt = castType;
-/**
- * Namespace providing type-safe operations for the `NonZeroInt` branded type.
- *
- * The `NonZeroInt` type represents a non-zero integer. Division (`div`) uses
- * floor division.
- *
- * Unlike `SafeInt`, `NonZeroInt` allows values outside the safe integer range
- * (±2^53 − 1), so very large magnitudes may lose precision in JavaScript's
- * `number` type.
- */
+
+
+
+
+
+
+
+
+
+
 export const NonZeroInt = {
-    /**
-     * Type guard that checks if a value is a non-zero integer.
-     *
-     * @param value - The value to check
-     * @returns `true` if the value is a non-zero integer, `false` otherwise
-     * @see {@link isNonZeroInt} for usage examples
-     */
+
+
+
+
+
+
+
     is,
-    /**
-     * Returns the absolute value of a non-zero integer.
-     *
-     * The result is non-negative and keeps the `NonZeroInt` brand. Note that
-     * `Math.abs(Number.MIN_SAFE_INTEGER)` exceeds `Number.MAX_SAFE_INTEGER`, so
-     * use `SafeInt` for guaranteed precision.
-     *
-     * @param a - The non-zero integer value
-     * @returns The absolute value as a non-negative `NonZeroInt`
-     */
+
+
+
+
+
+
+
+
+
+
     abs,
-    /**
-     * Returns the smallest of the given non-zero integers.
-     *
-     * @param values - The non-zero integers to compare (at least one required)
-     * @returns The smallest value as a `NonZeroInt`
-     */
+
+
+
+
+
+
     min: min_,
-    /**
-     * Returns the largest of the given non-zero integers.
-     *
-     * @param values - The non-zero integers to compare (at least one required)
-     * @returns The largest value as a `NonZeroInt`
-     */
+
+
+
+
+
+
     max: max_,
-    /**
-     * Generates a random `NonZeroInt` 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 `NonZeroInt` in `[min, max]`
-     */
+
+
+
+
+
+
+
+
+
     random,
-    /**
-     * Raises `a` to the power `b`, returning `a ** b` as a `NonZeroInt` (floored
-     * to an integer).
-     *
-     * @param a - The base non-zero integer
-     * @param b - The exponent non-zero integer
-     * @returns `a ** b` as a `NonZeroInt`
-     */
+
+
+
+
+
+
+
+
     pow,
-    /**
-     * Multiplies two non-zero integers, returning `a * b` as a `NonZeroInt`.
-     *
-     * @param a - The first non-zero integer
-     * @param b - The second non-zero integer
-     * @returns The product of `a` and `b` as a `NonZeroInt`
-     */
+
+
+
+
+
+
+
     mul,
 };
 

package/dist/number/branded-types/non-zero-int16.mjs

@@ -8,113 +8,113 @@ const { MAX_VALUE, MIN_VALUE, abs, castType, fromNumber, is, max: max_, min: min
     MAX_VALUE: 2 ** 15 - 1,
     typeNameInMessage,
 });
-/**
- * Type guard that checks if a value is a non-zero integer in [-2^15, 2^15).
- *
- * Returns `true` for a non-zero integer in [-2^15, 2^15) — a value with no
- * fractional component.
- *
- * @param value - The value to check
- * @returns `true` if the value is a non-zero integer in [-2^15, 2^15), `false` otherwise
- */
+
+
+
+
+
+
+
+
+
 export const isNonZeroInt16 = is;
-/**
- * Casts a `number` to the `NonZeroInt16` branded type.
- *
- * Validates that the value is a non-zero integer in [-2^15, 2^15) and returns
- * it with the `NonZeroInt16` brand. Throws a `TypeError` otherwise.
- *
- * @param value - The value to cast
- * @returns The value as a `NonZeroInt16`
- * @throws {TypeError} If the value is not a non-zero integer in [-2^15, 2^15)
- */
+
+
+
+
+
+
+
+
+
+
 export const asNonZeroInt16 = castType;
-/**
- * Namespace providing type-safe operations for the `NonZeroInt16` branded type.
- *
- * The `NonZeroInt16` type represents a non-zero integer in [-2^15, 2^15).
- * Division (`div`) uses floor division.
- */
+
+
+
+
+
+
 export const NonZeroInt16 = {
-    /**
-     * Type guard that checks if a value is a non-zero integer in [-2^15, 2^15).
-     *
-     * @param value - The value to check
-     * @returns `true` if the value is a non-zero integer in [-2^15, 2^15), `false` otherwise
-     * @see {@link isNonZeroInt16} for usage examples
-     */
+
+
+
+
+
+
+
     is,
-    /**
-     * The smallest value representable as `NonZeroInt16` (the lower saturation
-     * target of `fromNumber`).
-     */
+
+
+
+
     MIN_VALUE,
-    /**
-     * The largest value representable as `NonZeroInt16` (the upper saturation
-     * target of `fromNumber`).
-     */
+
+
+
+
     MAX_VALUE,
-    /**
-     * Returns the absolute value of a non-zero integer in [-2^15, 2^15).
-     *
-     * The result is non-negative and keeps the `NonZeroInt16` brand.
-     *
-     * @param a - The non-zero integer value
-     * @returns The absolute value as a non-negative `NonZeroInt16`
-     */
+
+
+
+
+
+
+
+
     abs,
-    /**
-     * Returns the smallest of the given non-zero integers.
-     *
-     * @param values - The non-zero integers to compare (at least one required)
-     * @returns The smallest value as a `NonZeroInt16`
-     */
+
+
+
+
+
+
     min: min_,
-    /**
-     * Returns the largest of the given non-zero integers.
-     *
-     * @param values - The non-zero integers to compare (at least one required)
-     * @returns The largest value as a `NonZeroInt16`
-     */
+
+
+
+
+
+
     max: max_,
-    /**
-     * Converts an arbitrary `number` into a `NonZeroInt16`, rounding to the
-     * nearest integer and saturating the result into the range `[MIN_VALUE,
-     * MAX_VALUE]`.
-     *
-     * Unlike `asNonZeroInt16`, this is total: out-of-range inputs are clamped to
-     * the nearest representable `NonZeroInt16` instead of throwing.
-     *
-     * @param value - The value to convert
-     * @returns The value as a `NonZeroInt16`
-     */
+
+
+
+
+
+
+
+
+
+
+
     fromNumber,
-    /**
-     * Generates a random `NonZeroInt16` 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 `NonZeroInt16` in `[min, max]`
-     */
+
+
+
+
+
+
+
+
+
     random,
-    /**
-     * Raises `a` to the power `b`, returning `a ** b` as a `NonZeroInt16`
-     * (floored to an integer).
-     *
-     * @param a - The base non-zero integer
-     * @param b - The exponent non-zero integer
-     * @returns `a ** b` as a `NonZeroInt16`
-     */
+
+
+
+
+
+
+
+
     pow,
-    /**
-     * Multiplies two non-zero integers, returning `a * b` as a `NonZeroInt16`.
-     *
-     * @param a - The first non-zero integer
-     * @param b - The second non-zero integer
-     * @returns The product of `a` and `b` as a `NonZeroInt16`
-     */
+
+
+
+
+
+
+
     mul,
 };