ts-data-forge 3.3.0 → 3.3.1

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

@@ -1 +1 @@
-{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,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,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,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,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;AAUG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;;;;;;;;AAcG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;AAEH;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;AAoBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;AAmBG;IACH,GAAG;;;;;"}

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

@@ -1,22 +1,18 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
- * Checks if a number is an Int16 (16-bit signed integer in the range [-2^15, 2^15)).
+ * Checks if a number is an Int16 (16-bit signed integer in the range [-2^15,
+ * 2^15)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is an Int16, `false` otherwise.
  */
 export declare const isInt16: (a: number) => a is Int16;
 /**
  * Casts a number to an Int16 type.
+ *
  * @param value The value to cast.
  * @returns The value as an Int16 type.
  * @throws {TypeError} If the value is not an integer in [-2^15, 2^15).
- * @example
- * ```typescript
- * const x = asInt16(1000); // Int16
- * const y = asInt16(-5000); // Int16
- * // asInt16(50000); // throws TypeError
- * // asInt16(1.5); // throws TypeError
- * ```
  */
 export declare const asInt16: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -35,55 +31,43 @@ export declare const asInt16: <N extends number>(x: N) => number & {
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
 /**
- * Namespace providing type-safe arithmetic operations for 16-bit signed integers.
- *
- * All operations automatically clamp results to the valid Int16 range [-32768, 32767].
- * This ensures that all arithmetic maintains the 16-bit signed integer constraint.
- *
- * @example
- * ```typescript
- * const a = asInt16(30000);
- * const b = asInt16(5000);
- *
- * // Arithmetic operations with automatic clamping
- * const sum = Int16.add(a, b);      // Int16 (32767 - clamped to MAX_VALUE)
- * const diff = Int16.sub(a, b);     // Int16 (25000)
- * const product = Int16.mul(a, b);  // Int16 (32767 - clamped due to overflow)
- *
- * // Range operations
- * const clamped = Int16.clamp(100000);    // Int16 (32767)
- * const minimum = Int16.min(a, b);        // Int16 (5000)
- * const maximum = Int16.max(a, b);        // Int16 (30000)
+ * Namespace providing type-safe arithmetic operations for 16-bit signed
+ * integers.
  *
- * // Range constants
- * const range = Int16.MAX_VALUE - Int16.MIN_VALUE + 1; // 65536
- * ```
+ * All operations automatically clamp results to the valid Int16 range [-32768,
+ * 32767]. This ensures that all arithmetic maintains the 16-bit signed integer
+ * constraint.
  */
 export declare const Int16: {
     /**
      * Type guard to check if a value is an Int16.
+     *
      * @param value The value to check.
      * @returns `true` if the value is a 16-bit signed integer, `false` otherwise.
      */
     readonly is: (a: number) => a is Int16;
     /**
      * The minimum value for a 16-bit signed integer.
+     *
      * @readonly
      */
     readonly MIN_VALUE: number;
     /**
      * The maximum value for a 16-bit signed integer.
+     *
      * @readonly
      */
     readonly MAX_VALUE: number;
     /**
      * Returns the absolute value of a 16-bit signed integer.
+     *
      * @param a The Int16 value.
      * @returns The absolute value as an Int16, clamped to valid range.
      */
     readonly abs: (x: WithSmallInt<Int16, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<Int16>;
     /**
      * Returns the smaller of two Int16 values.
+     *
      * @param a The first Int16.
      * @param b The second Int16.
      * @returns The minimum value as an Int16.
@@ -91,6 +75,7 @@ export declare const Int16: {
     readonly min: (...values: readonly WithSmallInt<Int16, 40>[]) => Int16;
     /**
      * Returns the larger of two Int16 values.
+     *
      * @param a The first Int16.
      * @param b The second Int16.
      * @returns The maximum value as an Int16.
@@ -98,17 +83,20 @@ export declare const Int16: {
     readonly max: (...values: readonly WithSmallInt<Int16, 40>[]) => Int16;
     /**
      * Clamps a number to the Int16 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [-32768, 32767] as an Int16.
      */
     readonly clamp: (x: number) => Int16;
     /**
      * Generates a random Int16 value within the valid range.
+     *
      * @returns A random Int16 between MIN_VALUE and MAX_VALUE.
      */
     readonly random: (min?: WithSmallInt<Int16, 40> | undefined, max?: WithSmallInt<Int16, 40> | undefined) => Int16;
     /**
      * Raises an Int16 to the power of another Int16.
+     *
      * @param a The base Int16.
      * @param b The exponent Int16.
      * @returns `a ** b` clamped to [-32768, 32767] as an Int16.
@@ -116,6 +104,7 @@ export declare const Int16: {
     readonly pow: (x: WithSmallInt<Int16, 40>, y: WithSmallInt<Int16, 40>) => Int16;
     /**
      * Adds two Int16 values.
+     *
      * @param a The first Int16.
      * @param b The second Int16.
      * @returns `a + b` clamped to [-32768, 32767] as an Int16.
@@ -123,6 +112,7 @@ export declare const Int16: {
     readonly add: (x: WithSmallInt<Int16, 40>, y: WithSmallInt<Int16, 40>) => Int16;
     /**
      * Subtracts one Int16 from another.
+     *
      * @param a The minuend Int16.
      * @param b The subtrahend Int16.
      * @returns `a - b` clamped to [-32768, 32767] as an Int16.
@@ -130,6 +120,7 @@ export declare const Int16: {
     readonly sub: (x: WithSmallInt<Int16, 40>, y: WithSmallInt<Int16, 40>) => Int16;
     /**
      * Multiplies two Int16 values.
+     *
      * @param a The first Int16.
      * @param b The second Int16.
      * @returns `a * b` clamped to [-32768, 32767] as an Int16.
@@ -137,6 +128,7 @@ export declare const Int16: {
     readonly mul: (x: WithSmallInt<Int16, 40>, y: WithSmallInt<Int16, 40>) => Int16;
     /**
      * Divides one Int16 by another using floor division.
+     *
      * @param a The dividend Int16.
      * @param b The divisor Int16.
      * @returns `⌊a / b⌋` clamped to [-32768, 32767] as an Int16.

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

@@ -1 +1 @@
-{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgCnE;;;;GAIG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,KAAK;IAChB;;;;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":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgCnE;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -8,75 +8,59 @@ const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, abs, pow, add, sub, mul, div
     typeNameInMessage,
 });
 /**
- * Checks if a number is an Int16 (16-bit signed integer in the range [-2^15, 2^15)).
+ * Checks if a number is an Int16 (16-bit signed integer in the range [-2^15,
+ * 2^15)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is an Int16, `false` otherwise.
  */
 const isInt16 = is;
 /**
  * Casts a number to an Int16 type.
+ *
  * @param value The value to cast.
  * @returns The value as an Int16 type.
  * @throws {TypeError} If the value is not an integer in [-2^15, 2^15).
- * @example
- * ```typescript
- * const x = asInt16(1000); // Int16
- * const y = asInt16(-5000); // Int16
- * // asInt16(50000); // throws TypeError
- * // asInt16(1.5); // throws TypeError
- * ```
  */
 const asInt16 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 16-bit signed integers.
- *
- * All operations automatically clamp results to the valid Int16 range [-32768, 32767].
- * This ensures that all arithmetic maintains the 16-bit signed integer constraint.
- *
- * @example
- * ```typescript
- * const a = asInt16(30000);
- * const b = asInt16(5000);
- *
- * // Arithmetic operations with automatic clamping
- * const sum = Int16.add(a, b);      // Int16 (32767 - clamped to MAX_VALUE)
- * const diff = Int16.sub(a, b);     // Int16 (25000)
- * const product = Int16.mul(a, b);  // Int16 (32767 - clamped due to overflow)
- *
- * // Range operations
- * const clamped = Int16.clamp(100000);    // Int16 (32767)
- * const minimum = Int16.min(a, b);        // Int16 (5000)
- * const maximum = Int16.max(a, b);        // Int16 (30000)
+ * Namespace providing type-safe arithmetic operations for 16-bit signed
+ * integers.
  *
- * // Range constants
- * const range = Int16.MAX_VALUE - Int16.MIN_VALUE + 1; // 65536
- * ```
+ * All operations automatically clamp results to the valid Int16 range [-32768,
+ * 32767]. This ensures that all arithmetic maintains the 16-bit signed integer
+ * constraint.
  */
 const Int16 = {
     /**
      * Type guard to check if a value is an Int16.
+     *
      * @param value The value to check.
      * @returns `true` if the value is a 16-bit signed integer, `false` otherwise.
      */
     is,
     /**
      * The minimum value for a 16-bit signed integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a 16-bit signed integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the absolute value of a 16-bit signed integer.
+     *
      * @param a The Int16 value.
      * @returns The absolute value as an Int16, clamped to valid range.
      */
     abs,
     /**
      * Returns the smaller of two Int16 values.
+     *
      * @param a The first Int16.
      * @param b The second Int16.
      * @returns The minimum value as an Int16.
@@ -84,6 +68,7 @@ const Int16 = {
     min: min_,
     /**
      * Returns the larger of two Int16 values.
+     *
      * @param a The first Int16.
      * @param b The second Int16.
      * @returns The maximum value as an Int16.
@@ -91,17 +76,20 @@ const Int16 = {
     max: max_,
     /**
      * Clamps a number to the Int16 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [-32768, 32767] as an Int16.
      */
     clamp,
     /**
      * Generates a random Int16 value within the valid range.
+     *
      * @returns A random Int16 between MIN_VALUE and MAX_VALUE.
      */
     random,
     /**
      * Raises an Int16 to the power of another Int16.
+     *
      * @param a The base Int16.
      * @param b The exponent Int16.
      * @returns `a ** b` clamped to [-32768, 32767] as an Int16.
@@ -109,6 +97,7 @@ const Int16 = {
     pow,
     /**
      * Adds two Int16 values.
+     *
      * @param a The first Int16.
      * @param b The second Int16.
      * @returns `a + b` clamped to [-32768, 32767] as an Int16.
@@ -116,6 +105,7 @@ const Int16 = {
     add,
     /**
      * Subtracts one Int16 from another.
+     *
      * @param a The minuend Int16.
      * @param b The subtrahend Int16.
      * @returns `a - b` clamped to [-32768, 32767] as an Int16.
@@ -123,6 +113,7 @@ const Int16 = {
     sub,
     /**
      * Multiplies two Int16 values.
+     *
      * @param a The first Int16.
      * @param b The second Int16.
      * @returns `a * b` clamped to [-32768, 32767] as an Int16.
@@ -130,6 +121,7 @@ const Int16 = {
     mul,
     /**
      * Divides one Int16 by another using floor division.
+     *
      * @param a The dividend Int16.
      * @param b The divisor Int16.
      * @returns `⌊a / b⌋` clamped to [-32768, 32767] as an Int16.

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

@@ -1 +1 @@
-{"version":3,"file":"int16.mjs","sources":["../../../src/number/branded-types/int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;AAYG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,KAAK,GAAG;AACnB;;;;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":"int16.mjs","sources":["../../../src/number/branded-types/int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;AAOG;AACI,MAAM,KAAK,GAAG;AACnB;;;;;AAKG;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;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;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/int32.d.mts

@@ -1,22 +1,18 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
- * Checks if a number is an Int32 (32-bit signed integer in the range [-2^31, 2^31)).
+ * Checks if a number is an Int32 (32-bit signed integer in the range [-2^31,
+ * 2^31)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is an Int32, `false` otherwise.
  */
 export declare const isInt32: (a: number) => a is Int32;
 /**
  * Casts a number to an Int32 type.
+ *
  * @param value The value to cast.
  * @returns The value as an Int32 type.
  * @throws {TypeError} If the value is not an integer in [-2^31, 2^31).
- * @example
- * ```typescript
- * const x = asInt32(100000); // Int32
- * const y = asInt32(-500000); // Int32
- * // asInt32(3000000000); // throws TypeError
- * // asInt32(1.5); // throws TypeError
- * ```
  */
 export declare const asInt32: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -31,56 +27,43 @@ export declare const asInt32: <N extends number>(x: N) => number & {
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
 /**
- * Namespace providing type-safe arithmetic operations for 32-bit signed integers.
- *
- * All operations automatically clamp results to the valid Int32 range [-2147483648, 2147483647].
- * This ensures that all arithmetic maintains the 32-bit signed integer constraint, preventing overflow.
- *
- * @example
- * ```typescript
- * const a = asInt32(2000000000);
- * const b = asInt32(500000000);
- *
- * // Arithmetic operations with automatic clamping
- * const sum = Int32.add(a, b);      // Int32 (2147483647 - clamped to MAX_VALUE)
- * const diff = Int32.sub(a, b);     // Int32 (1500000000)
- * const product = Int32.mul(a, b);  // Int32 (2147483647 - clamped due to overflow)
- *
- * // Range operations
- * const clamped = Int32.clamp(5000000000);    // Int32 (2147483647)
- * const minimum = Int32.min(a, b);            // Int32 (500000000)
- * const maximum = Int32.max(a, b);            // Int32 (2000000000)
+ * Namespace providing type-safe arithmetic operations for 32-bit signed
+ * integers.
  *
- * // Utility operations
- * const absolute = Int32.abs(asInt32(-1000)); // Int32 (1000)
- * const random = Int32.random();              // Int32 (random value in valid range)
- * ```
+ * All operations automatically clamp results to the valid Int32 range
+ * [-2147483648, 2147483647]. This ensures that all arithmetic maintains the
+ * 32-bit signed integer constraint, preventing overflow.
  */
 export declare const Int32: {
     /**
      * Type guard to check if a value is an Int32.
+     *
      * @param value The value to check.
      * @returns `true` if the value is a 32-bit signed integer, `false` otherwise.
      */
     readonly is: (a: number) => a is Int32;
     /**
      * The minimum value for a 32-bit signed integer.
+     *
      * @readonly
      */
     readonly MIN_VALUE: number;
     /**
      * The maximum value for a 32-bit signed integer.
+     *
      * @readonly
      */
     readonly MAX_VALUE: number;
     /**
      * Returns the absolute value of a 32-bit signed integer.
+     *
      * @param a The Int32 value.
      * @returns The absolute value as an Int32, clamped to valid range.
      */
     readonly abs: (x: WithSmallInt<Int32, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<Int32>;
     /**
      * Returns the smaller of two Int32 values.
+     *
      * @param a The first Int32.
      * @param b The second Int32.
      * @returns The minimum value as an Int32.
@@ -88,6 +71,7 @@ export declare const Int32: {
     readonly min: (...values: readonly WithSmallInt<Int32, 40>[]) => Int32;
     /**
      * Returns the larger of two Int32 values.
+     *
      * @param a The first Int32.
      * @param b The second Int32.
      * @returns The maximum value as an Int32.
@@ -95,17 +79,20 @@ export declare const Int32: {
     readonly max: (...values: readonly WithSmallInt<Int32, 40>[]) => Int32;
     /**
      * Clamps a number to the Int32 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [-2147483648, 2147483647] as an Int32.
      */
     readonly clamp: (x: number) => Int32;
     /**
      * Generates a random Int32 value within the valid range.
+     *
      * @returns A random Int32 between MIN_VALUE and MAX_VALUE.
      */
     readonly random: (min?: WithSmallInt<Int32, 40> | undefined, max?: WithSmallInt<Int32, 40> | undefined) => Int32;
     /**
      * Raises an Int32 to the power of another Int32.
+     *
      * @param a The base Int32.
      * @param b The exponent Int32.
      * @returns `a ** b` clamped to [-2147483648, 2147483647] as an Int32.
@@ -113,6 +100,7 @@ export declare const Int32: {
     readonly pow: (x: WithSmallInt<Int32, 40>, y: WithSmallInt<Int32, 40>) => Int32;
     /**
      * Adds two Int32 values.
+     *
      * @param a The first Int32.
      * @param b The second Int32.
      * @returns `a + b` clamped to [-2147483648, 2147483647] as an Int32.
@@ -120,6 +108,7 @@ export declare const Int32: {
     readonly add: (x: WithSmallInt<Int32, 40>, y: WithSmallInt<Int32, 40>) => Int32;
     /**
      * Subtracts one Int32 from another.
+     *
      * @param a The minuend Int32.
      * @param b The subtrahend Int32.
      * @returns `a - b` clamped to [-2147483648, 2147483647] as an Int32.
@@ -127,6 +116,7 @@ export declare const Int32: {
     readonly sub: (x: WithSmallInt<Int32, 40>, y: WithSmallInt<Int32, 40>) => Int32;
     /**
      * Multiplies two Int32 values.
+     *
      * @param a The first Int32.
      * @param b The second Int32.
      * @returns `a * b` clamped to [-2147483648, 2147483647] as an Int32.
@@ -134,6 +124,7 @@ export declare const Int32: {
     readonly mul: (x: WithSmallInt<Int32, 40>, y: WithSmallInt<Int32, 40>) => Int32;
     /**
      * Divides one Int32 by another using floor division.
+     *
      * @param a The dividend Int32.
      * @param b The divisor Int32.
      * @returns `⌊a / b⌋` clamped to [-2147483648, 2147483647] as an Int32.

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

@@ -1 +1 @@
-{"version":3,"file":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgCnE;;;;GAIG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,KAAK;IAChB;;;;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":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgCnE;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -8,76 +8,59 @@ const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, abs, pow, add, sub, mul, div
     typeNameInMessage,
 });
 /**
- * Checks if a number is an Int32 (32-bit signed integer in the range [-2^31, 2^31)).
+ * Checks if a number is an Int32 (32-bit signed integer in the range [-2^31,
+ * 2^31)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is an Int32, `false` otherwise.
  */
 const isInt32 = is;
 /**
  * Casts a number to an Int32 type.
+ *
  * @param value The value to cast.
  * @returns The value as an Int32 type.
  * @throws {TypeError} If the value is not an integer in [-2^31, 2^31).
- * @example
- * ```typescript
- * const x = asInt32(100000); // Int32
- * const y = asInt32(-500000); // Int32
- * // asInt32(3000000000); // throws TypeError
- * // asInt32(1.5); // throws TypeError
- * ```
  */
 const asInt32 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 32-bit signed integers.
- *
- * All operations automatically clamp results to the valid Int32 range [-2147483648, 2147483647].
- * This ensures that all arithmetic maintains the 32-bit signed integer constraint, preventing overflow.
- *
- * @example
- * ```typescript
- * const a = asInt32(2000000000);
- * const b = asInt32(500000000);
- *
- * // Arithmetic operations with automatic clamping
- * const sum = Int32.add(a, b);      // Int32 (2147483647 - clamped to MAX_VALUE)
- * const diff = Int32.sub(a, b);     // Int32 (1500000000)
- * const product = Int32.mul(a, b);  // Int32 (2147483647 - clamped due to overflow)
- *
- * // Range operations
- * const clamped = Int32.clamp(5000000000);    // Int32 (2147483647)
- * const minimum = Int32.min(a, b);            // Int32 (500000000)
- * const maximum = Int32.max(a, b);            // Int32 (2000000000)
+ * Namespace providing type-safe arithmetic operations for 32-bit signed
+ * integers.
  *
- * // Utility operations
- * const absolute = Int32.abs(asInt32(-1000)); // Int32 (1000)
- * const random = Int32.random();              // Int32 (random value in valid range)
- * ```
+ * All operations automatically clamp results to the valid Int32 range
+ * [-2147483648, 2147483647]. This ensures that all arithmetic maintains the
+ * 32-bit signed integer constraint, preventing overflow.
  */
 const Int32 = {
     /**
      * Type guard to check if a value is an Int32.
+     *
      * @param value The value to check.
      * @returns `true` if the value is a 32-bit signed integer, `false` otherwise.
      */
     is,
     /**
      * The minimum value for a 32-bit signed integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a 32-bit signed integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the absolute value of a 32-bit signed integer.
+     *
      * @param a The Int32 value.
      * @returns The absolute value as an Int32, clamped to valid range.
      */
     abs,
     /**
      * Returns the smaller of two Int32 values.
+     *
      * @param a The first Int32.
      * @param b The second Int32.
      * @returns The minimum value as an Int32.
@@ -85,6 +68,7 @@ const Int32 = {
     min: min_,
     /**
      * Returns the larger of two Int32 values.
+     *
      * @param a The first Int32.
      * @param b The second Int32.
      * @returns The maximum value as an Int32.
@@ -92,17 +76,20 @@ const Int32 = {
     max: max_,
     /**
      * Clamps a number to the Int32 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [-2147483648, 2147483647] as an Int32.
      */
     clamp,
     /**
      * Generates a random Int32 value within the valid range.
+     *
      * @returns A random Int32 between MIN_VALUE and MAX_VALUE.
      */
     random,
     /**
      * Raises an Int32 to the power of another Int32.
+     *
      * @param a The base Int32.
      * @param b The exponent Int32.
      * @returns `a ** b` clamped to [-2147483648, 2147483647] as an Int32.
@@ -110,6 +97,7 @@ const Int32 = {
     pow,
     /**
      * Adds two Int32 values.
+     *
      * @param a The first Int32.
      * @param b The second Int32.
      * @returns `a + b` clamped to [-2147483648, 2147483647] as an Int32.
@@ -117,6 +105,7 @@ const Int32 = {
     add,
     /**
      * Subtracts one Int32 from another.
+     *
      * @param a The minuend Int32.
      * @param b The subtrahend Int32.
      * @returns `a - b` clamped to [-2147483648, 2147483647] as an Int32.
@@ -124,6 +113,7 @@ const Int32 = {
     sub,
     /**
      * Multiplies two Int32 values.
+     *
      * @param a The first Int32.
      * @param b The second Int32.
      * @returns `a * b` clamped to [-2147483648, 2147483647] as an Int32.
@@ -131,6 +121,7 @@ const Int32 = {
     mul,
     /**
      * Divides one Int32 by another using floor division.
+     *
      * @param a The dividend Int32.
      * @param b The divisor Int32.
      * @returns `⌊a / b⌋` clamped to [-2147483648, 2147483647] as an Int32.

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

@@ -1 +1 @@
-{"version":3,"file":"int32.mjs","sources":["../../../src/number/branded-types/int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,WAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;AAYG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,KAAK,GAAG;AACnB;;;;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":"int32.mjs","sources":["../../../src/number/branded-types/int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,WAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;AAMG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;AAOG;AACI,MAAM,KAAK,GAAG;AACnB;;;;;AAKG;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;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}