ts-data-forge 3.3.0 → 3.3.1

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

@@ -9,73 +9,54 @@ const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, ran
     typeNameInMessage,
 });
 /**
- * Checks if a number is a NonZeroUint32 (32-bit non-zero unsigned integer in the range [1, 2^32)).
+ * Checks if a number is a NonZeroUint32 (32-bit non-zero unsigned integer in
+ * the range [1, 2^32)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroUint32, `false` otherwise.
  */
 const isNonZeroUint32 = is;
 /**
  * Casts a number to a NonZeroUint32 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroUint32 type.
  * @throws {TypeError} If the value is not a non-zero integer in [1, 2^32).
- * @example
- * ```typescript
- * const x = asNonZeroUint32(1000); // NonZeroUint32
- * const y = asNonZeroUint32(4294967295); // NonZeroUint32
- * // asNonZeroUint32(0); // throws TypeError
- * // asNonZeroUint32(-1); // throws TypeError
- * // asNonZeroUint32(4294967296); // throws TypeError
- * ```
  */
 const asNonZeroUint32 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 32-bit non-zero unsigned integers.
- *
- * All operations automatically clamp results to the valid NonZeroUint32 range [1, 4294967295].
- * This ensures that all arithmetic maintains the 32-bit non-zero unsigned integer constraint,
- * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
- *
- * @example
- * ```typescript
- * const a = asNonZeroUint32(4000000000);
- * const b = asNonZeroUint32(1000000000);
- *
- * // Arithmetic operations with automatic clamping and non-zero constraint
- * const sum = NonZeroUint32.add(a, b);       // NonZeroUint32 (4294967295 - clamped to MAX_VALUE)
- * const diff = NonZeroUint32.sub(a, b);      // NonZeroUint32 (3000000000)
- * const reverseDiff = NonZeroUint32.sub(b, a); // NonZeroUint32 (1 - clamped to MIN_VALUE)
- * const product = NonZeroUint32.mul(a, b);   // NonZeroUint32 (4294967295 - clamped due to overflow)
- *
- * // Range operations (maintaining non-zero constraint)
- * const clamped = NonZeroUint32.clamp(-100);     // NonZeroUint32 (1)
- * const minimum = NonZeroUint32.min(a, b);       // NonZeroUint32 (1000000000)
- * const maximum = NonZeroUint32.max(a, b);       // NonZeroUint32 (4000000000)
+ * Namespace providing type-safe arithmetic operations for 32-bit non-zero
+ * unsigned integers.
  *
- * // Utility operations
- * const random = NonZeroUint32.random();         // NonZeroUint32 (random value in [1, 4294967295])
- * const power = NonZeroUint32.pow(asNonZeroUint32(2), asNonZeroUint32(20)); // NonZeroUint32 (1048576)
- * ```
+ * All operations automatically clamp results to the valid NonZeroUint32 range
+ * [1, 4294967295]. This ensures that all arithmetic maintains the 32-bit
+ * non-zero unsigned integer constraint, with results below 1 clamped to
+ * MIN_VALUE and overflow results clamped to MAX_VALUE.
  */
 const NonZeroUint32 = {
     /**
      * Type guard to check if a value is a NonZeroUint32.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 32-bit non-zero unsigned integer, `false` otherwise.
+     * @returns `true` if the value is a 32-bit non-zero unsigned integer, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for a 32-bit non-zero unsigned integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a 32-bit non-zero unsigned integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the smaller of two NonZeroUint32 values.
+     *
      * @param a The first NonZeroUint32.
      * @param b The second NonZeroUint32.
      * @returns The minimum value as a NonZeroUint32.
@@ -83,6 +64,7 @@ const NonZeroUint32 = {
     min: min_,
     /**
      * Returns the larger of two NonZeroUint32 values.
+     *
      * @param a The first NonZeroUint32.
      * @param b The second NonZeroUint32.
      * @returns The maximum value as a NonZeroUint32.
@@ -90,17 +72,20 @@ const NonZeroUint32 = {
     max: max_,
     /**
      * Clamps a number to the NonZeroUint32 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [1, 4294967295] as a NonZeroUint32.
      */
     clamp,
     /**
      * Generates a random NonZeroUint32 value within the valid range.
+     *
      * @returns A random NonZeroUint32 between 1 and 4294967295.
      */
     random,
     /**
      * Raises a NonZeroUint32 to the power of another NonZeroUint32.
+     *
      * @param a The base NonZeroUint32.
      * @param b The exponent NonZeroUint32.
      * @returns `a ** b` clamped to [1, 4294967295] as a NonZeroUint32.
@@ -108,6 +93,7 @@ const NonZeroUint32 = {
     pow,
     /**
      * Adds two NonZeroUint32 values.
+     *
      * @param a The first NonZeroUint32.
      * @param b The second NonZeroUint32.
      * @returns `a + b` clamped to [1, 4294967295] as a NonZeroUint32.
@@ -115,6 +101,7 @@ const NonZeroUint32 = {
     add,
     /**
      * Subtracts one NonZeroUint32 from another.
+     *
      * @param a The minuend NonZeroUint32.
      * @param b The subtrahend NonZeroUint32.
      * @returns `a - b` clamped to [1, 4294967295] as a NonZeroUint32 (minimum 1).
@@ -122,6 +109,7 @@ const NonZeroUint32 = {
     sub,
     /**
      * Multiplies two NonZeroUint32 values.
+     *
      * @param a The first NonZeroUint32.
      * @param b The second NonZeroUint32.
      * @returns `a * b` clamped to [1, 4294967295] as a NonZeroUint32.
@@ -129,6 +117,7 @@ const NonZeroUint32 = {
     mul,
     /**
      * Divides one NonZeroUint32 by another using floor division.
+     *
      * @param a The dividend NonZeroUint32.
      * @param b The divisor NonZeroUint32.
      * @returns `⌊a / b⌋` clamped to [1, 4294967295] as a NonZeroUint32.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint32.mjs","sources":["../../../src/number/branded-types/non-zero-uint32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iCAAiC;AAE3D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,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,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,eAAe,GAAG;AAE/B;;;;;;;;;;;;;AAaG;AACI,MAAM,eAAe,GAAG;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,aAAa,GAAG;AAC3B;;;;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":"non-zero-uint32.mjs","sources":["../../../src/number/branded-types/non-zero-uint32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iCAAiC;AAE3D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,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,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,eAAe,GAAG;AAE/B;;;;;;AAMG;AACI,MAAM,eAAe,GAAG;AAE/B;;;;;;;;AAQG;AACI,MAAM,aAAa,GAAG;AAC3B;;;;;;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/positive-finite-number.d.mts

@@ -2,22 +2,17 @@ import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 type ElementType = PositiveFiniteNumber;
 /**
  * Checks if a number is a PositiveFiniteNumber (a finite number > 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a PositiveFiniteNumber, `false` otherwise.
  */
 export declare const isPositiveFiniteNumber: (a: number) => a is PositiveFiniteNumber;
 /**
  * Casts a number to a PositiveFiniteNumber type.
+ *
  * @param value The value to cast.
  * @returns The value as a PositiveFiniteNumber type.
  * @throws {TypeError} If the value is not a positive finite number.
- * @example
- * ```typescript
- * const x = asPositiveFiniteNumber(5.5); // PositiveFiniteNumber
- * const y = asPositiveFiniteNumber(0.001); // PositiveFiniteNumber
- * // asPositiveFiniteNumber(0); // throws TypeError
- * // asPositiveFiniteNumber(-1); // throws TypeError
- * ```
  */
 export declare const asPositiveFiniteNumber: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -32,53 +27,32 @@ export declare const asPositiveFiniteNumber: <N extends number>(x: N) => number
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
 /**
- * Namespace providing type-safe arithmetic operations for positive finite numbers.
- *
- * All operations maintain the positive constraint by clamping non-positive results to MIN_VALUE,
- * while ensuring results remain finite (excluding NaN and Infinity). This type is useful
- * for representing quantities that must always be positive, such as probabilities, magnitudes,
- * and physical measurements.
- *
- * @example
- * ```typescript
- * const probability = asPositiveFiniteNumber(0.75);
- * const rate = asPositiveFiniteNumber(1.25);
- *
- * // Arithmetic operations with positive clamping
- * const combined = PositiveFiniteNumber.add(probability, rate);        // PositiveFiniteNumber (2.0)
- * const difference = PositiveFiniteNumber.sub(rate, probability);      // PositiveFiniteNumber (0.5)
- * const scaled = PositiveFiniteNumber.mul(probability, rate);          // PositiveFiniteNumber (0.9375)
- * const ratio = PositiveFiniteNumber.div(rate, probability);           // PositiveFiniteNumber (1.666...)
- *
- * // Range operations
- * const clamped = PositiveFiniteNumber.clamp(-10.5);                  // PositiveFiniteNumber (MIN_VALUE)
- * const minimum = PositiveFiniteNumber.min(probability, rate);         // PositiveFiniteNumber (0.75)
- * const maximum = PositiveFiniteNumber.max(probability, rate);         // PositiveFiniteNumber (1.25)
- *
- * // Rounding operations (different return types based on operation)
- * const ceiled = PositiveFiniteNumber.ceil(probability);              // PositiveInt (1)
- * const floored = PositiveFiniteNumber.floor(rate);                   // Uint (1)
- * const rounded = PositiveFiniteNumber.round(rate);                   // Uint (1)
+ * Namespace providing type-safe arithmetic operations for positive finite
+ * numbers.
  *
- * // Utility operations
- * const random = PositiveFiniteNumber.random();                       // PositiveFiniteNumber (random positive value)
- * const power = PositiveFiniteNumber.pow(rate, probability);          // PositiveFiniteNumber (1.18...)
- * ```
+ * All operations maintain the positive constraint by clamping non-positive
+ * results to MIN_VALUE, while ensuring results remain finite (excluding NaN and
+ * Infinity). This type is useful for representing quantities that must always
+ * be positive, such as probabilities, magnitudes, and physical measurements.
  */
 export declare const PositiveFiniteNumber: {
     /**
      * Type guard to check if a value is a PositiveFiniteNumber.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a positive finite number, `false` otherwise.
+     * @returns `true` if the value is a positive finite number, `false`
+     *   otherwise.
      */
     readonly is: (a: number) => a is PositiveFiniteNumber;
     /**
      * The minimum value for a positive finite number.
+     *
      * @readonly
      */
     readonly MIN_VALUE: number;
     /**
      * Returns the smaller of two PositiveFiniteNumber values.
+     *
      * @param a The first PositiveFiniteNumber.
      * @param b The second PositiveFiniteNumber.
      * @returns The minimum value as a PositiveFiniteNumber.
@@ -86,6 +60,7 @@ export declare const PositiveFiniteNumber: {
     readonly min: (...values: readonly PositiveFiniteNumber[]) => PositiveFiniteNumber;
     /**
      * Returns the larger of two PositiveFiniteNumber values.
+     *
      * @param a The first PositiveFiniteNumber.
      * @param b The second PositiveFiniteNumber.
      * @returns The maximum value as a PositiveFiniteNumber.
@@ -93,35 +68,41 @@ export declare const PositiveFiniteNumber: {
     readonly max: (...values: readonly PositiveFiniteNumber[]) => PositiveFiniteNumber;
     /**
      * Clamps a number to the positive finite range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to (0, +∞) as a PositiveFiniteNumber.
      */
     readonly clamp: (x: number) => PositiveFiniteNumber;
     /**
      * Rounds down a PositiveFiniteNumber to the nearest integer.
+     *
      * @param x The PositiveFiniteNumber to round down.
      * @returns The floor value as a Uint (can be 0).
      */
     readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
     /**
      * Rounds up a PositiveFiniteNumber to the nearest integer.
+     *
      * @param x The PositiveFiniteNumber to round up.
      * @returns The ceiling value as a PositiveInt (always >= 1).
      */
     readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds a PositiveFiniteNumber to the nearest integer.
+     *
      * @param x The PositiveFiniteNumber to round.
      * @returns The rounded value as a Uint (can be 0 if x < 0.5).
      */
     readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
     /**
      * Generates a random PositiveFiniteNumber value.
+     *
      * @returns A random positive finite number.
      */
     readonly random: (min?: PositiveFiniteNumber | undefined, max?: PositiveFiniteNumber | undefined) => PositiveFiniteNumber;
     /**
      * Raises a PositiveFiniteNumber to the power of another PositiveFiniteNumber.
+     *
      * @param a The base PositiveFiniteNumber.
      * @param b The exponent PositiveFiniteNumber.
      * @returns `a ** b` clamped to (0, +∞) as a PositiveFiniteNumber.
@@ -129,6 +110,7 @@ export declare const PositiveFiniteNumber: {
     readonly pow: (x: PositiveFiniteNumber, y: PositiveFiniteNumber) => PositiveFiniteNumber;
     /**
      * Adds two PositiveFiniteNumber values.
+     *
      * @param a The first PositiveFiniteNumber.
      * @param b The second PositiveFiniteNumber.
      * @returns `a + b` clamped to (0, +∞) as a PositiveFiniteNumber.
@@ -136,13 +118,16 @@ export declare const PositiveFiniteNumber: {
     readonly add: (x: PositiveFiniteNumber, y: PositiveFiniteNumber) => PositiveFiniteNumber;
     /**
      * Subtracts one PositiveFiniteNumber from another.
+     *
      * @param a The minuend PositiveFiniteNumber.
      * @param b The subtrahend PositiveFiniteNumber.
-     * @returns `a - b` clamped to (0, +∞) as a PositiveFiniteNumber (minimum MIN_VALUE).
+     * @returns `a - b` clamped to (0, +∞) as a PositiveFiniteNumber (minimum
+     *   MIN_VALUE).
      */
     readonly sub: (x: PositiveFiniteNumber, y: PositiveFiniteNumber) => PositiveFiniteNumber;
     /**
      * Multiplies two PositiveFiniteNumber values.
+     *
      * @param a The first PositiveFiniteNumber.
      * @param b The second PositiveFiniteNumber.
      * @returns `a * b` clamped to (0, +∞) as a PositiveFiniteNumber.
@@ -150,6 +135,7 @@ export declare const PositiveFiniteNumber: {
     readonly mul: (x: PositiveFiniteNumber, y: PositiveFiniteNumber) => PositiveFiniteNumber;
     /**
      * Divides one PositiveFiniteNumber by another.
+     *
      * @param a The dividend PositiveFiniteNumber.
      * @param b The divisor PositiveFiniteNumber.
      * @returns `a / b` clamped to (0, +∞) as a PositiveFiniteNumber.

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

@@ -1 +1 @@
-{"version":3,"file":"positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AAqExC;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,0CAAK,CAAC;AAEzC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;wBA1IA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IA0IC;;;;OAIG;uBArIA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAuI3D;;;;OAIG;wBAtIA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAsIC;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AAqExC;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,0CAAK,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;wBAnHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAmHC;;;;;OAKG;uBA/GA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAiH3D;;;;;OAKG;wBAjHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAC3D;IAiHC;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/positive-finite-number.mjs

@@ -7,82 +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 PositiveFiniteNumber (a finite number > 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a PositiveFiniteNumber, `false` otherwise.
  */
 const isPositiveFiniteNumber = is;
 /**
  * Casts a number to a PositiveFiniteNumber type.
+ *
  * @param value The value to cast.
  * @returns The value as a PositiveFiniteNumber type.
  * @throws {TypeError} If the value is not a positive finite number.
- * @example
- * ```typescript
- * const x = asPositiveFiniteNumber(5.5); // PositiveFiniteNumber
- * const y = asPositiveFiniteNumber(0.001); // PositiveFiniteNumber
- * // asPositiveFiniteNumber(0); // throws TypeError
- * // asPositiveFiniteNumber(-1); // throws TypeError
- * ```
  */
 const asPositiveFiniteNumber = castType;
 /**
- * Namespace providing type-safe arithmetic operations for positive finite numbers.
- *
- * All operations maintain the positive constraint by clamping non-positive results to MIN_VALUE,
- * while ensuring results remain finite (excluding NaN and Infinity). This type is useful
- * for representing quantities that must always be positive, such as probabilities, magnitudes,
- * and physical measurements.
- *
- * @example
- * ```typescript
- * const probability = asPositiveFiniteNumber(0.75);
- * const rate = asPositiveFiniteNumber(1.25);
- *
- * // Arithmetic operations with positive clamping
- * const combined = PositiveFiniteNumber.add(probability, rate);        // PositiveFiniteNumber (2.0)
- * const difference = PositiveFiniteNumber.sub(rate, probability);      // PositiveFiniteNumber (0.5)
- * const scaled = PositiveFiniteNumber.mul(probability, rate);          // PositiveFiniteNumber (0.9375)
- * const ratio = PositiveFiniteNumber.div(rate, probability);           // PositiveFiniteNumber (1.666...)
- *
- * // Range operations
- * const clamped = PositiveFiniteNumber.clamp(-10.5);                  // PositiveFiniteNumber (MIN_VALUE)
- * const minimum = PositiveFiniteNumber.min(probability, rate);         // PositiveFiniteNumber (0.75)
- * const maximum = PositiveFiniteNumber.max(probability, rate);         // PositiveFiniteNumber (1.25)
- *
- * // Rounding operations (different return types based on operation)
- * const ceiled = PositiveFiniteNumber.ceil(probability);              // PositiveInt (1)
- * const floored = PositiveFiniteNumber.floor(rate);                   // Uint (1)
- * const rounded = PositiveFiniteNumber.round(rate);                   // Uint (1)
+ * Namespace providing type-safe arithmetic operations for positive finite
+ * numbers.
  *
- * // Utility operations
- * const random = PositiveFiniteNumber.random();                       // PositiveFiniteNumber (random positive value)
- * const power = PositiveFiniteNumber.pow(rate, probability);          // PositiveFiniteNumber (1.18...)
- * ```
+ * All operations maintain the positive constraint by clamping non-positive
+ * results to MIN_VALUE, while ensuring results remain finite (excluding NaN and
+ * Infinity). This type is useful for representing quantities that must always
+ * be positive, such as probabilities, magnitudes, and physical measurements.
  */
 const PositiveFiniteNumber = {
     /**
      * Type guard to check if a value is a PositiveFiniteNumber.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a positive finite number, `false` otherwise.
+     * @returns `true` if the value is a positive finite number, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for a positive finite number.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * Returns the smaller of two PositiveFiniteNumber values.
+     *
      * @param a The first PositiveFiniteNumber.
      * @param b The second PositiveFiniteNumber.
      * @returns The minimum value as a PositiveFiniteNumber.
@@ -90,6 +64,7 @@ const PositiveFiniteNumber = {
     min: min_,
     /**
      * Returns the larger of two PositiveFiniteNumber values.
+     *
      * @param a The first PositiveFiniteNumber.
      * @param b The second PositiveFiniteNumber.
      * @returns The maximum value as a PositiveFiniteNumber.
@@ -97,35 +72,41 @@ const PositiveFiniteNumber = {
     max: max_,
     /**
      * Clamps a number to the positive finite range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to (0, +∞) as a PositiveFiniteNumber.
      */
     clamp,
     /**
      * Rounds down a PositiveFiniteNumber to the nearest integer.
+     *
      * @param x The PositiveFiniteNumber to round down.
      * @returns The floor value as a Uint (can be 0).
      */
     floor,
     /**
      * Rounds up a PositiveFiniteNumber to the nearest integer.
+     *
      * @param x The PositiveFiniteNumber to round up.
      * @returns The ceiling value as a PositiveInt (always >= 1).
      */
     ceil,
     /**
      * Rounds a PositiveFiniteNumber to the nearest integer.
+     *
      * @param x The PositiveFiniteNumber to round.
      * @returns The rounded value as a Uint (can be 0 if x < 0.5).
      */
     round,
     /**
      * Generates a random PositiveFiniteNumber value.
+     *
      * @returns A random positive finite number.
      */
     random,
     /**
      * Raises a PositiveFiniteNumber to the power of another PositiveFiniteNumber.
+     *
      * @param a The base PositiveFiniteNumber.
      * @param b The exponent PositiveFiniteNumber.
      * @returns `a ** b` clamped to (0, +∞) as a PositiveFiniteNumber.
@@ -133,6 +114,7 @@ const PositiveFiniteNumber = {
     pow,
     /**
      * Adds two PositiveFiniteNumber values.
+     *
      * @param a The first PositiveFiniteNumber.
      * @param b The second PositiveFiniteNumber.
      * @returns `a + b` clamped to (0, +∞) as a PositiveFiniteNumber.
@@ -140,13 +122,16 @@ const PositiveFiniteNumber = {
     add,
     /**
      * Subtracts one PositiveFiniteNumber from another.
+     *
      * @param a The minuend PositiveFiniteNumber.
      * @param b The subtrahend PositiveFiniteNumber.
-     * @returns `a - b` clamped to (0, +∞) as a PositiveFiniteNumber (minimum MIN_VALUE).
+     * @returns `a - b` clamped to (0, +∞) as a PositiveFiniteNumber (minimum
+     *   MIN_VALUE).
      */
     sub,
     /**
      * Multiplies two PositiveFiniteNumber values.
+     *
      * @param a The first PositiveFiniteNumber.
      * @param b The second PositiveFiniteNumber.
      * @returns `a * b` clamped to (0, +∞) as a PositiveFiniteNumber.
@@ -154,6 +139,7 @@ const PositiveFiniteNumber = {
     mul,
     /**
      * Divides one PositiveFiniteNumber by another.
+     *
      * @param a The dividend PositiveFiniteNumber.
      * @param b The divisor PositiveFiniteNumber.
      * @returns `a / b` clamped to (0, +∞) as a PositiveFiniteNumber.

package/dist/number/branded-types/positive-finite-number.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"positive-finite-number.mjs","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,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;IACA,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAId;AACA,IAAI,CAAC,KAAK,CACR,CAAC,CAGF;AAEH,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAId;AACA,IAAI,CAAC,KAAK,CACR,CAAC,CAGF;AAcH;;;;AAIG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;;;;;;;AAYG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACI,MAAM,oBAAoB,GAAG;AAClC;;;;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":"positive-finite-number.mjs","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,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;IACA,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAId;AACA,IAAI,CAAC,KAAK,CACR,CAAC,CAGF;AAEH,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAId;AACA,IAAI,CAAC,KAAK,CACR,CAAC,CAGF;AAcH;;;;;AAKG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;AAMG;AACI,MAAM,sBAAsB,GAAG;AAEtC;;;;;;;;AAQG;AACI,MAAM,oBAAoB,GAAG;AAClC;;;;;;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;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}