ts-data-forge 1.0.0 → 1.0.1

package/dist/number/branded-types/finite-number.d.mts

@@ -0,0 +1,291 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+type ElementType = FiniteNumber;
+/**
+ * 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.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is finite, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isFiniteNumber(42);          // true
+ * isFiniteNumber(3.14);        // true
+ * isFiniteNumber(-0);          // true
+ * isFiniteNumber(Infinity);    // false
+ * isFiniteNumber(-Infinity);   // false
+ * isFiniteNumber(NaN);         // false
+ * isFiniteNumber(1/0);         // false (Infinity)
+ * ```
+ */
+export declare const isFiniteNumber: (a: number) => a is FiniteNumber;
+/**
+ * Casts a number to a 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.
+ *
+ * @param value - The value to cast
+ * @returns The value as a FiniteNumber branded type
+ * @throws {TypeError} If the value is NaN, Infinity, or -Infinity
+ *
+ * @example
+ * ```typescript
+ * const x = asFiniteNumber(5.5);   // FiniteNumber
+ * const y = asFiniteNumber(-10);   // FiniteNumber
+ * const z = asFiniteNumber(0);     // FiniteNumber
+ *
+ * // These throw TypeError:
+ * // asFiniteNumber(Infinity);     // Not finite
+ * // asFiniteNumber(-Infinity);    // Not finite
+ * // asFiniteNumber(NaN);          // Not a number
+ * // asFiniteNumber(Math.sqrt(-1)); // Results in NaN
+ * ```
+ */
+export declare const asFiniteNumber: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly Finite: true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe operations for FiniteNumber branded types.
+ *
+ * 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
+ *
+ * @example
+ * ```typescript
+ * // Type validation
+ * FiniteNumber.is(3.14);       // true
+ * FiniteNumber.is(Infinity);   // false
+ * FiniteNumber.is(0/0);        // false (NaN)
+ *
+ * // Arithmetic with guaranteed finite results
+ * const a = asFiniteNumber(10.5);
+ * const b = asFiniteNumber(3.2);
+ *
+ * const sum = FiniteNumber.add(a, b);      // FiniteNumber (13.7)
+ * const diff = FiniteNumber.sub(a, b);     // FiniteNumber (7.3)
+ * const product = FiniteNumber.mul(a, b);  // FiniteNumber (33.6)
+ * const quotient = FiniteNumber.div(a, b); // FiniteNumber (3.28125)
+ * const power = FiniteNumber.pow(a, asFiniteNumber(2)); // FiniteNumber (110.25)
+ *
+ * // Rounding to integers
+ * const value = asFiniteNumber(5.7);
+ * const floored = FiniteNumber.floor(value);  // Int (5)
+ * const ceiled = FiniteNumber.ceil(value);    // Int (6)
+ * const rounded = FiniteNumber.round(value);  // Int (6)
+ *
+ * // Utility operations
+ * const absolute = FiniteNumber.abs(asFiniteNumber(-42.5)); // FiniteNumber (42.5)
+ * const minimum = FiniteNumber.min(a, b, asFiniteNumber(5)); // FiniteNumber (3.2)
+ * const maximum = FiniteNumber.max(a, b, asFiniteNumber(5)); // FiniteNumber (10.5)
+ *
+ * // Random generation
+ * const rand = FiniteNumber.random(asFiniteNumber(0), asFiniteNumber(1)); // Random in [0, 1]
+ * ```
+ */
+export declare 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
+     *
+     * @see {@link isFiniteNumber} for usage examples
+     */
+    readonly is: (a: number) => a is 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
+     * @example
+     * ```typescript
+     * FiniteNumber.abs(asFiniteNumber(-5.5)); // FiniteNumber (5.5)
+     * FiniteNumber.abs(asFiniteNumber(3.2)); // FiniteNumber (3.2)
+     * ```
+     */
+    readonly abs: (x: FiniteNumber) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<FiniteNumber>;
+    /**
+     * Returns the minimum value from a list of finite numbers.
+     *
+     * @param values - The finite numbers to compare (at least one required)
+     * @returns The smallest value as a FiniteNumber
+     *
+     * @example
+     * ```typescript
+     * const a = asFiniteNumber(5.5);
+     * const b = asFiniteNumber(3.2);
+     * const c = asFiniteNumber(7.8);
+     *
+     * FiniteNumber.min(a, b);      // FiniteNumber (3.2)
+     * FiniteNumber.min(a, b, c);   // FiniteNumber (3.2)
+     * ```
+     */
+    readonly min: (...values: readonly FiniteNumber[]) => FiniteNumber;
+    /**
+     * Returns the maximum value from a list of finite numbers.
+     *
+     * @param values - The finite numbers to compare (at least one required)
+     * @returns The largest value as a FiniteNumber
+     *
+     * @example
+     * ```typescript
+     * const a = asFiniteNumber(5.5);
+     * const b = asFiniteNumber(3.2);
+     * const c = asFiniteNumber(7.8);
+     *
+     * FiniteNumber.max(a, b);      // FiniteNumber (7.8)
+     * FiniteNumber.max(a, b, c);   // FiniteNumber (7.8)
+     * ```
+     */
+    readonly max: (...values: readonly FiniteNumber[]) => FiniteNumber;
+    /**
+     * Returns the largest integer less than or equal to the given finite number.
+     * @param x - The finite number to floor
+     * @returns The floor value as an Int
+     * @example
+     * ```typescript
+     * FiniteNumber.floor(asFiniteNumber(5.8)); // Int (5)
+     * FiniteNumber.floor(asFiniteNumber(-5.2)); // Int (-6)
+     * ```
+     */
+    readonly floor: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    /**
+     * Returns the smallest integer greater than or equal to the given finite number.
+     * @param x - The finite number to ceil
+     * @returns The ceiling value as an Int
+     * @example
+     * ```typescript
+     * FiniteNumber.ceil(asFiniteNumber(5.2)); // Int (6)
+     * FiniteNumber.ceil(asFiniteNumber(-5.8)); // Int (-5)
+     * ```
+     */
+    readonly ceil: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    /**
+     * Rounds a finite number to the nearest integer.
+     * @param x - The finite number to round
+     * @returns The rounded value as an Int
+     * @example
+     * ```typescript
+     * FiniteNumber.round(asFiniteNumber(5.4)); // Int (5)
+     * FiniteNumber.round(asFiniteNumber(5.6)); // Int (6)
+     * FiniteNumber.round(asFiniteNumber(5.5)); // Int (6)
+     * ```
+     */
+    readonly round: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    /**
+     * Generates a random finite number within the specified range.
+     *
+     * The generated value is uniformly distributed in the range [min, max].
+     * Both bounds are inclusive.
+     *
+     * @param min - The minimum value (inclusive)
+     * @param max - The maximum value (inclusive)
+     * @returns A random FiniteNumber in the range [min, max]
+     *
+     * @example
+     * ```typescript
+     * // Random percentage (0-100)
+     * const pct = FiniteNumber.random(
+     *   asFiniteNumber(0),
+     *   asFiniteNumber(100)
+     * );
+     *
+     * // Random coordinate (-1 to 1)
+     * const coord = FiniteNumber.random(
+     *   asFiniteNumber(-1),
+     *   asFiniteNumber(1)
+     * );
+     * ```
+     */
+    readonly random: (min: FiniteNumber, max: FiniteNumber) => FiniteNumber;
+    /**
+     * Raises a finite number to a power.
+     * @param a - The base finite number
+     * @param b - The exponent finite number
+     * @returns `a ** b` as a FiniteNumber
+     * @example
+     * ```typescript
+     * FiniteNumber.pow(asFiniteNumber(2.5), asFiniteNumber(3)); // FiniteNumber (15.625)
+     * ```
+     */
+    readonly pow: (x: FiniteNumber, y: FiniteNumber) => FiniteNumber;
+    /**
+     * Adds two finite numbers.
+     * @param a - First finite number
+     * @param b - Second finite number
+     * @returns `a + b` as a FiniteNumber
+     * @example
+     * ```typescript
+     * FiniteNumber.add(asFiniteNumber(5.5), asFiniteNumber(3.2)); // FiniteNumber (8.7)
+     * ```
+     */
+    readonly add: (x: FiniteNumber, y: FiniteNumber) => FiniteNumber;
+    /**
+     * Subtracts two finite numbers.
+     * @param a - First finite number
+     * @param b - Second finite number
+     * @returns `a - b` as a FiniteNumber
+     * @example
+     * ```typescript
+     * FiniteNumber.sub(asFiniteNumber(8.7), asFiniteNumber(3.2)); // FiniteNumber (5.5)
+     * ```
+     */
+    readonly sub: (x: FiniteNumber, y: FiniteNumber) => FiniteNumber;
+    /**
+     * Multiplies two finite numbers.
+     * @param a - First finite number
+     * @param b - Second finite number
+     * @returns `a * b` as a FiniteNumber
+     * @example
+     * ```typescript
+     * FiniteNumber.mul(asFiniteNumber(5.5), asFiniteNumber(2)); // FiniteNumber (11)
+     * ```
+     */
+    readonly mul: (x: FiniteNumber, y: FiniteNumber) => FiniteNumber;
+    /**
+     * 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.
+     *
+     * @param a - The dividend
+     * @param b - The divisor (must be non-zero)
+     * @returns The quotient `a / b` as a FiniteNumber
+     *
+     * @example
+     * ```typescript
+     * const a = asFiniteNumber(11);
+     * const b = asFiniteNumber(2);
+     *
+     * FiniteNumber.div(a, b); // FiniteNumber (5.5)
+     *
+     * // With non-zero type guard
+     * const divisor = asFiniteNumber(userInput);
+     * if (Num.isNonZero(divisor)) {
+     *   const result = FiniteNumber.div(a, divisor);
+     * }
+     * ```
+     */
+    readonly div: (x: FiniteNumber, y: number & {
+        readonly NaNValue: false;
+        readonly "!=0": true;
+        readonly Finite: true;
+    } & Readonly<{
+        'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+    }>) => FiniteNumber;
+};
+export {};
+//# sourceMappingURL=finite-number.d.mts.map

package/dist/number/branded-types/finite-number.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,KAAK,WAAW,GAAG,YAAY,CAAC;AA8ChC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;OAOG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;OASG;wBAnLA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAqL1D;;;;;;;;;OASG;uBAzLA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA2L1D;;;;;;;;;;OAUG;wBAhMA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAkM1D;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;;;;;;;CAEK,CAAC"}

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

@@ -0,0 +1,296 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a finite number';
+const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForFloat({
+    MIN_VALUE: undefined,
+    MAX_VALUE: undefined,
+    typeNameInMessage,
+});
+const floor = (x) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+Math.floor(x);
+const ceil = (x) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+Math.ceil(x);
+const round = (x) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+Math.round(x);
+/**
+ * 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.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is finite, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isFiniteNumber(42);          // true
+ * isFiniteNumber(3.14);        // true
+ * isFiniteNumber(-0);          // true
+ * isFiniteNumber(Infinity);    // false
+ * isFiniteNumber(-Infinity);   // false
+ * isFiniteNumber(NaN);         // false
+ * isFiniteNumber(1/0);         // false (Infinity)
+ * ```
+ */
+const isFiniteNumber = is;
+/**
+ * Casts a number to a 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.
+ *
+ * @param value - The value to cast
+ * @returns The value as a FiniteNumber branded type
+ * @throws {TypeError} If the value is NaN, Infinity, or -Infinity
+ *
+ * @example
+ * ```typescript
+ * const x = asFiniteNumber(5.5);   // FiniteNumber
+ * const y = asFiniteNumber(-10);   // FiniteNumber
+ * const z = asFiniteNumber(0);     // FiniteNumber
+ *
+ * // These throw TypeError:
+ * // asFiniteNumber(Infinity);     // Not finite
+ * // asFiniteNumber(-Infinity);    // Not finite
+ * // asFiniteNumber(NaN);          // Not a number
+ * // asFiniteNumber(Math.sqrt(-1)); // Results in NaN
+ * ```
+ */
+const asFiniteNumber = castType;
+/**
+ * Namespace providing type-safe operations for FiniteNumber branded types.
+ *
+ * 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
+ *
+ * @example
+ * ```typescript
+ * // Type validation
+ * FiniteNumber.is(3.14);       // true
+ * FiniteNumber.is(Infinity);   // false
+ * FiniteNumber.is(0/0);        // false (NaN)
+ *
+ * // Arithmetic with guaranteed finite results
+ * const a = asFiniteNumber(10.5);
+ * const b = asFiniteNumber(3.2);
+ *
+ * const sum = FiniteNumber.add(a, b);      // FiniteNumber (13.7)
+ * const diff = FiniteNumber.sub(a, b);     // FiniteNumber (7.3)
+ * const product = FiniteNumber.mul(a, b);  // FiniteNumber (33.6)
+ * const quotient = FiniteNumber.div(a, b); // FiniteNumber (3.28125)
+ * const power = FiniteNumber.pow(a, asFiniteNumber(2)); // FiniteNumber (110.25)
+ *
+ * // Rounding to integers
+ * const value = asFiniteNumber(5.7);
+ * const floored = FiniteNumber.floor(value);  // Int (5)
+ * const ceiled = FiniteNumber.ceil(value);    // Int (6)
+ * const rounded = FiniteNumber.round(value);  // Int (6)
+ *
+ * // Utility operations
+ * const absolute = FiniteNumber.abs(asFiniteNumber(-42.5)); // FiniteNumber (42.5)
+ * const minimum = FiniteNumber.min(a, b, asFiniteNumber(5)); // FiniteNumber (3.2)
+ * const maximum = FiniteNumber.max(a, b, asFiniteNumber(5)); // FiniteNumber (10.5)
+ *
+ * // Random generation
+ * const rand = FiniteNumber.random(asFiniteNumber(0), asFiniteNumber(1)); // Random in [0, 1]
+ * ```
+ */
+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
+     *
+     * @see {@link isFiniteNumber} for usage examples
+     */
+    is,
+    /**
+     * 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
+     * @example
+     * ```typescript
+     * FiniteNumber.abs(asFiniteNumber(-5.5)); // FiniteNumber (5.5)
+     * FiniteNumber.abs(asFiniteNumber(3.2)); // FiniteNumber (3.2)
+     * ```
+     */
+    abs,
+    /**
+     * Returns the minimum value from a list of finite numbers.
+     *
+     * @param values - The finite numbers to compare (at least one required)
+     * @returns The smallest value as a FiniteNumber
+     *
+     * @example
+     * ```typescript
+     * const a = asFiniteNumber(5.5);
+     * const b = asFiniteNumber(3.2);
+     * const c = asFiniteNumber(7.8);
+     *
+     * FiniteNumber.min(a, b);      // FiniteNumber (3.2)
+     * FiniteNumber.min(a, b, c);   // FiniteNumber (3.2)
+     * ```
+     */
+    min: min_,
+    /**
+     * Returns the maximum value from a list of finite numbers.
+     *
+     * @param values - The finite numbers to compare (at least one required)
+     * @returns The largest value as a FiniteNumber
+     *
+     * @example
+     * ```typescript
+     * const a = asFiniteNumber(5.5);
+     * const b = asFiniteNumber(3.2);
+     * const c = asFiniteNumber(7.8);
+     *
+     * FiniteNumber.max(a, b);      // FiniteNumber (7.8)
+     * FiniteNumber.max(a, b, c);   // FiniteNumber (7.8)
+     * ```
+     */
+    max: max_,
+    /**
+     * Returns the largest integer less than or equal to the given finite number.
+     * @param x - The finite number to floor
+     * @returns The floor value as an Int
+     * @example
+     * ```typescript
+     * FiniteNumber.floor(asFiniteNumber(5.8)); // Int (5)
+     * FiniteNumber.floor(asFiniteNumber(-5.2)); // Int (-6)
+     * ```
+     */
+    floor,
+    /**
+     * Returns the smallest integer greater than or equal to the given finite number.
+     * @param x - The finite number to ceil
+     * @returns The ceiling value as an Int
+     * @example
+     * ```typescript
+     * FiniteNumber.ceil(asFiniteNumber(5.2)); // Int (6)
+     * FiniteNumber.ceil(asFiniteNumber(-5.8)); // Int (-5)
+     * ```
+     */
+    ceil,
+    /**
+     * Rounds a finite number to the nearest integer.
+     * @param x - The finite number to round
+     * @returns The rounded value as an Int
+     * @example
+     * ```typescript
+     * FiniteNumber.round(asFiniteNumber(5.4)); // Int (5)
+     * FiniteNumber.round(asFiniteNumber(5.6)); // Int (6)
+     * FiniteNumber.round(asFiniteNumber(5.5)); // Int (6)
+     * ```
+     */
+    round,
+    /**
+     * Generates a random finite number within the specified range.
+     *
+     * The generated value is uniformly distributed in the range [min, max].
+     * Both bounds are inclusive.
+     *
+     * @param min - The minimum value (inclusive)
+     * @param max - The maximum value (inclusive)
+     * @returns A random FiniteNumber in the range [min, max]
+     *
+     * @example
+     * ```typescript
+     * // Random percentage (0-100)
+     * const pct = FiniteNumber.random(
+     *   asFiniteNumber(0),
+     *   asFiniteNumber(100)
+     * );
+     *
+     * // Random coordinate (-1 to 1)
+     * const coord = FiniteNumber.random(
+     *   asFiniteNumber(-1),
+     *   asFiniteNumber(1)
+     * );
+     * ```
+     */
+    random,
+    /**
+     * Raises a finite number to a power.
+     * @param a - The base finite number
+     * @param b - The exponent finite number
+     * @returns `a ** b` as a FiniteNumber
+     * @example
+     * ```typescript
+     * FiniteNumber.pow(asFiniteNumber(2.5), asFiniteNumber(3)); // FiniteNumber (15.625)
+     * ```
+     */
+    pow,
+    /**
+     * Adds two finite numbers.
+     * @param a - First finite number
+     * @param b - Second finite number
+     * @returns `a + b` as a FiniteNumber
+     * @example
+     * ```typescript
+     * FiniteNumber.add(asFiniteNumber(5.5), asFiniteNumber(3.2)); // FiniteNumber (8.7)
+     * ```
+     */
+    add,
+    /**
+     * Subtracts two finite numbers.
+     * @param a - First finite number
+     * @param b - Second finite number
+     * @returns `a - b` as a FiniteNumber
+     * @example
+     * ```typescript
+     * FiniteNumber.sub(asFiniteNumber(8.7), asFiniteNumber(3.2)); // FiniteNumber (5.5)
+     * ```
+     */
+    sub,
+    /**
+     * Multiplies two finite numbers.
+     * @param a - First finite number
+     * @param b - Second finite number
+     * @returns `a * b` as a FiniteNumber
+     * @example
+     * ```typescript
+     * FiniteNumber.mul(asFiniteNumber(5.5), asFiniteNumber(2)); // FiniteNumber (11)
+     * ```
+     */
+    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.
+     *
+     * @param a - The dividend
+     * @param b - The divisor (must be non-zero)
+     * @returns The quotient `a / b` as a FiniteNumber
+     *
+     * @example
+     * ```typescript
+     * const a = asFiniteNumber(11);
+     * const b = asFiniteNumber(2);
+     *
+     * FiniteNumber.div(a, b); // FiniteNumber (5.5)
+     *
+     * // With non-zero type guard
+     * const divisor = asFiniteNumber(userInput);
+     * if (Num.isNonZero(divisor)) {
+     *   const result = FiniteNumber.div(a, divisor);
+     * }
+     * ```
+     */
+    div,
+};
+
+export { FiniteNumber, asFiniteNumber, isFiniteNumber };
+//# sourceMappingURL=finite-number.mjs.map

