ts-data-forge 3.2.0 → 3.3.1

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

@@ -8,71 +8,55 @@ const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, ran
     typeNameInMessage,
 });
 /**
- * Checks if a number is a Uint16 (16-bit unsigned integer in the range [0, 2^16)).
+ * Checks if a number is a Uint16 (16-bit unsigned integer in the range [0,
+ * 2^16)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a Uint16, `false` otherwise.
  */
 const isUint16 = is;
 /**
  * Casts a number to a Uint16 type.
+ *
  * @param value The value to cast.
  * @returns The value as a Uint16 type.
- * @throws {TypeError} If the value is not a non-negative integer less than 2^16.
- * @example
- * ```typescript
- * const x = asUint16(1000); // Uint16
- * const y = asUint16(0); // Uint16
- * // asUint16(-1); // throws TypeError
- * // asUint16(70000); // throws TypeError
- * ```
+ * @throws {TypeError} If the value is not a non-negative integer less than
+ *   2^16.
  */
 const asUint16 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 16-bit unsigned integers.
- *
- * All operations automatically clamp results to the valid Uint16 range [0, 65535].
- * This ensures that all arithmetic maintains the 16-bit unsigned integer constraint,
- * with negative results clamped to 0 and overflow results clamped to MAX_VALUE.
- *
- * @example
- * ```typescript
- * const a = asUint16(60000);
- * const b = asUint16(10000);
- *
- * // Arithmetic operations with automatic clamping
- * const sum = Uint16.add(a, b);       // Uint16 (65535 - clamped to MAX_VALUE)
- * const diff = Uint16.sub(b, a);      // Uint16 (0 - clamped to MIN_VALUE)
- * const product = Uint16.mul(a, b);   // Uint16 (65535 - clamped due to overflow)
- *
- * // Range operations
- * const clamped = Uint16.clamp(-100);     // Uint16 (0)
- * const minimum = Uint16.min(a, b);       // Uint16 (10000)
- * const maximum = Uint16.max(a, b);       // Uint16 (60000)
+ * Namespace providing type-safe arithmetic operations for 16-bit unsigned
+ * integers.
  *
- * // Utility operations
- * const random = Uint16.random();         // Uint16 (random value in [0, 65535])
- * const power = Uint16.pow(asUint16(2), asUint16(10)); // Uint16 (1024)
- * ```
+ * All operations automatically clamp results to the valid Uint16 range [0,
+ * 65535]. This ensures that all arithmetic maintains the 16-bit unsigned
+ * integer constraint, with negative results clamped to 0 and overflow results
+ * clamped to MAX_VALUE.
  */
 const Uint16 = {
     /**
      * Type guard to check if a value is a Uint16.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 16-bit unsigned integer, `false` otherwise.
+     * @returns `true` if the value is a 16-bit unsigned integer, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for a 16-bit unsigned integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a 16-bit unsigned integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the smaller of two Uint16 values.
+     *
      * @param a The first Uint16.
      * @param b The second Uint16.
      * @returns The minimum value as a Uint16.
@@ -80,6 +64,7 @@ const Uint16 = {
     min: min_,
     /**
      * Returns the larger of two Uint16 values.
+     *
      * @param a The first Uint16.
      * @param b The second Uint16.
      * @returns The maximum value as a Uint16.
@@ -87,17 +72,20 @@ const Uint16 = {
     max: max_,
     /**
      * Clamps a number to the Uint16 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [0, 65535] as a Uint16.
      */
     clamp,
     /**
      * Generates a random Uint16 value within the valid range.
+     *
      * @returns A random Uint16 between 0 and 65535.
      */
     random,
     /**
      * Raises a Uint16 to the power of another Uint16.
+     *
      * @param a The base Uint16.
      * @param b The exponent Uint16.
      * @returns `a ** b` clamped to [0, 65535] as a Uint16.
@@ -105,6 +93,7 @@ const Uint16 = {
     pow,
     /**
      * Adds two Uint16 values.
+     *
      * @param a The first Uint16.
      * @param b The second Uint16.
      * @returns `a + b` clamped to [0, 65535] as a Uint16.
@@ -112,6 +101,7 @@ const Uint16 = {
     add,
     /**
      * Subtracts one Uint16 from another.
+     *
      * @param a The minuend Uint16.
      * @param b The subtrahend Uint16.
      * @returns `a - b` clamped to [0, 65535] as a Uint16 (minimum 0).
@@ -119,6 +109,7 @@ const Uint16 = {
     sub,
     /**
      * Multiplies two Uint16 values.
+     *
      * @param a The first Uint16.
      * @param b The second Uint16.
      * @returns `a * b` clamped to [0, 65535] as a Uint16.
@@ -126,6 +117,7 @@ const Uint16 = {
     mul,
     /**
      * Divides one Uint16 by another using floor division.
+     *
      * @param a The dividend Uint16.
      * @param b The divisor Uint16.
      * @returns `⌊a / b⌋` clamped to [0, 65535] as a Uint16.

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

@@ -1 +1 @@
-{"version":3,"file":"uint16.mjs","sources":["../../../src/number/branded-types/uint16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,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,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;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,QAAQ,GAAG;AAExB;;;;;;;;;;;;AAYG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,MAAM,GAAG;AACpB;;;;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;;;;;"}
+{"version":3,"file":"uint16.mjs","sources":["../../../src/number/branded-types/uint16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,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,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;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;;;;;;AAMG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;AAOG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;AAQG;AACI,MAAM,MAAM,GAAG;AACpB;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;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/uint32.d.mts

@@ -1,21 +1,18 @@
 /**
- * Checks if a number is a Uint32 (32-bit unsigned integer in the range [0, 2^32)).
+ * Checks if a number is a Uint32 (32-bit unsigned integer in the range [0,
+ * 2^32)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a Uint32, `false` otherwise.
  */
 export declare const isUint32: (a: number) => a is Uint32;
 /**
  * Casts a number to a Uint32 type.
+ *
  * @param value The value to cast.
  * @returns The value as a Uint32 type.
- * @throws {TypeError} If the value is not a non-negative integer less than 2^32.
- * @example
- * ```typescript
- * const x = asUint32(1000000); // Uint32
- * const y = asUint32(0); // Uint32
- * // asUint32(-1); // throws TypeError
- * // asUint32(5000000000); // throws TypeError
- * ```
+ * @throws {TypeError} If the value is not a non-negative integer less than
+ *   2^32.
  */
 export declare const asUint32: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -32,139 +29,100 @@ export declare const asUint32: <N extends number>(x: N) => number & {
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
 /**
- * Utility functions for working with Uint32 (32-bit unsigned integer) branded types.
- * Provides type-safe operations that ensure results remain within the valid range [0, 2^32).
- * All arithmetic operations are clamped to maintain the Uint32 constraint.
- *
- * @example
- * ```typescript
- * // Type checking
- * Uint32.is(1000000); // true
- * Uint32.is(-1); // false
- * Uint32.is(5000000000); // false (exceeds 2^32)
- *
- * // Constants
- * console.log(Uint32.MIN_VALUE); // 0
- * console.log(Uint32.MAX_VALUE); // 4294967295 (2^32 - 1)
- *
- * // Arithmetic operations (all results clamped to [0, 2^32))
- * const a = asUint32(1000000);
- * const b = asUint32(500000);
- *
- * Uint32.add(a, b); // Uint32 (1500000)
- * Uint32.sub(a, b); // Uint32 (500000)
- * Uint32.mul(a, b); // Uint32 (clamped if overflow)
- * Uint32.div(a, b); // Uint32 (2)
- * Uint32.pow(asUint32(2), asUint32(10)); // Uint32 (1024)
- *
- * // Utility functions
- * Uint32.min(a, b); // Uint32 (500000)
- * Uint32.max(a, b); // Uint32 (1000000)
- * Uint32.clamp(asUint32(5000000000), Uint32.MIN_VALUE, Uint32.MAX_VALUE); // Uint32 (MAX_VALUE)
- * Uint32.random(); // Random Uint32
- * ```
+ * Utility functions for working with Uint32 (32-bit unsigned integer) branded
+ * types. Provides type-safe operations that ensure results remain within the
+ * valid range [0, 2^32). All arithmetic operations are clamped to maintain the
+ * Uint32 constraint.
  */
 export declare const Uint32: {
     /**
      * Type guard that checks if a value is a 32-bit unsigned integer.
+     *
      * @param value - The value to check
-     * @returns `true` if the value is within the range [0, 2^32), `false` otherwise
+     * @returns `true` if the value is within the range [0, 2^32), `false`
+     *   otherwise
      */
     readonly is: (a: number) => a is Uint32;
     /**
      * The minimum value for a Uint32.
+     *
      * @readonly
      */
     readonly MIN_VALUE: 0;
     /**
      * The maximum value for a Uint32.
+     *
      * @readonly
      */
     readonly MAX_VALUE: number;
     /**
      * Returns the minimum of multiple Uint32 values.
+     *
      * @param values - The Uint32 values to compare
      * @returns The smallest value as a Uint32
      */
     readonly min: (...values: readonly WithSmallInt<Uint32, 40>[]) => Uint32;
     /**
      * Returns the maximum of multiple Uint32 values.
+     *
      * @param values - The Uint32 values to compare
      * @returns The largest value as a Uint32
      */
     readonly max: (...values: readonly WithSmallInt<Uint32, 40>[]) => Uint32;
     /**
      * Clamps a Uint32 to be within the specified range.
+     *
      * @param value - The value to clamp
      * @param min - The minimum value
      * @param max - The maximum value
      * @returns The clamped value as a Uint32
-     * @example
-     * ```typescript
-     * Uint32.clamp(asUint32(5000000000), Uint32.MIN_VALUE, asUint32(1000)); // Uint32 (1000)
-     * ```
      */
     readonly clamp: (x: number) => Uint32;
     /**
      * Generates a random Uint32 value.
+     *
      * @returns A random Uint32 value within [0, 2^32)
      */
     readonly random: (min?: WithSmallInt<Uint32, 40> | undefined, max?: WithSmallInt<Uint32, 40> | undefined) => Uint32;
     /**
      * Raises a Uint32 to a power, with result clamped to [0, 2^32).
+     *
      * @param a - The base Uint32
      * @param b - The exponent Uint32
      * @returns `a ** b` as a Uint32, clamped to valid range
-     * @example
-     * ```typescript
-     * Uint32.pow(asUint32(2), asUint32(10)); // Uint32 (1024)
-     * ```
      */
     readonly pow: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
     /**
      * Adds two Uint32 values, with result clamped to [0, 2^32).
+     *
      * @param a - First Uint32
      * @param b - Second Uint32
      * @returns `a + b` as a Uint32, clamped to valid range
-     * @example
-     * ```typescript
-     * Uint32.add(asUint32(1000000), asUint32(500000)); // Uint32 (1500000)
-     * ```
      */
     readonly add: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
     /**
      * Subtracts two Uint32 values, with result clamped to [0, 2^32).
+     *
      * @param a - First Uint32
      * @param b - Second Uint32
      * @returns `a - b` as a Uint32, clamped to valid range (minimum 0)
-     * @example
-     * ```typescript
-     * Uint32.sub(asUint32(1000000), asUint32(500000)); // Uint32 (500000)
-     * Uint32.sub(asUint32(100), asUint32(500)); // Uint32 (0) - clamped
-     * ```
      */
     readonly sub: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
     /**
      * Multiplies two Uint32 values, with result clamped to [0, 2^32).
+     *
      * @param a - First Uint32
      * @param b - Second Uint32
      * @returns `a * b` as a Uint32, clamped to valid range
-     * @example
-     * ```typescript
-     * Uint32.mul(asUint32(1000), asUint32(500)); // Uint32 (500000)
-     * ```
      */
     readonly mul: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
     /**
-     * Divides two Uint32 values using floor division, with result clamped to [0, 2^32).
+     * Divides two Uint32 values using floor division, with result clamped to [0,
+     * 2^32).
+     *
      * @param a - The dividend Uint32
      * @param b - The divisor Uint32
      * @returns `⌊a / b⌋` as a Uint32, clamped to valid range
-     * @example
-     * ```typescript
-     * Uint32.div(asUint32(1000000), asUint32(500000)); // Uint32 (2)
-     * Uint32.div(asUint32(7), asUint32(3)); // Uint32 (2) - floor division
-     * ```
      */
     readonly div: (x: WithSmallInt<Uint32, 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 | NormalizeBrandUnion<number & {
         readonly NaNValue: false;

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

@@ -1 +1 @@
-{"version":3,"file":"uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint32.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,QAAQ,4BAAK,CAAC;AAE3B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,MAAM;IACjB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;OAGG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;OAUG;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint32.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,4BAAK,CAAC;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;OAOG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -8,159 +8,117 @@ const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, ran
     typeNameInMessage,
 });
 /**
- * Checks if a number is a Uint32 (32-bit unsigned integer in the range [0, 2^32)).
+ * Checks if a number is a Uint32 (32-bit unsigned integer in the range [0,
+ * 2^32)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a Uint32, `false` otherwise.
  */
 const isUint32 = is;
 /**
  * Casts a number to a Uint32 type.
+ *
  * @param value The value to cast.
  * @returns The value as a Uint32 type.
- * @throws {TypeError} If the value is not a non-negative integer less than 2^32.
- * @example
- * ```typescript
- * const x = asUint32(1000000); // Uint32
- * const y = asUint32(0); // Uint32
- * // asUint32(-1); // throws TypeError
- * // asUint32(5000000000); // throws TypeError
- * ```
+ * @throws {TypeError} If the value is not a non-negative integer less than
+ *   2^32.
  */
 const asUint32 = castType;
 /**
- * Utility functions for working with Uint32 (32-bit unsigned integer) branded types.
- * Provides type-safe operations that ensure results remain within the valid range [0, 2^32).
- * All arithmetic operations are clamped to maintain the Uint32 constraint.
- *
- * @example
- * ```typescript
- * // Type checking
- * Uint32.is(1000000); // true
- * Uint32.is(-1); // false
- * Uint32.is(5000000000); // false (exceeds 2^32)
- *
- * // Constants
- * console.log(Uint32.MIN_VALUE); // 0
- * console.log(Uint32.MAX_VALUE); // 4294967295 (2^32 - 1)
- *
- * // Arithmetic operations (all results clamped to [0, 2^32))
- * const a = asUint32(1000000);
- * const b = asUint32(500000);
- *
- * Uint32.add(a, b); // Uint32 (1500000)
- * Uint32.sub(a, b); // Uint32 (500000)
- * Uint32.mul(a, b); // Uint32 (clamped if overflow)
- * Uint32.div(a, b); // Uint32 (2)
- * Uint32.pow(asUint32(2), asUint32(10)); // Uint32 (1024)
- *
- * // Utility functions
- * Uint32.min(a, b); // Uint32 (500000)
- * Uint32.max(a, b); // Uint32 (1000000)
- * Uint32.clamp(asUint32(5000000000), Uint32.MIN_VALUE, Uint32.MAX_VALUE); // Uint32 (MAX_VALUE)
- * Uint32.random(); // Random Uint32
- * ```
+ * Utility functions for working with Uint32 (32-bit unsigned integer) branded
+ * types. Provides type-safe operations that ensure results remain within the
+ * valid range [0, 2^32). All arithmetic operations are clamped to maintain the
+ * Uint32 constraint.
  */
 const Uint32 = {
     /**
      * Type guard that checks if a value is a 32-bit unsigned integer.
+     *
      * @param value - The value to check
-     * @returns `true` if the value is within the range [0, 2^32), `false` otherwise
+     * @returns `true` if the value is within the range [0, 2^32), `false`
+     *   otherwise
      */
     is,
     /**
      * The minimum value for a Uint32.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a Uint32.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the minimum of multiple Uint32 values.
+     *
      * @param values - The Uint32 values to compare
      * @returns The smallest value as a Uint32
      */
     min: min_,
     /**
      * Returns the maximum of multiple Uint32 values.
+     *
      * @param values - The Uint32 values to compare
      * @returns The largest value as a Uint32
      */
     max: max_,
     /**
      * Clamps a Uint32 to be within the specified range.
+     *
      * @param value - The value to clamp
      * @param min - The minimum value
      * @param max - The maximum value
      * @returns The clamped value as a Uint32
-     * @example
-     * ```typescript
-     * Uint32.clamp(asUint32(5000000000), Uint32.MIN_VALUE, asUint32(1000)); // Uint32 (1000)
-     * ```
      */
     clamp,
     /**
      * Generates a random Uint32 value.
+     *
      * @returns A random Uint32 value within [0, 2^32)
      */
     random,
     /**
      * Raises a Uint32 to a power, with result clamped to [0, 2^32).
+     *
      * @param a - The base Uint32
      * @param b - The exponent Uint32
      * @returns `a ** b` as a Uint32, clamped to valid range
-     * @example
-     * ```typescript
-     * Uint32.pow(asUint32(2), asUint32(10)); // Uint32 (1024)
-     * ```
      */
     pow,
     /**
      * Adds two Uint32 values, with result clamped to [0, 2^32).
+     *
      * @param a - First Uint32
      * @param b - Second Uint32
      * @returns `a + b` as a Uint32, clamped to valid range
-     * @example
-     * ```typescript
-     * Uint32.add(asUint32(1000000), asUint32(500000)); // Uint32 (1500000)
-     * ```
      */
     add,
     /**
      * Subtracts two Uint32 values, with result clamped to [0, 2^32).
+     *
      * @param a - First Uint32
      * @param b - Second Uint32
      * @returns `a - b` as a Uint32, clamped to valid range (minimum 0)
-     * @example
-     * ```typescript
-     * Uint32.sub(asUint32(1000000), asUint32(500000)); // Uint32 (500000)
-     * Uint32.sub(asUint32(100), asUint32(500)); // Uint32 (0) - clamped
-     * ```
      */
     sub,
     /**
      * Multiplies two Uint32 values, with result clamped to [0, 2^32).
+     *
      * @param a - First Uint32
      * @param b - Second Uint32
      * @returns `a * b` as a Uint32, clamped to valid range
-     * @example
-     * ```typescript
-     * Uint32.mul(asUint32(1000), asUint32(500)); // Uint32 (500000)
-     * ```
      */
     mul,
     /**
-     * Divides two Uint32 values using floor division, with result clamped to [0, 2^32).
+     * Divides two Uint32 values using floor division, with result clamped to [0,
+     * 2^32).
+     *
      * @param a - The dividend Uint32
      * @param b - The divisor Uint32
      * @returns `⌊a / b⌋` as a Uint32, clamped to valid range
-     * @example
-     * ```typescript
-     * Uint32.div(asUint32(1000000), asUint32(500000)); // Uint32 (2)
-     * Uint32.div(asUint32(7), asUint32(3)); // Uint32 (2) - floor division
-     * ```
      */
     div,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"uint32.mjs","sources":["../../../src/number/branded-types/uint32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,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,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;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,QAAQ,GAAG;AAExB;;;;;;;;;;;;AAYG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACI,MAAM,MAAM,GAAG;AACpB;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;AAUG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;AAUG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;AAUG;IACH,GAAG;;;;;"}
+{"version":3,"file":"uint32.mjs","sources":["../../../src/number/branded-types/uint32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,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,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;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;;;;;;AAMG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;AAOG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;AAKG;AACI,MAAM,MAAM,GAAG;AACpB;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;AAOG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;;;;;"}