ts-data-forge 1.0.0 → 1.0.2

package/dist/number/branded-types/non-negative-int32.mjs

@@ -0,0 +1,138 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a non-negative integer in [0, 2^31)';
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'SafeInteger',
+    MIN_VALUE: 0,
+    MAX_VALUE: 2 ** 31 - 1,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a NonNegativeInt32 (32-bit non-negative signed integer in the range [0, 2^31)).
+ * @param value The value to check.
+ * @returns `true` if the value is a NonNegativeInt32, `false` otherwise.
+ */
+const isNonNegativeInt32 = is;
+/**
+ * Casts a number to a NonNegativeInt32 type.
+ * @param value The value to cast.
+ * @returns The value as a NonNegativeInt32 type.
+ * @throws {TypeError} If the value is not a non-negative integer in [0, 2^31).
+ * @example
+ * ```typescript
+ * const x = asNonNegativeInt32(1000); // NonNegativeInt32
+ * const y = asNonNegativeInt32(0); // NonNegativeInt32
+ * // asNonNegativeInt32(-1); // throws TypeError
+ * // asNonNegativeInt32(2147483648); // throws TypeError
+ * ```
+ */
+const asNonNegativeInt32 = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for 32-bit non-negative integers.
+ *
+ * All operations automatically clamp results to the valid NonNegativeInt32 range [0, 2147483647].
+ * This ensures that all arithmetic maintains the 32-bit non-negative integer constraint,
+ * with negative results clamped to 0 and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asNonNegativeInt32(2000000000);
+ * const b = asNonNegativeInt32(500000000);
+ *
+ * // Arithmetic operations with automatic clamping
+ * const sum = NonNegativeInt32.add(a, b);       // NonNegativeInt32 (2147483647 - clamped to MAX_VALUE)
+ * const diff = NonNegativeInt32.sub(a, b);      // NonNegativeInt32 (1500000000)
+ * const reverseDiff = NonNegativeInt32.sub(b, a); // NonNegativeInt32 (0 - clamped to MIN_VALUE)
+ * const product = NonNegativeInt32.mul(a, b);   // NonNegativeInt32 (2147483647 - clamped due to overflow)
+ *
+ * // Range operations
+ * const clamped = NonNegativeInt32.clamp(-1000);     // NonNegativeInt32 (0)
+ * const minimum = NonNegativeInt32.min(a, b);        // NonNegativeInt32 (500000000)
+ * const maximum = NonNegativeInt32.max(a, b);        // NonNegativeInt32 (2000000000)
+ *
+ * // Utility operations
+ * const random = NonNegativeInt32.random();          // NonNegativeInt32 (random value in [0, 2147483647])
+ * const power = NonNegativeInt32.pow(asNonNegativeInt32(2), asNonNegativeInt32(20)); // NonNegativeInt32 (1048576)
+ * ```
+ */
+const NonNegativeInt32 = {
+    /**
+     * Type guard to check if a value is a NonNegativeInt32.
+     * @param value The value to check.
+     * @returns `true` if the value is a 32-bit non-negative integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for a 32-bit non-negative integer.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum value for a 32-bit non-negative integer.
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the smaller of two NonNegativeInt32 values.
+     * @param a The first NonNegativeInt32.
+     * @param b The second NonNegativeInt32.
+     * @returns The minimum value as a NonNegativeInt32.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two NonNegativeInt32 values.
+     * @param a The first NonNegativeInt32.
+     * @param b The second NonNegativeInt32.
+     * @returns The maximum value as a NonNegativeInt32.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the NonNegativeInt32 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [0, 2147483647] as a NonNegativeInt32.
+     */
+    clamp,
+    /**
+     * Generates a random NonNegativeInt32 value within the valid range.
+     * @returns A random NonNegativeInt32 between 0 and 2147483647.
+     */
+    random,
+    /**
+     * Raises a NonNegativeInt32 to the power of another NonNegativeInt32.
+     * @param a The base NonNegativeInt32.
+     * @param b The exponent NonNegativeInt32.
+     * @returns `a ** b` clamped to [0, 2147483647] as a NonNegativeInt32.
+     */
+    pow,
+    /**
+     * Adds two NonNegativeInt32 values.
+     * @param a The first NonNegativeInt32.
+     * @param b The second NonNegativeInt32.
+     * @returns `a + b` clamped to [0, 2147483647] as a NonNegativeInt32.
+     */
+    add,
+    /**
+     * Subtracts one NonNegativeInt32 from another.
+     * @param a The minuend NonNegativeInt32.
+     * @param b The subtrahend NonNegativeInt32.
+     * @returns `a - b` clamped to [0, 2147483647] as a NonNegativeInt32 (minimum 0).
+     */
+    sub,
+    /**
+     * Multiplies two NonNegativeInt32 values.
+     * @param a The first NonNegativeInt32.
+     * @param b The second NonNegativeInt32.
+     * @returns `a * b` clamped to [0, 2147483647] as a NonNegativeInt32.
+     */
+    mul,
+    /**
+     * Divides one NonNegativeInt32 by another using floor division.
+     * @param a The dividend NonNegativeInt32.
+     * @param b The divisor NonNegativeInt32.
+     * @returns `⌊a / b⌋` clamped to [0, 2147483647] as a NonNegativeInt32.
+     */
+    div,
+};
+
+export { NonNegativeInt32, asNonNegativeInt32, isNonNegativeInt32 };
+//# sourceMappingURL=non-negative-int32.mjs.map

package/dist/number/branded-types/non-negative-int32.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-negative-int32.mjs","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;AAYG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -0,0 +1,154 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+type ElementType = NonZeroFiniteNumber;
+/**
+ * Checks if a number is a NonZeroFiniteNumber (a finite number that is not 0).
+ * @param value The value to check.
+ * @returns `true` if the value is a NonZeroFiniteNumber, `false` otherwise.
+ */
+export declare const isNonZeroFiniteNumber: (a: number) => a is NonZeroFiniteNumber;
+/**
+ * Casts a number to a NonZeroFiniteNumber type.
+ * @param value The value to cast.
+ * @returns The value as a NonZeroFiniteNumber type.
+ * @throws {TypeError} If the value is not a non-zero finite number.
+ * @example
+ * ```typescript
+ * const x = asNonZeroFiniteNumber(5.5); // NonZeroFiniteNumber
+ * const y = asNonZeroFiniteNumber(-3.2); // NonZeroFiniteNumber
+ * // asNonZeroFiniteNumber(0); // throws TypeError
+ * // asNonZeroFiniteNumber(Infinity); // throws TypeError
+ * ```
+ */
+export declare const asNonZeroFiniteNumber: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly "!=0": true;
+    readonly Finite: true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for non-zero finite numbers.
+ *
+ * All operations maintain the non-zero constraint while ensuring results remain finite
+ * (excluding NaN and Infinity). This type is useful for values that must never be zero,
+ * such as denominators, scaling factors, and ratios.
+ *
+ * @example
+ * ```typescript
+ * const factor = asNonZeroFiniteNumber(2.5);
+ * const multiplier = asNonZeroFiniteNumber(-1.5);
+ *
+ * // Arithmetic operations that preserve non-zero constraint
+ * const result = NonZeroFiniteNumber.add(factor, multiplier);        // NonZeroFiniteNumber (1.0)
+ * const difference = NonZeroFiniteNumber.sub(factor, multiplier);    // NonZeroFiniteNumber (4.0)
+ * const product = NonZeroFiniteNumber.mul(factor, multiplier);       // NonZeroFiniteNumber (-3.75)
+ * const quotient = NonZeroFiniteNumber.div(factor, multiplier);      // NonZeroFiniteNumber (-1.666...)
+ *
+ * // Utility operations
+ * const absolute = NonZeroFiniteNumber.abs(multiplier);              // NonZeroFiniteNumber (1.5)
+ * const minimum = NonZeroFiniteNumber.min(factor, multiplier);       // NonZeroFiniteNumber (-1.5)
+ * const maximum = NonZeroFiniteNumber.max(factor, multiplier);       // NonZeroFiniteNumber (2.5)
+ *
+ * // Rounding operations (return NonZeroInt)
+ * const rounded = NonZeroFiniteNumber.round(factor);                 // NonZeroInt (3)
+ * const floored = NonZeroFiniteNumber.floor(factor);                 // NonZeroInt (2)
+ * const ceiled = NonZeroFiniteNumber.ceil(factor);                   // NonZeroInt (3)
+ *
+ * // Random generation
+ * const randomValue = NonZeroFiniteNumber.random();                  // NonZeroFiniteNumber (random non-zero value)
+ * ```
+ */
+export declare const NonZeroFiniteNumber: {
+    /**
+     * Type guard to check if a value is a NonZeroFiniteNumber.
+     * @param value The value to check.
+     * @returns `true` if the value is a non-zero finite number, `false` otherwise.
+     */
+    readonly is: (a: number) => a is NonZeroFiniteNumber;
+    /**
+     * Returns the absolute value of a non-zero finite number.
+     * @param a The NonZeroFiniteNumber.
+     * @returns The absolute value as a NonZeroFiniteNumber.
+     */
+    readonly abs: (x: NonZeroFiniteNumber) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<NonZeroFiniteNumber>;
+    /**
+     * Returns the smaller of two NonZeroFiniteNumber values.
+     * @param a The first NonZeroFiniteNumber.
+     * @param b The second NonZeroFiniteNumber.
+     * @returns The minimum value as a NonZeroFiniteNumber.
+     */
+    readonly min: (...values: readonly NonZeroFiniteNumber[]) => NonZeroFiniteNumber;
+    /**
+     * Returns the larger of two NonZeroFiniteNumber values.
+     * @param a The first NonZeroFiniteNumber.
+     * @param b The second NonZeroFiniteNumber.
+     * @returns The maximum value as a NonZeroFiniteNumber.
+     */
+    readonly max: (...values: readonly NonZeroFiniteNumber[]) => NonZeroFiniteNumber;
+    /**
+     * Rounds down a NonZeroFiniteNumber to the nearest integer.
+     * @param x The NonZeroFiniteNumber to round down.
+     * @returns The floor value as a NonZeroInt.
+     */
+    readonly floor: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    /**
+     * Rounds up a NonZeroFiniteNumber to the nearest integer.
+     * @param x The NonZeroFiniteNumber to round up.
+     * @returns The ceiling value as a NonZeroInt.
+     */
+    readonly ceil: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    /**
+     * Rounds a NonZeroFiniteNumber to the nearest integer.
+     * @param x The NonZeroFiniteNumber to round.
+     * @returns The rounded value as a NonZeroInt.
+     */
+    readonly round: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    /**
+     * Generates a random NonZeroFiniteNumber value.
+     * @returns A random non-zero finite number.
+     */
+    readonly random: (min: NonZeroFiniteNumber, max: NonZeroFiniteNumber) => NonZeroFiniteNumber;
+    /**
+     * Raises a NonZeroFiniteNumber to the power of another NonZeroFiniteNumber.
+     * @param a The base NonZeroFiniteNumber.
+     * @param b The exponent NonZeroFiniteNumber.
+     * @returns `a ** b` as a NonZeroFiniteNumber.
+     */
+    readonly pow: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
+    /**
+     * Adds two NonZeroFiniteNumber values.
+     * @param a The first NonZeroFiniteNumber.
+     * @param b The second NonZeroFiniteNumber.
+     * @returns `a + b` as a NonZeroFiniteNumber.
+     */
+    readonly add: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
+    /**
+     * Subtracts one NonZeroFiniteNumber from another.
+     * @param a The minuend NonZeroFiniteNumber.
+     * @param b The subtrahend NonZeroFiniteNumber.
+     * @returns `a - b` as a NonZeroFiniteNumber.
+     */
+    readonly sub: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
+    /**
+     * Multiplies two NonZeroFiniteNumber values.
+     * @param a The first NonZeroFiniteNumber.
+     * @param b The second NonZeroFiniteNumber.
+     * @returns `a * b` as a NonZeroFiniteNumber.
+     */
+    readonly mul: (x: NonZeroFiniteNumber, y: NonZeroFiniteNumber) => NonZeroFiniteNumber;
+    /**
+     * Divides one NonZeroFiniteNumber by another.
+     * @param a The dividend NonZeroFiniteNumber.
+     * @param b The divisor NonZeroFiniteNumber.
+     * @returns `a / b` as a NonZeroFiniteNumber.
+     */
+    readonly div: (x: NonZeroFiniteNumber, y: number & {
+        readonly NaNValue: false;
+        readonly "!=0": true;
+        readonly Finite: true;
+    } & Readonly<{
+        'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+    }>) => NonZeroFiniteNumber;
+};
+export {};
+//# sourceMappingURL=non-zero-finite-number.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AA2DvC;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,yCAAK,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;wBAtHA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAwH1D;;;;OAIG;uBAvHA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAyH1D;;;;OAIG;wBAxHA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA0H1D;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;CAEK,CAAC"}

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

@@ -0,0 +1,160 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a non-zero finite number';
+const { abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: random, is, castType, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForFloat({
+    nonZero: true,
+    MIN_VALUE: undefined,
+    MAX_VALUE: undefined,
+    typeNameInMessage,
+});
+// Not provided because reasonable rounding operations that avoid becoming 0 cannot be defined
+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);
+/**
+ * Checks if a number is a NonZeroFiniteNumber (a finite number that is not 0).
+ * @param value The value to check.
+ * @returns `true` if the value is a NonZeroFiniteNumber, `false` otherwise.
+ */
+const isNonZeroFiniteNumber = is;
+/**
+ * Casts a number to a NonZeroFiniteNumber type.
+ * @param value The value to cast.
+ * @returns The value as a NonZeroFiniteNumber type.
+ * @throws {TypeError} If the value is not a non-zero finite number.
+ * @example
+ * ```typescript
+ * const x = asNonZeroFiniteNumber(5.5); // NonZeroFiniteNumber
+ * const y = asNonZeroFiniteNumber(-3.2); // NonZeroFiniteNumber
+ * // asNonZeroFiniteNumber(0); // throws TypeError
+ * // asNonZeroFiniteNumber(Infinity); // throws TypeError
+ * ```
+ */
+const asNonZeroFiniteNumber = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for non-zero finite numbers.
+ *
+ * All operations maintain the non-zero constraint while ensuring results remain finite
+ * (excluding NaN and Infinity). This type is useful for values that must never be zero,
+ * such as denominators, scaling factors, and ratios.
+ *
+ * @example
+ * ```typescript
+ * const factor = asNonZeroFiniteNumber(2.5);
+ * const multiplier = asNonZeroFiniteNumber(-1.5);
+ *
+ * // Arithmetic operations that preserve non-zero constraint
+ * const result = NonZeroFiniteNumber.add(factor, multiplier);        // NonZeroFiniteNumber (1.0)
+ * const difference = NonZeroFiniteNumber.sub(factor, multiplier);    // NonZeroFiniteNumber (4.0)
+ * const product = NonZeroFiniteNumber.mul(factor, multiplier);       // NonZeroFiniteNumber (-3.75)
+ * const quotient = NonZeroFiniteNumber.div(factor, multiplier);      // NonZeroFiniteNumber (-1.666...)
+ *
+ * // Utility operations
+ * const absolute = NonZeroFiniteNumber.abs(multiplier);              // NonZeroFiniteNumber (1.5)
+ * const minimum = NonZeroFiniteNumber.min(factor, multiplier);       // NonZeroFiniteNumber (-1.5)
+ * const maximum = NonZeroFiniteNumber.max(factor, multiplier);       // NonZeroFiniteNumber (2.5)
+ *
+ * // Rounding operations (return NonZeroInt)
+ * const rounded = NonZeroFiniteNumber.round(factor);                 // NonZeroInt (3)
+ * const floored = NonZeroFiniteNumber.floor(factor);                 // NonZeroInt (2)
+ * const ceiled = NonZeroFiniteNumber.ceil(factor);                   // NonZeroInt (3)
+ *
+ * // Random generation
+ * const randomValue = NonZeroFiniteNumber.random();                  // NonZeroFiniteNumber (random non-zero value)
+ * ```
+ */
+const NonZeroFiniteNumber = {
+    /**
+     * Type guard to check if a value is a NonZeroFiniteNumber.
+     * @param value The value to check.
+     * @returns `true` if the value is a non-zero finite number, `false` otherwise.
+     */
+    is,
+    /**
+     * Returns the absolute value of a non-zero finite number.
+     * @param a The NonZeroFiniteNumber.
+     * @returns The absolute value as a NonZeroFiniteNumber.
+     */
+    abs,
+    /**
+     * Returns the smaller of two NonZeroFiniteNumber values.
+     * @param a The first NonZeroFiniteNumber.
+     * @param b The second NonZeroFiniteNumber.
+     * @returns The minimum value as a NonZeroFiniteNumber.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two NonZeroFiniteNumber values.
+     * @param a The first NonZeroFiniteNumber.
+     * @param b The second NonZeroFiniteNumber.
+     * @returns The maximum value as a NonZeroFiniteNumber.
+     */
+    max: max_,
+    /**
+     * Rounds down a NonZeroFiniteNumber to the nearest integer.
+     * @param x The NonZeroFiniteNumber to round down.
+     * @returns The floor value as a NonZeroInt.
+     */
+    floor,
+    /**
+     * Rounds up a NonZeroFiniteNumber to the nearest integer.
+     * @param x The NonZeroFiniteNumber to round up.
+     * @returns The ceiling value as a NonZeroInt.
+     */
+    ceil,
+    /**
+     * Rounds a NonZeroFiniteNumber to the nearest integer.
+     * @param x The NonZeroFiniteNumber to round.
+     * @returns The rounded value as a NonZeroInt.
+     */
+    round,
+    /**
+     * Generates a random NonZeroFiniteNumber value.
+     * @returns A random non-zero finite number.
+     */
+    random,
+    /**
+     * Raises a NonZeroFiniteNumber to the power of another NonZeroFiniteNumber.
+     * @param a The base NonZeroFiniteNumber.
+     * @param b The exponent NonZeroFiniteNumber.
+     * @returns `a ** b` as a NonZeroFiniteNumber.
+     */
+    pow,
+    /**
+     * Adds two NonZeroFiniteNumber values.
+     * @param a The first NonZeroFiniteNumber.
+     * @param b The second NonZeroFiniteNumber.
+     * @returns `a + b` as a NonZeroFiniteNumber.
+     */
+    add,
+    /**
+     * Subtracts one NonZeroFiniteNumber from another.
+     * @param a The minuend NonZeroFiniteNumber.
+     * @param b The subtrahend NonZeroFiniteNumber.
+     * @returns `a - b` as a NonZeroFiniteNumber.
+     */
+    sub,
+    /**
+     * Multiplies two NonZeroFiniteNumber values.
+     * @param a The first NonZeroFiniteNumber.
+     * @param b The second NonZeroFiniteNumber.
+     * @returns `a * b` as a NonZeroFiniteNumber.
+     */
+    mul,
+    /**
+     * Divides one NonZeroFiniteNumber by another.
+     * @param a The dividend NonZeroFiniteNumber.
+     * @param b The divisor NonZeroFiniteNumber.
+     * @returns `a / b` as a NonZeroFiniteNumber.
+     */
+    div,
+};
+
+export { NonZeroFiniteNumber, asNonZeroFiniteNumber, isNonZeroFiniteNumber };
+//# sourceMappingURL=non-zero-finite-number.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"non-zero-finite-number.mjs","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,EAAE,EACF,QAAQ,GACT,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,iBAAiB,CAI1D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX;AAEA,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;AAc5E;;;;AAIG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;;;AAYG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACI,MAAM,mBAAmB,GAAG;AACjC;;;;AAIG;IACH,EAAE;AAEF;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,IAAI;AAEJ;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/non-zero-int.d.mts

@@ -0,0 +1,131 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+/**
+ * Checks if a number is a NonZeroInt.
+ * @param value The value to check.
+ * @returns `true` if the value is a NonZeroInt, `false` otherwise.
+ */
+export declare const isNonZeroInt: (a: number) => a is NonZeroInt;
+/**
+ * Casts a number to a NonZeroInt type.
+ * @param value The value to cast.
+ * @returns The value as a NonZeroInt type.
+ * @throws {TypeError} If the value is not a non-zero integer.
+ * @example
+ * ```typescript
+ * const x = asNonZeroInt(5); // NonZeroInt
+ * const y = asNonZeroInt(-3); // NonZeroInt
+ * // asNonZeroInt(0); // throws TypeError
+ * // asNonZeroInt(1.5); // throws TypeError
+ * ```
+ */
+export declare const asNonZeroInt: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    readonly "!=0": true;
+    readonly Finite: true;
+    readonly Int: true;
+} & Readonly<{
+    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+}> & N;
+/**
+ * Namespace providing type-safe arithmetic operations for non-zero integers.
+ *
+ * All operations maintain the non-zero constraint, ensuring that results are always valid NonZeroInt values.
+ * Division operations return floor division results, and all arithmetic maintains integer precision.
+ *
+ * @example
+ * ```typescript
+ * const a = asNonZeroInt(10);
+ * const b = asNonZeroInt(-5);
+ *
+ * // Arithmetic operations
+ * const sum = NonZeroInt.add(a, b);     // NonZeroInt (5)
+ * const diff = NonZeroInt.sub(a, b);    // NonZeroInt (15)
+ * const product = NonZeroInt.mul(a, b); // NonZeroInt (-50)
+ * const quotient = NonZeroInt.div(a, b); // NonZeroInt (-2)
+ *
+ * // Utility operations
+ * const absolute = NonZeroInt.abs(b);   // NonZeroInt (5)
+ * const power = NonZeroInt.pow(a, asNonZeroInt(2)); // NonZeroInt (100)
+ * const minimum = NonZeroInt.min(a, b); // NonZeroInt (-5)
+ * const maximum = NonZeroInt(a, b); // NonZeroInt (10)
+ *
+ * // Random generation
+ * const randomInt = NonZeroInt.random(); // NonZeroInt (random non-zero integer)
+ * ```
+ */
+export declare const NonZeroInt: {
+    /**
+     * Type guard to check if a value is a NonZeroInt.
+     * @param value The value to check.
+     * @returns `true` if the value is a non-zero integer, `false` otherwise.
+     */
+    readonly is: (a: number) => a is NonZeroInt;
+    /**
+     * Returns the absolute value of a non-zero integer.
+     * @param a The non-zero integer.
+     * @returns The absolute value as a NonZeroInt.
+     */
+    readonly abs: (x: WithSmallInt<NonZeroInt, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt>;
+    /**
+     * Returns the smaller of two non-zero integers.
+     * @param a The first non-zero integer.
+     * @param b The second non-zero integer.
+     * @returns The minimum value as a NonZeroInt.
+     */
+    readonly min: (...values: readonly WithSmallInt<NonZeroInt, 40>[]) => NonZeroInt;
+    /**
+     * Returns the larger of two non-zero integers.
+     * @param a The first non-zero integer.
+     * @param b The second non-zero integer.
+     * @returns The maximum value as a NonZeroInt.
+     */
+    readonly max: (...values: readonly WithSmallInt<NonZeroInt, 40>[]) => NonZeroInt;
+    /**
+     * Generates a random non-zero integer.
+     * @returns A random NonZeroInt value.
+     */
+    readonly random: (min: WithSmallInt<NonZeroInt, 40>, max: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
+    /**
+     * Raises a non-zero integer to the power of another non-zero integer.
+     * @param a The base non-zero integer.
+     * @param b The exponent non-zero integer.
+     * @returns `a ** b` as a NonZeroInt.
+     */
+    readonly pow: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
+    /**
+     * Adds two non-zero integers.
+     * @param a The first non-zero integer.
+     * @param b The second non-zero integer.
+     * @returns `a + b` as a NonZeroInt.
+     */
+    readonly add: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
+    /**
+     * Subtracts one non-zero integer from another.
+     * @param a The minuend non-zero integer.
+     * @param b The subtrahend non-zero integer.
+     * @returns `a - b` as a NonZeroInt.
+     */
+    readonly sub: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
+    /**
+     * Multiplies two non-zero integers.
+     * @param a The first non-zero integer.
+     * @param b The second non-zero integer.
+     * @returns `a * b` as a NonZeroInt.
+     */
+    readonly mul: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
+    /**
+     * Divides one non-zero integer by another using floor division.
+     * @param a The dividend non-zero integer.
+     * @param b The divisor non-zero integer.
+     * @returns `⌊a / b⌋` as a NonZeroInt.
+     */
+    readonly div: (x: WithSmallInt<NonZeroInt, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | -1 | -2 | -3 | -32 | -4 | -5 | -6 | -7 | -8 | -9 | -11 | -10 | -24 | -14 | -34 | -12 | -13 | -15 | -16 | -17 | -18 | -19 | -20 | -21 | -22 | -23 | -25 | -26 | -27 | -28 | -29 | -30 | -31 | -33 | -35 | -36 | -37 | -38 | -39 | -40 | NormalizeBrandUnion<number & {
+        readonly NaNValue: false;
+        readonly "!=0": true;
+        readonly Finite: true;
+        readonly Int: true;
+    } & Readonly<{
+        'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
+    }>>) => NonZeroInt;
+};
+//# sourceMappingURL=non-zero-int.d.mts.map

package/dist/number/branded-types/non-zero-int.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AA8BlE;;;;GAIG;AACH,eAAO,MAAM,YAAY,gCAAK,CAAC;AAE/B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,UAAU;IACrB;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;CAEK,CAAC"}