ts-data-forge 3.3.0 → 3.3.1

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

@@ -1,22 +1,18 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
- * Checks if a number is a NonZeroInt32 (32-bit non-zero signed integer in the range [-2^31, 2^31) excluding 0).
+ * Checks if a number is a NonZeroInt32 (32-bit non-zero signed integer in the
+ * range [-2^31, 2^31) excluding 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt32, `false` otherwise.
  */
 export declare const isNonZeroInt32: (a: number) => a is NonZeroInt32;
 /**
  * Casts a number to a NonZeroInt32 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroInt32 type.
  * @throws {TypeError} If the value is not a non-zero integer in [-2^31, 2^31).
- * @example
- * ```typescript
- * const x = asNonZeroInt32(1000); // NonZeroInt32
- * const y = asNonZeroInt32(-1000); // NonZeroInt32
- * // asNonZeroInt32(0); // throws TypeError
- * // asNonZeroInt32(2147483648); // throws TypeError
- * ```
  */
 export declare const asNonZeroInt32: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -32,58 +28,45 @@ export declare const asNonZeroInt32: <N extends number>(x: N) => number & {
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
 /**
- * Namespace providing type-safe arithmetic operations for 32-bit non-zero signed integers.
- *
- * All operations automatically clamp results to the valid NonZeroInt32 range [-2147483648, 2147483647]
- * excluding 0. This ensures that all arithmetic maintains the 32-bit non-zero signed integer
- * constraint, preventing zero results and overflow.
- *
- * @example
- * ```typescript
- * const a = asNonZeroInt32(2000000000);
- * const b = asNonZeroInt32(-500000000);
- *
- * // Arithmetic operations with automatic clamping and non-zero constraint
- * const sum = NonZeroInt32.add(a, b);       // NonZeroInt32 (1500000000)
- * const diff = NonZeroInt32.sub(a, b);      // NonZeroInt32 (2147483647 - clamped to MAX_VALUE)
- * const product = NonZeroInt32.mul(a, b);   // NonZeroInt32 (-2147483648 - clamped to MIN_VALUE)
- *
- * // Utility operations
- * const absolute = NonZeroInt32.abs(b);         // NonZeroInt32 (500000000)
- * const minimum = NonZeroInt32.min(a, b);       // NonZeroInt32 (-500000000)
- * const maximum = NonZeroInt32.max(a, b);       // NonZeroInt32 (2000000000)
+ * Namespace providing type-safe arithmetic operations for 32-bit non-zero
+ * signed integers.
  *
- * // Range operations (avoiding zero)
- * const clamped = NonZeroInt32.clamp(0);        // NonZeroInt32 (1 or -1, avoiding zero)
- * const random = NonZeroInt32.random();         // NonZeroInt32 (random non-zero value in range)
- * const power = NonZeroInt32.pow(asNonZeroInt32(2), asNonZeroInt32(20)); // NonZeroInt32 (1048576)
- * ```
+ * All operations automatically clamp results to the valid NonZeroInt32 range
+ * [-2147483648, 2147483647] excluding 0. This ensures that all arithmetic
+ * maintains the 32-bit non-zero signed integer constraint, preventing zero
+ * results and overflow.
  */
 export declare const NonZeroInt32: {
     /**
      * Type guard to check if a value is a NonZeroInt32.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 32-bit non-zero signed integer, `false` otherwise.
+     * @returns `true` if the value is a 32-bit non-zero signed integer, `false`
+     *   otherwise.
      */
     readonly is: (a: number) => a is NonZeroInt32;
     /**
      * The minimum value for a 32-bit non-zero signed integer.
+     *
      * @readonly
      */
     readonly MIN_VALUE: number;
     /**
      * The maximum value for a 32-bit non-zero signed integer.
+     *
      * @readonly
      */
     readonly MAX_VALUE: number;
     /**
      * Returns the absolute value of a 32-bit non-zero signed integer.
+     *
      * @param a The NonZeroInt32 value.
      * @returns The absolute value as a NonZeroInt32, clamped to valid range.
      */
     readonly abs: (x: WithSmallInt<NonZeroInt32, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt32>;
     /**
      * Returns the smaller of two NonZeroInt32 values.
+     *
      * @param a The first NonZeroInt32.
      * @param b The second NonZeroInt32.
      * @returns The minimum value as a NonZeroInt32.
@@ -91,6 +74,7 @@ export declare const NonZeroInt32: {
     readonly min: (...values: readonly WithSmallInt<NonZeroInt32, 40>[]) => NonZeroInt32;
     /**
      * Returns the larger of two NonZeroInt32 values.
+     *
      * @param a The first NonZeroInt32.
      * @param b The second NonZeroInt32.
      * @returns The maximum value as a NonZeroInt32.
@@ -98,17 +82,22 @@ export declare const NonZeroInt32: {
     readonly max: (...values: readonly WithSmallInt<NonZeroInt32, 40>[]) => NonZeroInt32;
     /**
      * Clamps a number to the NonZeroInt32 range (avoiding zero).
+     *
      * @param value The number to clamp.
-     * @returns The value clamped to [-2147483648, 2147483647] \ {0} as a NonZeroInt32.
+     * @returns The value clamped to [-2147483648, 2147483647] \ {0} as a
+     *   NonZeroInt32.
      */
     readonly clamp: (x: number) => NonZeroInt32;
     /**
      * Generates a random NonZeroInt32 value within the valid range.
-     * @returns A random NonZeroInt32 between MIN_VALUE and MAX_VALUE (excluding 0).
+     *
+     * @returns A random NonZeroInt32 between MIN_VALUE and MAX_VALUE (excluding
+     *   0).
      */
     readonly random: (min?: WithSmallInt<NonZeroInt32, 40> | undefined, max?: WithSmallInt<NonZeroInt32, 40> | undefined) => NonZeroInt32;
     /**
      * Raises a NonZeroInt32 to the power of another NonZeroInt32.
+     *
      * @param a The base NonZeroInt32.
      * @param b The exponent NonZeroInt32.
      * @returns `a ** b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
@@ -116,6 +105,7 @@ export declare const NonZeroInt32: {
     readonly pow: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
     /**
      * Adds two NonZeroInt32 values.
+     *
      * @param a The first NonZeroInt32.
      * @param b The second NonZeroInt32.
      * @returns `a + b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
@@ -123,6 +113,7 @@ export declare const NonZeroInt32: {
     readonly add: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
     /**
      * Subtracts one NonZeroInt32 from another.
+     *
      * @param a The minuend NonZeroInt32.
      * @param b The subtrahend NonZeroInt32.
      * @returns `a - b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
@@ -130,6 +121,7 @@ export declare const NonZeroInt32: {
     readonly sub: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
     /**
      * Multiplies two NonZeroInt32 values.
+     *
      * @param a The first NonZeroInt32.
      * @param b The second NonZeroInt32.
      * @returns `a * b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
@@ -137,6 +129,7 @@ export declare const NonZeroInt32: {
     readonly mul: (x: WithSmallInt<NonZeroInt32, 40>, y: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
     /**
      * Divides one NonZeroInt32 by another using floor division.
+     *
      * @param a The dividend NonZeroInt32.
      * @param b The divisor NonZeroInt32.
      * @returns `⌊a / b⌋` clamped to [-2147483648, 2147483647] as a NonZeroInt32.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAiCnE;;;;GAIG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,YAAY;IACvB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAiCnE;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -9,78 +9,61 @@ const { MIN_VALUE, MAX_VALUE, abs, min: min_, max: max_, pow, add, sub, mul, div
     typeNameInMessage,
 });
 /**
- * Checks if a number is a NonZeroInt32 (32-bit non-zero signed integer in the range [-2^31, 2^31) excluding 0).
+ * Checks if a number is a NonZeroInt32 (32-bit non-zero signed integer in the
+ * range [-2^31, 2^31) excluding 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt32, `false` otherwise.
  */
 const isNonZeroInt32 = is;
 /**
  * Casts a number to a NonZeroInt32 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroInt32 type.
  * @throws {TypeError} If the value is not a non-zero integer in [-2^31, 2^31).
- * @example
- * ```typescript
- * const x = asNonZeroInt32(1000); // NonZeroInt32
- * const y = asNonZeroInt32(-1000); // NonZeroInt32
- * // asNonZeroInt32(0); // throws TypeError
- * // asNonZeroInt32(2147483648); // throws TypeError
- * ```
  */
 const asNonZeroInt32 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 32-bit non-zero signed integers.
- *
- * All operations automatically clamp results to the valid NonZeroInt32 range [-2147483648, 2147483647]
- * excluding 0. This ensures that all arithmetic maintains the 32-bit non-zero signed integer
- * constraint, preventing zero results and overflow.
- *
- * @example
- * ```typescript
- * const a = asNonZeroInt32(2000000000);
- * const b = asNonZeroInt32(-500000000);
- *
- * // Arithmetic operations with automatic clamping and non-zero constraint
- * const sum = NonZeroInt32.add(a, b);       // NonZeroInt32 (1500000000)
- * const diff = NonZeroInt32.sub(a, b);      // NonZeroInt32 (2147483647 - clamped to MAX_VALUE)
- * const product = NonZeroInt32.mul(a, b);   // NonZeroInt32 (-2147483648 - clamped to MIN_VALUE)
- *
- * // Utility operations
- * const absolute = NonZeroInt32.abs(b);         // NonZeroInt32 (500000000)
- * const minimum = NonZeroInt32.min(a, b);       // NonZeroInt32 (-500000000)
- * const maximum = NonZeroInt32.max(a, b);       // NonZeroInt32 (2000000000)
+ * Namespace providing type-safe arithmetic operations for 32-bit non-zero
+ * signed integers.
  *
- * // Range operations (avoiding zero)
- * const clamped = NonZeroInt32.clamp(0);        // NonZeroInt32 (1 or -1, avoiding zero)
- * const random = NonZeroInt32.random();         // NonZeroInt32 (random non-zero value in range)
- * const power = NonZeroInt32.pow(asNonZeroInt32(2), asNonZeroInt32(20)); // NonZeroInt32 (1048576)
- * ```
+ * All operations automatically clamp results to the valid NonZeroInt32 range
+ * [-2147483648, 2147483647] excluding 0. This ensures that all arithmetic
+ * maintains the 32-bit non-zero signed integer constraint, preventing zero
+ * results and overflow.
  */
 const NonZeroInt32 = {
     /**
      * Type guard to check if a value is a NonZeroInt32.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 32-bit non-zero signed integer, `false` otherwise.
+     * @returns `true` if the value is a 32-bit non-zero signed integer, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for a 32-bit non-zero signed integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a 32-bit non-zero signed integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the absolute value of a 32-bit non-zero signed integer.
+     *
      * @param a The NonZeroInt32 value.
      * @returns The absolute value as a NonZeroInt32, clamped to valid range.
      */
     abs,
     /**
      * Returns the smaller of two NonZeroInt32 values.
+     *
      * @param a The first NonZeroInt32.
      * @param b The second NonZeroInt32.
      * @returns The minimum value as a NonZeroInt32.
@@ -88,6 +71,7 @@ const NonZeroInt32 = {
     min: min_,
     /**
      * Returns the larger of two NonZeroInt32 values.
+     *
      * @param a The first NonZeroInt32.
      * @param b The second NonZeroInt32.
      * @returns The maximum value as a NonZeroInt32.
@@ -95,17 +79,22 @@ const NonZeroInt32 = {
     max: max_,
     /**
      * Clamps a number to the NonZeroInt32 range (avoiding zero).
+     *
      * @param value The number to clamp.
-     * @returns The value clamped to [-2147483648, 2147483647] \ {0} as a NonZeroInt32.
+     * @returns The value clamped to [-2147483648, 2147483647] \ {0} as a
+     *   NonZeroInt32.
      */
     clamp,
     /**
      * Generates a random NonZeroInt32 value within the valid range.
-     * @returns A random NonZeroInt32 between MIN_VALUE and MAX_VALUE (excluding 0).
+     *
+     * @returns A random NonZeroInt32 between MIN_VALUE and MAX_VALUE (excluding
+     *   0).
      */
     random,
     /**
      * Raises a NonZeroInt32 to the power of another NonZeroInt32.
+     *
      * @param a The base NonZeroInt32.
      * @param b The exponent NonZeroInt32.
      * @returns `a ** b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
@@ -113,6 +102,7 @@ const NonZeroInt32 = {
     pow,
     /**
      * Adds two NonZeroInt32 values.
+     *
      * @param a The first NonZeroInt32.
      * @param b The second NonZeroInt32.
      * @returns `a + b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
@@ -120,6 +110,7 @@ const NonZeroInt32 = {
     add,
     /**
      * Subtracts one NonZeroInt32 from another.
+     *
      * @param a The minuend NonZeroInt32.
      * @param b The subtrahend NonZeroInt32.
      * @returns `a - b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
@@ -127,6 +118,7 @@ const NonZeroInt32 = {
     sub,
     /**
      * Multiplies two NonZeroInt32 values.
+     *
      * @param a The first NonZeroInt32.
      * @param b The second NonZeroInt32.
      * @returns `a * b` clamped to [-2147483648, 2147483647] as a NonZeroInt32.
@@ -134,6 +126,7 @@ const NonZeroInt32 = {
     mul,
     /**
      * Divides one NonZeroInt32 by another using floor division.
+     *
      * @param a The dividend NonZeroInt32.
      * @param b The divisor NonZeroInt32.
      * @returns `⌊a / b⌋` clamped to [-2147483648, 2147483647] as a NonZeroInt32.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int32.mjs","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,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,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,WAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;AAYG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;IACH,GAAG;AAEH;;;;;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;;;;;"}
+{"version":3,"file":"non-zero-int32.mjs","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,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,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,WAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;AAMG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;AAQG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;IACH,KAAK;AAEL;;;;;AAKG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,22 +1,18 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
- * Checks if a number is a NonZeroSafeInt (a non-zero safe integer in the range [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] excluding 0).
+ * Checks if a number is a NonZeroSafeInt (a non-zero safe integer in the range
+ * [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] excluding 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroSafeInt, `false` otherwise.
  */
 export declare const isNonZeroSafeInt: (a: number) => a is NonZeroSafeInt;
 /**
  * Casts a number to a NonZeroSafeInt type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroSafeInt type.
  * @throws {TypeError} If the value is not a non-zero safe integer.
- * @example
- * ```typescript
- * const x = asNonZeroSafeInt(5); // NonZeroSafeInt
- * const y = asNonZeroSafeInt(-1000); // NonZeroSafeInt
- * // asNonZeroSafeInt(0); // throws TypeError
- * // asNonZeroSafeInt(1.5); // throws TypeError
- * ```
  */
 export declare const asNonZeroSafeInt: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -28,56 +24,44 @@ export declare const asNonZeroSafeInt: <N extends number>(x: N) => number & {
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
 /**
- * Namespace providing type-safe arithmetic operations for non-zero safe integers.
- *
- * All operations automatically clamp results to the non-zero safe integer range, excluding zero.
- * This ensures that all arithmetic maintains both the non-zero constraint and IEEE 754 precision guarantees,
- * preventing precision loss while ensuring results are never zero.
- *
- * @example
- * ```typescript
- * const a = asNonZeroSafeInt(9007199254740000);  // Near MAX_SAFE_INTEGER
- * const b = asNonZeroSafeInt(-1000);
- *
- * // Arithmetic operations with non-zero safe range clamping
- * const sum = NonZeroSafeInt.add(a, b);          // NonZeroSafeInt (9007199254739000)
- * const diff = NonZeroSafeInt.sub(a, b);         // NonZeroSafeInt (clamped to MAX_SAFE_INTEGER)
- * const product = NonZeroSafeInt.mul(a, b);      // NonZeroSafeInt (clamped to MIN_SAFE_INTEGER)
- *
- * // Utility operations
- * const absolute = NonZeroSafeInt.abs(b);            // NonZeroSafeInt (1000)
- * const minimum = NonZeroSafeInt.min(a, b);          // NonZeroSafeInt (-1000)
- * const maximum = NonZeroSafeInt.max(a, b);          // NonZeroSafeInt (a)
+ * Namespace providing type-safe arithmetic operations for non-zero safe
+ * integers.
  *
- * // Random generation
- * const random = NonZeroSafeInt.random();            // NonZeroSafeInt (random non-zero safe integer)
- * ```
+ * All operations automatically clamp results to the non-zero safe integer
+ * range, excluding zero. This ensures that all arithmetic maintains both the
+ * non-zero constraint and IEEE 754 precision guarantees, preventing precision
+ * loss while ensuring results are never zero.
  */
 export declare const NonZeroSafeInt: {
     /**
      * Type guard to check if a value is a NonZeroSafeInt.
+     *
      * @param value The value to check.
      * @returns `true` if the value is a non-zero safe integer, `false` otherwise.
      */
     readonly is: (a: number) => a is NonZeroSafeInt;
     /**
      * The minimum safe integer value (-(2^53 - 1)).
+     *
      * @readonly
      */
     readonly MIN_VALUE: SafeInt;
     /**
      * The maximum safe integer value (2^53 - 1).
+     *
      * @readonly
      */
     readonly MAX_VALUE: SafeUint;
     /**
      * Returns the absolute value of a non-zero safe integer.
+     *
      * @param a The NonZeroSafeInt value.
      * @returns The absolute value as a NonZeroSafeInt, clamped to safe range.
      */
     readonly abs: (x: WithSmallInt<NonZeroSafeInt, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroSafeInt>;
     /**
      * Returns the smaller of two NonZeroSafeInt values.
+     *
      * @param a The first NonZeroSafeInt.
      * @param b The second NonZeroSafeInt.
      * @returns The minimum value as a NonZeroSafeInt.
@@ -85,6 +69,7 @@ export declare const NonZeroSafeInt: {
     readonly min: (...values: readonly WithSmallInt<NonZeroSafeInt, 40>[]) => NonZeroSafeInt;
     /**
      * Returns the larger of two NonZeroSafeInt values.
+     *
      * @param a The first NonZeroSafeInt.
      * @param b The second NonZeroSafeInt.
      * @returns The maximum value as a NonZeroSafeInt.
@@ -92,48 +77,62 @@ export declare const NonZeroSafeInt: {
     readonly max: (...values: readonly WithSmallInt<NonZeroSafeInt, 40>[]) => NonZeroSafeInt;
     /**
      * Clamps a number to the non-zero safe integer range.
+     *
      * @param value The number to clamp.
-     * @returns The value clamped to [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] \ {0} as a NonZeroSafeInt.
+     * @returns The value clamped to [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] \ {0} as
+     *   a NonZeroSafeInt.
      */
     readonly clamp: (x: number) => NonZeroSafeInt;
     /**
      * Generates a random NonZeroSafeInt value within the valid range.
-     * @returns A random non-zero safe integer between MIN_SAFE_INTEGER and MAX_SAFE_INTEGER.
+     *
+     * @returns A random non-zero safe integer between MIN_SAFE_INTEGER and
+     *   MAX_SAFE_INTEGER.
      */
     readonly random: (min?: WithSmallInt<NonZeroSafeInt, 40> | undefined, max?: WithSmallInt<NonZeroSafeInt, 40> | undefined) => NonZeroSafeInt;
     /**
      * Raises a NonZeroSafeInt to the power of another NonZeroSafeInt.
+     *
      * @param a The base NonZeroSafeInt.
      * @param b The exponent NonZeroSafeInt.
-     * @returns `a ** b` clamped to non-zero safe integer range as a NonZeroSafeInt.
+     * @returns `a ** b` clamped to non-zero safe integer range as a
+     *   NonZeroSafeInt.
      */
     readonly pow: (x: WithSmallInt<NonZeroSafeInt, 40>, y: WithSmallInt<NonZeroSafeInt, 40>) => NonZeroSafeInt;
     /**
      * Adds two NonZeroSafeInt values.
+     *
      * @param a The first NonZeroSafeInt.
      * @param b The second NonZeroSafeInt.
-     * @returns `a + b` clamped to non-zero safe integer range as a NonZeroSafeInt.
+     * @returns `a + b` clamped to non-zero safe integer range as a
+     *   NonZeroSafeInt.
      */
     readonly add: (x: WithSmallInt<NonZeroSafeInt, 40>, y: WithSmallInt<NonZeroSafeInt, 40>) => NonZeroSafeInt;
     /**
      * Subtracts one NonZeroSafeInt from another.
+     *
      * @param a The minuend NonZeroSafeInt.
      * @param b The subtrahend NonZeroSafeInt.
-     * @returns `a - b` clamped to non-zero safe integer range as a NonZeroSafeInt.
+     * @returns `a - b` clamped to non-zero safe integer range as a
+     *   NonZeroSafeInt.
      */
     readonly sub: (x: WithSmallInt<NonZeroSafeInt, 40>, y: WithSmallInt<NonZeroSafeInt, 40>) => NonZeroSafeInt;
     /**
      * Multiplies two NonZeroSafeInt values.
+     *
      * @param a The first NonZeroSafeInt.
      * @param b The second NonZeroSafeInt.
-     * @returns `a * b` clamped to non-zero safe integer range as a NonZeroSafeInt.
+     * @returns `a * b` clamped to non-zero safe integer range as a
+     *   NonZeroSafeInt.
      */
     readonly mul: (x: WithSmallInt<NonZeroSafeInt, 40>, y: WithSmallInt<NonZeroSafeInt, 40>) => NonZeroSafeInt;
     /**
      * Divides one NonZeroSafeInt by another using floor division.
+     *
      * @param a The dividend NonZeroSafeInt.
      * @param b The divisor NonZeroSafeInt.
-     * @returns `⌊a / b⌋` clamped to non-zero safe integer range as a NonZeroSafeInt.
+     * @returns `⌊a / b⌋` clamped to non-zero safe integer range as a
+     *   NonZeroSafeInt.
      */
     readonly div: (x: WithSmallInt<NonZeroSafeInt, 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;

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAmCnE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,oCAAK,CAAC;AAEnC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc;IACzB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAmCnE;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,oCAAK,CAAC;AAEnC;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;CAEK,CAAC"}