package/dist/number/branded-types/finite-number.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"finite-number.mjs","sources":["../../../src/number/branded-types/finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iBAAiB;AAE3C,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,iBAAiB,CAI1D;AACA,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAE5E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA8D;AAE3E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAI5E;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;AASG;IACH,KAAK;AAEL;;;;;;;;;AASG;IACH,IAAI;AAEJ;;;;;;;;;;AAUG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/index.d.mts

@@ -0,0 +1,27 @@
+export * from './finite-number.mjs';
+export * from './int.mjs';
+export * from './int16.mjs';
+export * from './int32.mjs';
+export * from './non-negative-finite-number.mjs';
+export * from './non-negative-int16.mjs';
+export * from './non-negative-int32.mjs';
+export * from './non-zero-finite-number.mjs';
+export * from './non-zero-int.mjs';
+export * from './non-zero-int16.mjs';
+export * from './non-zero-int32.mjs';
+export * from './non-zero-safe-int.mjs';
+export * from './non-zero-uint16.mjs';
+export * from './non-zero-uint32.mjs';
+export * from './positive-finite-number.mjs';
+export * from './positive-int.mjs';
+export * from './positive-int16.mjs';
+export * from './positive-int32.mjs';
+export * from './positive-safe-int.mjs';
+export * from './positive-uint16.mjs';
+export * from './positive-uint32.mjs';
+export * from './safe-int.mjs';
+export * from './safe-uint.mjs';
+export * from './uint.mjs';
+export * from './uint16.mjs';
+export * from './uint32.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/number/branded-types/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/index.mts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC"}

package/dist/number/branded-types/index.mjs

@@ -0,0 +1,27 @@
+export { FiniteNumber, asFiniteNumber, isFiniteNumber } from './finite-number.mjs';
+export { Int, asInt, isInt } from './int.mjs';
+export { Int16, asInt16, isInt16 } from './int16.mjs';
+export { Int32, asInt32, isInt32 } from './int32.mjs';
+export { NonNegativeFiniteNumber, asNonNegativeFiniteNumber, isNonNegativeFiniteNumber } from './non-negative-finite-number.mjs';
+export { NonNegativeInt16, asNonNegativeInt16, isNonNegativeInt16 } from './non-negative-int16.mjs';
+export { NonNegativeInt32, asNonNegativeInt32, isNonNegativeInt32 } from './non-negative-int32.mjs';
+export { NonZeroFiniteNumber, asNonZeroFiniteNumber, isNonZeroFiniteNumber } from './non-zero-finite-number.mjs';
+export { NonZeroInt, asNonZeroInt, isNonZeroInt } from './non-zero-int.mjs';
+export { NonZeroInt16, asNonZeroInt16, isNonZeroInt16 } from './non-zero-int16.mjs';
+export { NonZeroInt32, asNonZeroInt32, isNonZeroInt32 } from './non-zero-int32.mjs';
+export { NonZeroSafeInt, asNonZeroSafeInt, isNonZeroSafeInt } from './non-zero-safe-int.mjs';
+export { NonZeroUint16, asNonZeroUint16, isNonZeroUint16 } from './non-zero-uint16.mjs';
+export { NonZeroUint32, asNonZeroUint32, isNonZeroUint32 } from './non-zero-uint32.mjs';
+export { PositiveFiniteNumber, asPositiveFiniteNumber, isPositiveFiniteNumber } from './positive-finite-number.mjs';
+export { PositiveInt, asPositiveInt, isPositiveInt } from './positive-int.mjs';
+export { PositiveInt16, asPositiveInt16, isPositiveInt16 } from './positive-int16.mjs';
+export { PositiveInt32, asPositiveInt32, isPositiveInt32 } from './positive-int32.mjs';
+export { PositiveSafeInt, asPositiveSafeInt, isPositiveSafeInt } from './positive-safe-int.mjs';
+export { PositiveUint16, asPositiveUint16, isPositiveUint16 } from './positive-uint16.mjs';
+export { PositiveUint32, asPositiveUint32, isPositiveUint32 } from './positive-uint32.mjs';
+export { SafeInt, asSafeInt, isSafeInt } from './safe-int.mjs';
+export { SafeUint, asSafeUint, isSafeUint } from './safe-uint.mjs';
+export { Uint, asUint, isUint } from './uint.mjs';
+export { Uint16, asUint16, isUint16 } from './uint16.mjs';
+export { Uint32, asUint32, isUint32 } from './uint32.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/number/branded-types/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;"}