ts-data-forge 3.2.0 → 3.3.1

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int16.mjs","sources":["../../../src/number/branded-types/positive-int16.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,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,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":"positive-int16.mjs","sources":["../../../src/number/branded-types/positive-int16.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,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,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-int32.d.mts

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

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int32.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,eAAe,mCAAK,CAAC;AAElC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,aAAa;IACxB;;;;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":"positive-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int32.mts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,mCAAK,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;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/positive-int32.mjs

@@ -8,73 +8,54 @@ const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, ran
     typeNameInMessage,
 });
 /**
- * Checks if a number is a PositiveInt32 (32-bit positive signed integer in the range [1, 2^31)).
+ * Checks if a number is a PositiveInt32 (32-bit positive signed integer in the
+ * range [1, 2^31)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a PositiveInt32, `false` otherwise.
  */
 const isPositiveInt32 = is;
 /**
  * Casts a number to a PositiveInt32 type.
+ *
  * @param value The value to cast.
  * @returns The value as a PositiveInt32 type.
  * @throws {TypeError} If the value is not a positive integer in [1, 2^31).
- * @example
- * ```typescript
- * const x = asPositiveInt32(1000); // PositiveInt32
- * const y = asPositiveInt32(2147483647); // PositiveInt32
- * // asPositiveInt32(0); // throws TypeError
- * // asPositiveInt32(-1); // throws TypeError
- * // asPositiveInt32(2147483648); // throws TypeError
- * ```
  */
 const asPositiveInt32 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 32-bit positive integers.
- *
- * All operations automatically clamp results to the valid PositiveInt32 range [1, 2147483647].
- * This ensures that all arithmetic maintains the 32-bit positive integer constraint,
- * with results below 1 clamped to MIN_VALUE and overflow results clamped to MAX_VALUE.
- *
- * @example
- * ```typescript
- * const a = asPositiveInt32(2000000000);
- * const b = asPositiveInt32(500000000);
- *
- * // Arithmetic operations with automatic clamping and positive constraint
- * const sum = PositiveInt32.add(a, b);       // PositiveInt32 (2147483647 - clamped to MAX_VALUE)
- * const diff = PositiveInt32.sub(a, b);      // PositiveInt32 (1500000000)
- * const reverseDiff = PositiveInt32.sub(b, a); // PositiveInt32 (1 - clamped to MIN_VALUE)
- * const product = PositiveInt32.mul(a, b);   // PositiveInt32 (2147483647 - clamped due to overflow)
- *
- * // Range operations (maintaining positive constraint)
- * const clamped = PositiveInt32.clamp(-1000);     // PositiveInt32 (1)
- * const minimum = PositiveInt32.min(a, b);        // PositiveInt32 (500000000)
- * const maximum = PositiveInt32.max(a, b);        // PositiveInt32 (2000000000)
+ * Namespace providing type-safe arithmetic operations for 32-bit positive
+ * integers.
  *
- * // Utility operations
- * const random = PositiveInt32.random();          // PositiveInt32 (random value in [1, 2147483647])
- * const power = PositiveInt32.pow(asPositiveInt32(2), asPositiveInt32(20)); // PositiveInt32 (1048576)
- * ```
+ * All operations automatically clamp results to the valid PositiveInt32 range
+ * [1, 2147483647]. This ensures that all arithmetic maintains the 32-bit
+ * positive integer constraint, with results below 1 clamped to MIN_VALUE and
+ * overflow results clamped to MAX_VALUE.
  */
 const PositiveInt32 = {
     /**
      * Type guard to check if a value is a PositiveInt32.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 32-bit positive integer, `false` otherwise.
+     * @returns `true` if the value is a 32-bit positive integer, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for a 32-bit positive integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a 32-bit positive integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the smaller of two PositiveInt32 values.
+     *
      * @param a The first PositiveInt32.
      * @param b The second PositiveInt32.
      * @returns The minimum value as a PositiveInt32.
@@ -82,6 +63,7 @@ const PositiveInt32 = {
     min: min_,
     /**
      * Returns the larger of two PositiveInt32 values.
+     *
      * @param a The first PositiveInt32.
      * @param b The second PositiveInt32.
      * @returns The maximum value as a PositiveInt32.
@@ -89,17 +71,20 @@ const PositiveInt32 = {
     max: max_,
     /**
      * Clamps a number to the PositiveInt32 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [1, 2147483647] as a PositiveInt32.
      */
     clamp,
     /**
      * Generates a random PositiveInt32 value within the valid range.
+     *
      * @returns A random PositiveInt32 between 1 and 2147483647.
      */
     random,
     /**
      * Raises a PositiveInt32 to the power of another PositiveInt32.
+     *
      * @param a The base PositiveInt32.
      * @param b The exponent PositiveInt32.
      * @returns `a ** b` clamped to [1, 2147483647] as a PositiveInt32.
@@ -107,6 +92,7 @@ const PositiveInt32 = {
     pow,
     /**
      * Adds two PositiveInt32 values.
+     *
      * @param a The first PositiveInt32.
      * @param b The second PositiveInt32.
      * @returns `a + b` clamped to [1, 2147483647] as a PositiveInt32.
@@ -114,6 +100,7 @@ const PositiveInt32 = {
     add,
     /**
      * Subtracts one PositiveInt32 from another.
+     *
      * @param a The minuend PositiveInt32.
      * @param b The subtrahend PositiveInt32.
      * @returns `a - b` clamped to [1, 2147483647] as a PositiveInt32 (minimum 1).
@@ -121,6 +108,7 @@ const PositiveInt32 = {
     sub,
     /**
      * Multiplies two PositiveInt32 values.
+     *
      * @param a The first PositiveInt32.
      * @param b The second PositiveInt32.
      * @returns `a * b` clamped to [1, 2147483647] as a PositiveInt32.
@@ -128,6 +116,7 @@ const PositiveInt32 = {
     mul,
     /**
      * Divides one PositiveInt32 by another using floor division.
+     *
      * @param a The dividend PositiveInt32.
      * @param b The divisor PositiveInt32.
      * @returns `⌊a / b⌋` clamped to [1, 2147483647] as a PositiveInt32.

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int32.mjs","sources":["../../../src/number/branded-types/positive-int32.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,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,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":"positive-int32.mjs","sources":["../../../src/number/branded-types/positive-int32.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,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,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;;;;;"}