ts-data-forge 3.2.0 → 3.3.1

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

@@ -2,22 +2,17 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 type ElementType = NonNegativeFiniteNumber;
 /**
  * Checks if a number is a NonNegativeFiniteNumber (a finite number >= 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonNegativeFiniteNumber, `false` otherwise.
  */
 export declare const isNonNegativeFiniteNumber: (a: number) => a is NonNegativeFiniteNumber;
 /**
  * Casts a number to a NonNegativeFiniteNumber type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonNegativeFiniteNumber type.
  * @throws {TypeError} If the value is not a non-negative finite number.
- * @example
- * ```typescript
- * const x = asNonNegativeFiniteNumber(5.5); // NonNegativeFiniteNumber
- * const y = asNonNegativeFiniteNumber(0); // NonNegativeFiniteNumber
- * // asNonNegativeFiniteNumber(-1); // throws TypeError
- * // asNonNegativeFiniteNumber(Infinity); // throws TypeError
- * ```
  */
 export declare const asNonNegativeFiniteNumber: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -31,48 +26,32 @@ export declare const asNonNegativeFiniteNumber: <N extends number>(x: N) => numb
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
 /**
- * Namespace providing type-safe arithmetic operations for non-negative finite numbers.
- *
- * All operations maintain the non-negative constraint by clamping negative results to 0,
- * while ensuring results remain finite (excluding NaN and Infinity). This type is useful
- * for representing measurements, distances, weights, and other inherently non-negative values.
- *
- * @example
- * ```typescript
- * const distance = asNonNegativeFiniteNumber(5.5);
- * const speed = asNonNegativeFiniteNumber(2.2);
- *
- * // Arithmetic operations with non-negative clamping
- * const total = NonNegativeFiniteNumber.add(distance, speed);        // NonNegativeFiniteNumber (7.7)
- * const diff = NonNegativeFiniteNumber.sub(speed, distance);        // NonNegativeFiniteNumber (0 - clamped)
- * const area = NonNegativeFiniteNumber.mul(distance, speed);        // NonNegativeFiniteNumber (12.1)
- * const ratio = NonNegativeFiniteNumber.div(distance, speed);       // NonNegativeFiniteNumber (2.5)
- *
- * // Range operations
- * const clamped = NonNegativeFiniteNumber.clamp(-10.5);             // NonNegativeFiniteNumber (0)
- * const minimum = NonNegativeFiniteNumber.min(distance, speed);     // NonNegativeFiniteNumber (2.2)
- * const maximum = NonNegativeFiniteNumber.max(distance, speed);     // NonNegativeFiniteNumber (5.5)
+ * Namespace providing type-safe arithmetic operations for non-negative finite
+ * numbers.
  *
- * // Rounding operations (return Uint)
- * const pixels = NonNegativeFiniteNumber.round(distance);           // Uint (6)
- * const floorValue = NonNegativeFiniteNumber.floor(distance);       // Uint (5)
- * const ceilValue = NonNegativeFiniteNumber.ceil(distance);         // Uint (6)
- * ```
+ * All operations maintain the non-negative constraint by clamping negative
+ * results to 0, while ensuring results remain finite (excluding NaN and
+ * Infinity). This type is useful for representing measurements, distances,
+ * weights, and other inherently non-negative values.
  */
 export declare const NonNegativeFiniteNumber: {
     /**
      * Type guard to check if a value is a NonNegativeFiniteNumber.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a non-negative finite number, `false` otherwise.
+     * @returns `true` if the value is a non-negative finite number, `false`
+     *   otherwise.
      */
     readonly is: (a: number) => a is NonNegativeFiniteNumber;
     /**
      * The minimum value for a non-negative finite number.
+     *
      * @readonly
      */
     readonly MIN_VALUE: 0;
     /**
      * Returns the smaller of two NonNegativeFiniteNumber values.
+     *
      * @param a The first NonNegativeFiniteNumber.
      * @param b The second NonNegativeFiniteNumber.
      * @returns The minimum value as a NonNegativeFiniteNumber.
@@ -80,6 +59,7 @@ export declare const NonNegativeFiniteNumber: {
     readonly min: (...values: readonly NonNegativeFiniteNumber[]) => NonNegativeFiniteNumber;
     /**
      * Returns the larger of two NonNegativeFiniteNumber values.
+     *
      * @param a The first NonNegativeFiniteNumber.
      * @param b The second NonNegativeFiniteNumber.
      * @returns The maximum value as a NonNegativeFiniteNumber.
@@ -87,35 +67,42 @@ export declare const NonNegativeFiniteNumber: {
     readonly max: (...values: readonly NonNegativeFiniteNumber[]) => NonNegativeFiniteNumber;
     /**
      * Clamps a number to the non-negative finite range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [0, +∞) as a NonNegativeFiniteNumber.
      */
     readonly clamp: (x: number) => NonNegativeFiniteNumber;
     /**
      * Rounds down a NonNegativeFiniteNumber to the nearest integer.
+     *
      * @param x The NonNegativeFiniteNumber to round down.
      * @returns The floor value as a Uint.
      */
     readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds up a NonNegativeFiniteNumber to the nearest integer.
+     *
      * @param x The NonNegativeFiniteNumber to round up.
      * @returns The ceiling value as a Uint.
      */
     readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds a NonNegativeFiniteNumber to the nearest integer.
+     *
      * @param x The NonNegativeFiniteNumber to round.
      * @returns The rounded value as a Uint.
      */
     readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Generates a random NonNegativeFiniteNumber value.
+     *
      * @returns A random non-negative finite number.
      */
     readonly random: (min?: NonNegativeFiniteNumber | undefined, max?: NonNegativeFiniteNumber | undefined) => NonNegativeFiniteNumber;
     /**
-     * Raises a NonNegativeFiniteNumber to the power of another NonNegativeFiniteNumber.
+     * Raises a NonNegativeFiniteNumber to the power of another
+     * NonNegativeFiniteNumber.
+     *
      * @param a The base NonNegativeFiniteNumber.
      * @param b The exponent NonNegativeFiniteNumber.
      * @returns `a ** b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
@@ -123,6 +110,7 @@ export declare const NonNegativeFiniteNumber: {
     readonly pow: (x: NonNegativeFiniteNumber, y: NonNegativeFiniteNumber) => NonNegativeFiniteNumber;
     /**
      * Adds two NonNegativeFiniteNumber values.
+     *
      * @param a The first NonNegativeFiniteNumber.
      * @param b The second NonNegativeFiniteNumber.
      * @returns `a + b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
@@ -130,13 +118,16 @@ export declare const NonNegativeFiniteNumber: {
     readonly add: (x: NonNegativeFiniteNumber, y: NonNegativeFiniteNumber) => NonNegativeFiniteNumber;
     /**
      * Subtracts one NonNegativeFiniteNumber from another.
+     *
      * @param a The minuend NonNegativeFiniteNumber.
      * @param b The subtrahend NonNegativeFiniteNumber.
-     * @returns `a - b` clamped to [0, +∞) as a NonNegativeFiniteNumber (minimum 0).
+     * @returns `a - b` clamped to [0, +∞) as a NonNegativeFiniteNumber (minimum
+     *   0).
      */
     readonly sub: (x: NonNegativeFiniteNumber, y: NonNegativeFiniteNumber) => NonNegativeFiniteNumber;
     /**
      * Multiplies two NonNegativeFiniteNumber values.
+     *
      * @param a The first NonNegativeFiniteNumber.
      * @param b The second NonNegativeFiniteNumber.
      * @returns `a * b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
@@ -144,6 +135,7 @@ export declare const NonNegativeFiniteNumber: {
     readonly mul: (x: NonNegativeFiniteNumber, y: NonNegativeFiniteNumber) => NonNegativeFiniteNumber;
     /**
      * Divides one NonNegativeFiniteNumber by another.
+     *
      * @param a The dividend NonNegativeFiniteNumber.
      * @param b The divisor NonNegativeFiniteNumber.
      * @returns `a / b` clamped to [0, +∞) as a NonNegativeFiniteNumber.

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAiD3C;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,6CAAK,CAAC;AAE5C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;wBAjHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAmH3D;;;;OAIG;uBAlHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAoH3D;;;;OAIG;wBAnHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAqH3D;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAiD3C;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,6CAAK,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;wBA/FA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAiG3D;;;;;OAKG;uBAjGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAmG3D;;;;;OAKG;wBAnGA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAqG3D;;;;OAIG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -7,77 +7,56 @@ const { MIN_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, ca
     typeNameInMessage,
 });
 const floor = (x) => 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
 Math.floor(x);
 const ceil = (x) => 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
 Math.ceil(x);
 const round = (x) => 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
 Math.round(x);
 /**
  * Checks if a number is a NonNegativeFiniteNumber (a finite number >= 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonNegativeFiniteNumber, `false` otherwise.
  */
 const isNonNegativeFiniteNumber = is;
 /**
  * Casts a number to a NonNegativeFiniteNumber type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonNegativeFiniteNumber type.
  * @throws {TypeError} If the value is not a non-negative finite number.
- * @example
- * ```typescript
- * const x = asNonNegativeFiniteNumber(5.5); // NonNegativeFiniteNumber
- * const y = asNonNegativeFiniteNumber(0); // NonNegativeFiniteNumber
- * // asNonNegativeFiniteNumber(-1); // throws TypeError
- * // asNonNegativeFiniteNumber(Infinity); // throws TypeError
- * ```
  */
 const asNonNegativeFiniteNumber = castType;
 /**
- * Namespace providing type-safe arithmetic operations for non-negative finite numbers.
- *
- * All operations maintain the non-negative constraint by clamping negative results to 0,
- * while ensuring results remain finite (excluding NaN and Infinity). This type is useful
- * for representing measurements, distances, weights, and other inherently non-negative values.
- *
- * @example
- * ```typescript
- * const distance = asNonNegativeFiniteNumber(5.5);
- * const speed = asNonNegativeFiniteNumber(2.2);
- *
- * // Arithmetic operations with non-negative clamping
- * const total = NonNegativeFiniteNumber.add(distance, speed);        // NonNegativeFiniteNumber (7.7)
- * const diff = NonNegativeFiniteNumber.sub(speed, distance);        // NonNegativeFiniteNumber (0 - clamped)
- * const area = NonNegativeFiniteNumber.mul(distance, speed);        // NonNegativeFiniteNumber (12.1)
- * const ratio = NonNegativeFiniteNumber.div(distance, speed);       // NonNegativeFiniteNumber (2.5)
- *
- * // Range operations
- * const clamped = NonNegativeFiniteNumber.clamp(-10.5);             // NonNegativeFiniteNumber (0)
- * const minimum = NonNegativeFiniteNumber.min(distance, speed);     // NonNegativeFiniteNumber (2.2)
- * const maximum = NonNegativeFiniteNumber.max(distance, speed);     // NonNegativeFiniteNumber (5.5)
+ * Namespace providing type-safe arithmetic operations for non-negative finite
+ * numbers.
  *
- * // Rounding operations (return Uint)
- * const pixels = NonNegativeFiniteNumber.round(distance);           // Uint (6)
- * const floorValue = NonNegativeFiniteNumber.floor(distance);       // Uint (5)
- * const ceilValue = NonNegativeFiniteNumber.ceil(distance);         // Uint (6)
- * ```
+ * All operations maintain the non-negative constraint by clamping negative
+ * results to 0, while ensuring results remain finite (excluding NaN and
+ * Infinity). This type is useful for representing measurements, distances,
+ * weights, and other inherently non-negative values.
  */
 const NonNegativeFiniteNumber = {
     /**
      * Type guard to check if a value is a NonNegativeFiniteNumber.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a non-negative finite number, `false` otherwise.
+     * @returns `true` if the value is a non-negative finite number, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for a non-negative finite number.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * Returns the smaller of two NonNegativeFiniteNumber values.
+     *
      * @param a The first NonNegativeFiniteNumber.
      * @param b The second NonNegativeFiniteNumber.
      * @returns The minimum value as a NonNegativeFiniteNumber.
@@ -85,6 +64,7 @@ const NonNegativeFiniteNumber = {
     min: min_,
     /**
      * Returns the larger of two NonNegativeFiniteNumber values.
+     *
      * @param a The first NonNegativeFiniteNumber.
      * @param b The second NonNegativeFiniteNumber.
      * @returns The maximum value as a NonNegativeFiniteNumber.
@@ -92,35 +72,42 @@ const NonNegativeFiniteNumber = {
     max: max_,
     /**
      * Clamps a number to the non-negative finite range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [0, +∞) as a NonNegativeFiniteNumber.
      */
     clamp,
     /**
      * Rounds down a NonNegativeFiniteNumber to the nearest integer.
+     *
      * @param x The NonNegativeFiniteNumber to round down.
      * @returns The floor value as a Uint.
      */
     floor,
     /**
      * Rounds up a NonNegativeFiniteNumber to the nearest integer.
+     *
      * @param x The NonNegativeFiniteNumber to round up.
      * @returns The ceiling value as a Uint.
      */
     ceil,
     /**
      * Rounds a NonNegativeFiniteNumber to the nearest integer.
+     *
      * @param x The NonNegativeFiniteNumber to round.
      * @returns The rounded value as a Uint.
      */
     round,
     /**
      * Generates a random NonNegativeFiniteNumber value.
+     *
      * @returns A random non-negative finite number.
      */
     random,
     /**
-     * Raises a NonNegativeFiniteNumber to the power of another NonNegativeFiniteNumber.
+     * Raises a NonNegativeFiniteNumber to the power of another
+     * NonNegativeFiniteNumber.
+     *
      * @param a The base NonNegativeFiniteNumber.
      * @param b The exponent NonNegativeFiniteNumber.
      * @returns `a ** b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
@@ -128,6 +115,7 @@ const NonNegativeFiniteNumber = {
     pow,
     /**
      * Adds two NonNegativeFiniteNumber values.
+     *
      * @param a The first NonNegativeFiniteNumber.
      * @param b The second NonNegativeFiniteNumber.
      * @returns `a + b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
@@ -135,13 +123,16 @@ const NonNegativeFiniteNumber = {
     add,
     /**
      * Subtracts one NonNegativeFiniteNumber from another.
+     *
      * @param a The minuend NonNegativeFiniteNumber.
      * @param b The subtrahend NonNegativeFiniteNumber.
-     * @returns `a - b` clamped to [0, +∞) as a NonNegativeFiniteNumber (minimum 0).
+     * @returns `a - b` clamped to [0, +∞) as a NonNegativeFiniteNumber (minimum
+     *   0).
      */
     sub,
     /**
      * Multiplies two NonNegativeFiniteNumber values.
+     *
      * @param a The first NonNegativeFiniteNumber.
      * @param b The second NonNegativeFiniteNumber.
      * @returns `a * b` clamped to [0, +∞) as a NonNegativeFiniteNumber.
@@ -149,6 +140,7 @@ const NonNegativeFiniteNumber = {
     mul,
     /**
      * Divides one NonNegativeFiniteNumber by another.
+     *
      * @param a The dividend NonNegativeFiniteNumber.
      * @param b The divisor NonNegativeFiniteNumber.
      * @returns `a / b` clamped to [0, +∞) as a NonNegativeFiniteNumber.

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-finite-number.mjs","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,8BAA8B;AAExD,MAAM,EACJ,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,iBAAiB,CAI3D;AACA,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAM7E;;;;AAIG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;;;;;AAYG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,uBAAuB,GAAG;AACrC;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;;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;;;;;"}
+{"version":3,"file":"non-negative-finite-number.mjs","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,8BAA8B;AAExD,MAAM,EACJ,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,iBAAiB,CAI3D;AACA,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAM7E;;;;;AAKG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;AAMG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;AAQG;AACI,MAAM,uBAAuB,GAAG;AACrC;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,21 +1,17 @@
 /**
- * Checks if a number is a NonNegativeInt16 (16-bit non-negative signed integer in the range [0, 2^15)).
+ * Checks if a number is a NonNegativeInt16 (16-bit non-negative signed integer
+ * in the range [0, 2^15)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonNegativeInt16, `false` otherwise.
  */
 export declare const isNonNegativeInt16: (a: number) => a is NonNegativeInt16;
 /**
  * Casts a number to a NonNegativeInt16 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonNegativeInt16 type.
  * @throws {TypeError} If the value is not a non-negative integer in [0, 2^15).
- * @example
- * ```typescript
- * const x = asNonNegativeInt16(1000); // NonNegativeInt16
- * const y = asNonNegativeInt16(0); // NonNegativeInt16
- * // asNonNegativeInt16(-1); // throws TypeError
- * // asNonNegativeInt16(32768); // throws TypeError
- * ```
  */
 export declare const asNonNegativeInt16: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -35,52 +31,38 @@ export declare const asNonNegativeInt16: <N extends number>(x: N) => number & {
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
 /**
- * Namespace providing type-safe arithmetic operations for 16-bit non-negative integers.
- *
- * All operations automatically clamp results to the valid NonNegativeInt16 range [0, 32767].
- * This ensures that all arithmetic maintains the 16-bit non-negative integer constraint,
- * with negative results clamped to 0 and overflow results clamped to MAX_VALUE.
- *
- * @example
- * ```typescript
- * const a = asNonNegativeInt16(30000);
- * const b = asNonNegativeInt16(5000);
- *
- * // Arithmetic operations with automatic clamping
- * const sum = NonNegativeInt16.add(a, b);       // NonNegativeInt16 (32767 - clamped to MAX_VALUE)
- * const diff = NonNegativeInt16.sub(a, b);      // NonNegativeInt16 (25000)
- * const reverseDiff = NonNegativeInt16.sub(b, a); // NonNegativeInt16 (0 - clamped to MIN_VALUE)
- * const product = NonNegativeInt16.mul(a, b);   // NonNegativeInt16 (32767 - clamped due to overflow)
- *
- * // Range operations
- * const clamped = NonNegativeInt16.clamp(-100);     // NonNegativeInt16 (0)
- * const minimum = NonNegativeInt16.min(a, b);       // NonNegativeInt16 (5000)
- * const maximum = NonNegativeInt16.max(a, b);       // NonNegativeInt16 (30000)
+ * Namespace providing type-safe arithmetic operations for 16-bit non-negative
+ * integers.
  *
- * // Utility operations
- * const random = NonNegativeInt16.random();         // NonNegativeInt16 (random value in [0, 32767])
- * const power = NonNegativeInt16.pow(asNonNegativeInt16(2), asNonNegativeInt16(10)); // NonNegativeInt16 (1024)
- * ```
+ * All operations automatically clamp results to the valid NonNegativeInt16
+ * range [0, 32767]. This ensures that all arithmetic maintains the 16-bit
+ * non-negative integer constraint, with negative results clamped to 0 and
+ * overflow results clamped to MAX_VALUE.
  */
 export declare const NonNegativeInt16: {
     /**
      * Type guard to check if a value is a NonNegativeInt16.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 16-bit non-negative integer, `false` otherwise.
+     * @returns `true` if the value is a 16-bit non-negative integer, `false`
+     *   otherwise.
      */
     readonly is: (a: number) => a is NonNegativeInt16;
     /**
      * The minimum value for a 16-bit non-negative integer.
+     *
      * @readonly
      */
     readonly MIN_VALUE: 0;
     /**
      * The maximum value for a 16-bit non-negative integer.
+     *
      * @readonly
      */
     readonly MAX_VALUE: number;
     /**
      * Returns the smaller of two NonNegativeInt16 values.
+     *
      * @param a The first NonNegativeInt16.
      * @param b The second NonNegativeInt16.
      * @returns The minimum value as a NonNegativeInt16.
@@ -88,6 +70,7 @@ export declare const NonNegativeInt16: {
     readonly min: (...values: readonly WithSmallInt<NonNegativeInt16, 40>[]) => NonNegativeInt16;
     /**
      * Returns the larger of two NonNegativeInt16 values.
+     *
      * @param a The first NonNegativeInt16.
      * @param b The second NonNegativeInt16.
      * @returns The maximum value as a NonNegativeInt16.
@@ -95,17 +78,20 @@ export declare const NonNegativeInt16: {
     readonly max: (...values: readonly WithSmallInt<NonNegativeInt16, 40>[]) => NonNegativeInt16;
     /**
      * Clamps a number to the NonNegativeInt16 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [0, 32767] as a NonNegativeInt16.
      */
     readonly clamp: (x: number) => NonNegativeInt16;
     /**
      * Generates a random NonNegativeInt16 value within the valid range.
+     *
      * @returns A random NonNegativeInt16 between 0 and 32767.
      */
     readonly random: (min?: WithSmallInt<NonNegativeInt16, 40> | undefined, max?: WithSmallInt<NonNegativeInt16, 40> | undefined) => NonNegativeInt16;
     /**
      * Raises a NonNegativeInt16 to the power of another NonNegativeInt16.
+     *
      * @param a The base NonNegativeInt16.
      * @param b The exponent NonNegativeInt16.
      * @returns `a ** b` clamped to [0, 32767] as a NonNegativeInt16.
@@ -113,6 +99,7 @@ export declare const NonNegativeInt16: {
     readonly pow: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
     /**
      * Adds two NonNegativeInt16 values.
+     *
      * @param a The first NonNegativeInt16.
      * @param b The second NonNegativeInt16.
      * @returns `a + b` clamped to [0, 32767] as a NonNegativeInt16.
@@ -120,6 +107,7 @@ export declare const NonNegativeInt16: {
     readonly add: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
     /**
      * Subtracts one NonNegativeInt16 from another.
+     *
      * @param a The minuend NonNegativeInt16.
      * @param b The subtrahend NonNegativeInt16.
      * @returns `a - b` clamped to [0, 32767] as a NonNegativeInt16 (minimum 0).
@@ -127,6 +115,7 @@ export declare const NonNegativeInt16: {
     readonly sub: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
     /**
      * Multiplies two NonNegativeInt16 values.
+     *
      * @param a The first NonNegativeInt16.
      * @param b The second NonNegativeInt16.
      * @returns `a * b` clamped to [0, 32767] as a NonNegativeInt16.
@@ -134,6 +123,7 @@ export declare const NonNegativeInt16: {
     readonly mul: (x: WithSmallInt<NonNegativeInt16, 40>, y: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
     /**
      * Divides one NonNegativeInt16 by another using floor division.
+     *
      * @param a The dividend NonNegativeInt16.
      * @param b The divisor NonNegativeInt16.
      * @returns `⌊a / b⌋` clamped to [0, 32767] as a NonNegativeInt16.

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,sCAAK,CAAC;AAErC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,sCAAK,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;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/non-negative-int16.mjs

@@ -8,72 +8,54 @@ const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, ran
     typeNameInMessage,
 });
 /**
- * Checks if a number is a NonNegativeInt16 (16-bit non-negative signed integer in the range [0, 2^15)).
+ * Checks if a number is a NonNegativeInt16 (16-bit non-negative signed integer
+ * in the range [0, 2^15)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonNegativeInt16, `false` otherwise.
  */
 const isNonNegativeInt16 = is;
 /**
  * Casts a number to a NonNegativeInt16 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonNegativeInt16 type.
  * @throws {TypeError} If the value is not a non-negative integer in [0, 2^15).
- * @example
- * ```typescript
- * const x = asNonNegativeInt16(1000); // NonNegativeInt16
- * const y = asNonNegativeInt16(0); // NonNegativeInt16
- * // asNonNegativeInt16(-1); // throws TypeError
- * // asNonNegativeInt16(32768); // throws TypeError
- * ```
  */
 const asNonNegativeInt16 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 16-bit non-negative integers.
- *
- * All operations automatically clamp results to the valid NonNegativeInt16 range [0, 32767].
- * This ensures that all arithmetic maintains the 16-bit non-negative integer constraint,
- * with negative results clamped to 0 and overflow results clamped to MAX_VALUE.
- *
- * @example
- * ```typescript
- * const a = asNonNegativeInt16(30000);
- * const b = asNonNegativeInt16(5000);
- *
- * // Arithmetic operations with automatic clamping
- * const sum = NonNegativeInt16.add(a, b);       // NonNegativeInt16 (32767 - clamped to MAX_VALUE)
- * const diff = NonNegativeInt16.sub(a, b);      // NonNegativeInt16 (25000)
- * const reverseDiff = NonNegativeInt16.sub(b, a); // NonNegativeInt16 (0 - clamped to MIN_VALUE)
- * const product = NonNegativeInt16.mul(a, b);   // NonNegativeInt16 (32767 - clamped due to overflow)
- *
- * // Range operations
- * const clamped = NonNegativeInt16.clamp(-100);     // NonNegativeInt16 (0)
- * const minimum = NonNegativeInt16.min(a, b);       // NonNegativeInt16 (5000)
- * const maximum = NonNegativeInt16.max(a, b);       // NonNegativeInt16 (30000)
+ * Namespace providing type-safe arithmetic operations for 16-bit non-negative
+ * integers.
  *
- * // Utility operations
- * const random = NonNegativeInt16.random();         // NonNegativeInt16 (random value in [0, 32767])
- * const power = NonNegativeInt16.pow(asNonNegativeInt16(2), asNonNegativeInt16(10)); // NonNegativeInt16 (1024)
- * ```
+ * All operations automatically clamp results to the valid NonNegativeInt16
+ * range [0, 32767]. This ensures that all arithmetic maintains the 16-bit
+ * non-negative integer constraint, with negative results clamped to 0 and
+ * overflow results clamped to MAX_VALUE.
  */
 const NonNegativeInt16 = {
     /**
      * Type guard to check if a value is a NonNegativeInt16.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 16-bit non-negative integer, `false` otherwise.
+     * @returns `true` if the value is a 16-bit non-negative integer, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for a 16-bit non-negative integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a 16-bit non-negative integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the smaller of two NonNegativeInt16 values.
+     *
      * @param a The first NonNegativeInt16.
      * @param b The second NonNegativeInt16.
      * @returns The minimum value as a NonNegativeInt16.
@@ -81,6 +63,7 @@ const NonNegativeInt16 = {
     min: min_,
     /**
      * Returns the larger of two NonNegativeInt16 values.
+     *
      * @param a The first NonNegativeInt16.
      * @param b The second NonNegativeInt16.
      * @returns The maximum value as a NonNegativeInt16.
@@ -88,17 +71,20 @@ const NonNegativeInt16 = {
     max: max_,
     /**
      * Clamps a number to the NonNegativeInt16 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [0, 32767] as a NonNegativeInt16.
      */
     clamp,
     /**
      * Generates a random NonNegativeInt16 value within the valid range.
+     *
      * @returns A random NonNegativeInt16 between 0 and 32767.
      */
     random,
     /**
      * Raises a NonNegativeInt16 to the power of another NonNegativeInt16.
+     *
      * @param a The base NonNegativeInt16.
      * @param b The exponent NonNegativeInt16.
      * @returns `a ** b` clamped to [0, 32767] as a NonNegativeInt16.
@@ -106,6 +92,7 @@ const NonNegativeInt16 = {
     pow,
     /**
      * Adds two NonNegativeInt16 values.
+     *
      * @param a The first NonNegativeInt16.
      * @param b The second NonNegativeInt16.
      * @returns `a + b` clamped to [0, 32767] as a NonNegativeInt16.
@@ -113,6 +100,7 @@ const NonNegativeInt16 = {
     add,
     /**
      * Subtracts one NonNegativeInt16 from another.
+     *
      * @param a The minuend NonNegativeInt16.
      * @param b The subtrahend NonNegativeInt16.
      * @returns `a - b` clamped to [0, 32767] as a NonNegativeInt16 (minimum 0).
@@ -120,6 +108,7 @@ const NonNegativeInt16 = {
     sub,
     /**
      * Multiplies two NonNegativeInt16 values.
+     *
      * @param a The first NonNegativeInt16.
      * @param b The second NonNegativeInt16.
      * @returns `a * b` clamped to [0, 32767] as a NonNegativeInt16.
@@ -127,6 +116,7 @@ const NonNegativeInt16 = {
     mul,
     /**
      * Divides one NonNegativeInt16 by another using floor division.
+     *
      * @param a The dividend NonNegativeInt16.
      * @param b The divisor NonNegativeInt16.
      * @returns `⌊a / b⌋` clamped to [0, 32767] as a NonNegativeInt16.