ts-data-forge 3.2.0 → 3.3.1

package/dist/number/branded-types/non-zero-safe-int.mjs

@@ -4,83 +4,67 @@ const typeNameInMessage = 'a non-zero safe integer';
 const { MIN_VALUE, MAX_VALUE, abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: random, is, castType, clamp, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'SafeInteger',
     nonZero: true,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     MIN_VALUE: Number.MIN_SAFE_INTEGER,
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     MAX_VALUE: Number.MAX_SAFE_INTEGER,
     typeNameInMessage,
 });
 /**
- * Checks if a number is a NonZeroSafeInt (a non-zero safe integer in the range [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] excluding 0).
+ * Checks if a number is a NonZeroSafeInt (a non-zero safe integer in the range
+ * [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] excluding 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroSafeInt, `false` otherwise.
  */
 const isNonZeroSafeInt = is;
 /**
  * Casts a number to a NonZeroSafeInt type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroSafeInt type.
  * @throws {TypeError} If the value is not a non-zero safe integer.
- * @example
- * ```typescript
- * const x = asNonZeroSafeInt(5); // NonZeroSafeInt
- * const y = asNonZeroSafeInt(-1000); // NonZeroSafeInt
- * // asNonZeroSafeInt(0); // throws TypeError
- * // asNonZeroSafeInt(1.5); // throws TypeError
- * ```
  */
 const asNonZeroSafeInt = castType;
 /**
- * Namespace providing type-safe arithmetic operations for non-zero safe integers.
- *
- * All operations automatically clamp results to the non-zero safe integer range, excluding zero.
- * This ensures that all arithmetic maintains both the non-zero constraint and IEEE 754 precision guarantees,
- * preventing precision loss while ensuring results are never zero.
- *
- * @example
- * ```typescript
- * const a = asNonZeroSafeInt(9007199254740000);  // Near MAX_SAFE_INTEGER
- * const b = asNonZeroSafeInt(-1000);
- *
- * // Arithmetic operations with non-zero safe range clamping
- * const sum = NonZeroSafeInt.add(a, b);          // NonZeroSafeInt (9007199254739000)
- * const diff = NonZeroSafeInt.sub(a, b);         // NonZeroSafeInt (clamped to MAX_SAFE_INTEGER)
- * const product = NonZeroSafeInt.mul(a, b);      // NonZeroSafeInt (clamped to MIN_SAFE_INTEGER)
- *
- * // Utility operations
- * const absolute = NonZeroSafeInt.abs(b);            // NonZeroSafeInt (1000)
- * const minimum = NonZeroSafeInt.min(a, b);          // NonZeroSafeInt (-1000)
- * const maximum = NonZeroSafeInt.max(a, b);          // NonZeroSafeInt (a)
+ * Namespace providing type-safe arithmetic operations for non-zero safe
+ * integers.
  *
- * // Random generation
- * const random = NonZeroSafeInt.random();            // NonZeroSafeInt (random non-zero safe integer)
- * ```
+ * All operations automatically clamp results to the non-zero safe integer
+ * range, excluding zero. This ensures that all arithmetic maintains both the
+ * non-zero constraint and IEEE 754 precision guarantees, preventing precision
+ * loss while ensuring results are never zero.
  */
 const NonZeroSafeInt = {
     /**
      * Type guard to check if a value is a NonZeroSafeInt.
+     *
      * @param value The value to check.
      * @returns `true` if the value is a non-zero safe integer, `false` otherwise.
      */
     is,
     /**
      * The minimum safe integer value (-(2^53 - 1)).
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum safe integer value (2^53 - 1).
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the absolute value of a non-zero safe integer.
+     *
      * @param a The NonZeroSafeInt value.
      * @returns The absolute value as a NonZeroSafeInt, clamped to safe range.
      */
     abs,
     /**
      * Returns the smaller of two NonZeroSafeInt values.
+     *
      * @param a The first NonZeroSafeInt.
      * @param b The second NonZeroSafeInt.
      * @returns The minimum value as a NonZeroSafeInt.
@@ -88,6 +72,7 @@ const NonZeroSafeInt = {
     min: min_,
     /**
      * Returns the larger of two NonZeroSafeInt values.
+     *
      * @param a The first NonZeroSafeInt.
      * @param b The second NonZeroSafeInt.
      * @returns The maximum value as a NonZeroSafeInt.
@@ -95,48 +80,62 @@ const NonZeroSafeInt = {
     max: max_,
     /**
      * Clamps a number to the non-zero safe integer range.
+     *
      * @param value The number to clamp.
-     * @returns The value clamped to [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] \ {0} as a NonZeroSafeInt.
+     * @returns The value clamped to [MIN_SAFE_INTEGER, MAX_SAFE_INTEGER] \ {0} as
+     *   a NonZeroSafeInt.
      */
     clamp,
     /**
      * Generates a random NonZeroSafeInt value within the valid range.
-     * @returns A random non-zero safe integer between MIN_SAFE_INTEGER and MAX_SAFE_INTEGER.
+     *
+     * @returns A random non-zero safe integer between MIN_SAFE_INTEGER and
+     *   MAX_SAFE_INTEGER.
      */
     random,
     /**
      * Raises a NonZeroSafeInt to the power of another NonZeroSafeInt.
+     *
      * @param a The base NonZeroSafeInt.
      * @param b The exponent NonZeroSafeInt.
-     * @returns `a ** b` clamped to non-zero safe integer range as a NonZeroSafeInt.
+     * @returns `a ** b` clamped to non-zero safe integer range as a
+     *   NonZeroSafeInt.
      */
     pow,
     /**
      * Adds two NonZeroSafeInt values.
+     *
      * @param a The first NonZeroSafeInt.
      * @param b The second NonZeroSafeInt.
-     * @returns `a + b` clamped to non-zero safe integer range as a NonZeroSafeInt.
+     * @returns `a + b` clamped to non-zero safe integer range as a
+     *   NonZeroSafeInt.
      */
     add,
     /**
      * Subtracts one NonZeroSafeInt from another.
+     *
      * @param a The minuend NonZeroSafeInt.
      * @param b The subtrahend NonZeroSafeInt.
-     * @returns `a - b` clamped to non-zero safe integer range as a NonZeroSafeInt.
+     * @returns `a - b` clamped to non-zero safe integer range as a
+     *   NonZeroSafeInt.
      */
     sub,
     /**
      * Multiplies two NonZeroSafeInt values.
+     *
      * @param a The first NonZeroSafeInt.
      * @param b The second NonZeroSafeInt.
-     * @returns `a * b` clamped to non-zero safe integer range as a NonZeroSafeInt.
+     * @returns `a * b` clamped to non-zero safe integer range as a
+     *   NonZeroSafeInt.
      */
     mul,
     /**
      * Divides one NonZeroSafeInt by another using floor division.
+     *
      * @param a The dividend NonZeroSafeInt.
      * @param b The divisor NonZeroSafeInt.
-     * @returns `⌊a / b⌋` clamped to non-zero safe integer range as a NonZeroSafeInt.
+     * @returns `⌊a / b⌋` clamped to non-zero safe integer range as a
+     *   NonZeroSafeInt.
      */
     div,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-safe-int.mjs","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,yBAAyB;AAEnD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,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;;IAEb,SAAS,EAAE,MAAM,CAAC,gBAA2B;;IAE7C,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;;;;;AAYG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,cAAc,GAAG;AAC5B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-zero-safe-int.mjs","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,yBAAyB;AAEnD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,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;;IAEb,SAAS,EAAE,MAAM,CAAC,gBAA2B;;IAE7C,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;AAMG;AACI,MAAM,gBAAgB,GAAG;AAEhC;;;;;;;;AAQG;AACI,MAAM,cAAc,GAAG;AAC5B;;;;;AAKG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;IACH,KAAK;AAEL;;;;;AAKG;IACH,MAAM;AAEN;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;;;;;"}

package/dist/number/branded-types/non-zero-uint16.d.mts

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

package/dist/number/branded-types/non-zero-uint16.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint16.mts"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH,eAAO,MAAM,eAAe,oCAAK,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":"non-zero-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint16.mts"],"names":[],"mappings":"AAiCA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,oCAAK,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/non-zero-uint16.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 NonZeroUint16 (16-bit non-zero unsigned integer in the range [1, 2^16)).
+ * Checks if a number is a NonZeroUint16 (16-bit non-zero unsigned integer in
+ * the range [1, 2^16)).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroUint16, `false` otherwise.
  */
 const isNonZeroUint16 = is;
 /**
  * Casts a number to a NonZeroUint16 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroUint16 type.
  * @throws {TypeError} If the value is not a non-zero integer in [1, 2^16).
- * @example
- * ```typescript
- * const x = asNonZeroUint16(1000); // NonZeroUint16
- * const y = asNonZeroUint16(65535); // NonZeroUint16
- * // asNonZeroUint16(0); // throws TypeError
- * // asNonZeroUint16(-1); // throws TypeError
- * // asNonZeroUint16(65536); // throws TypeError
- * ```
  */
 const asNonZeroUint16 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 16-bit non-zero unsigned integers.
- *
- * All operations automatically clamp results to the valid NonZeroUint16 range [1, 65535].
- * This ensures that all arithmetic maintains the 16-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 = asNonZeroUint16(60000);
- * const b = asNonZeroUint16(10000);
- *
- * // Arithmetic operations with automatic clamping and non-zero constraint
- * const sum = NonZeroUint16.add(a, b);       // NonZeroUint16 (65535 - clamped to MAX_VALUE)
- * const diff = NonZeroUint16.sub(a, b);      // NonZeroUint16 (50000)
- * const reverseDiff = NonZeroUint16.sub(b, a); // NonZeroUint16 (1 - clamped to MIN_VALUE)
- * const product = NonZeroUint16.mul(a, b);   // NonZeroUint16 (65535 - clamped due to overflow)
- *
- * // Range operations (maintaining non-zero constraint)
- * const clamped = NonZeroUint16.clamp(-100);     // NonZeroUint16 (1)
- * const minimum = NonZeroUint16.min(a, b);       // NonZeroUint16 (10000)
- * const maximum = NonZeroUint16.max(a, b);       // NonZeroUint16 (60000)
+ * Namespace providing type-safe arithmetic operations for 16-bit non-zero
+ * unsigned integers.
  *
- * // Utility operations
- * const random = NonZeroUint16.random();         // NonZeroUint16 (random value in [1, 65535])
- * const power = NonZeroUint16.pow(asNonZeroUint16(2), asNonZeroUint16(10)); // NonZeroUint16 (1024)
- * ```
+ * All operations automatically clamp results to the valid NonZeroUint16 range
+ * [1, 65535]. This ensures that all arithmetic maintains the 16-bit non-zero
+ * unsigned integer constraint, with results below 1 clamped to MIN_VALUE and
+ * overflow results clamped to MAX_VALUE.
  */
 const NonZeroUint16 = {
     /**
      * Type guard to check if a value is a NonZeroUint16.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 16-bit non-zero unsigned integer, `false` otherwise.
+     * @returns `true` if the value is a 16-bit non-zero unsigned integer, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for a 16-bit non-zero unsigned integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a 16-bit non-zero unsigned integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the smaller of two NonZeroUint16 values.
+     *
      * @param a The first NonZeroUint16.
      * @param b The second NonZeroUint16.
      * @returns The minimum value as a NonZeroUint16.
@@ -83,6 +64,7 @@ const NonZeroUint16 = {
     min: min_,
     /**
      * Returns the larger of two NonZeroUint16 values.
+     *
      * @param a The first NonZeroUint16.
      * @param b The second NonZeroUint16.
      * @returns The maximum value as a NonZeroUint16.
@@ -90,17 +72,20 @@ const NonZeroUint16 = {
     max: max_,
     /**
      * Clamps a number to the NonZeroUint16 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [1, 65535] as a NonZeroUint16.
      */
     clamp,
     /**
      * Generates a random NonZeroUint16 value within the valid range.
+     *
      * @returns A random NonZeroUint16 between 1 and 65535.
      */
     random,
     /**
      * Raises a NonZeroUint16 to the power of another NonZeroUint16.
+     *
      * @param a The base NonZeroUint16.
      * @param b The exponent NonZeroUint16.
      * @returns `a ** b` clamped to [1, 65535] as a NonZeroUint16.
@@ -108,6 +93,7 @@ const NonZeroUint16 = {
     pow,
     /**
      * Adds two NonZeroUint16 values.
+     *
      * @param a The first NonZeroUint16.
      * @param b The second NonZeroUint16.
      * @returns `a + b` clamped to [1, 65535] as a NonZeroUint16.
@@ -115,6 +101,7 @@ const NonZeroUint16 = {
     add,
     /**
      * Subtracts one NonZeroUint16 from another.
+     *
      * @param a The minuend NonZeroUint16.
      * @param b The subtrahend NonZeroUint16.
      * @returns `a - b` clamped to [1, 65535] as a NonZeroUint16 (minimum 1).
@@ -122,6 +109,7 @@ const NonZeroUint16 = {
     sub,
     /**
      * Multiplies two NonZeroUint16 values.
+     *
      * @param a The first NonZeroUint16.
      * @param b The second NonZeroUint16.
      * @returns `a * b` clamped to [1, 65535] as a NonZeroUint16.
@@ -129,6 +117,7 @@ const NonZeroUint16 = {
     mul,
     /**
      * Divides one NonZeroUint16 by another using floor division.
+     *
      * @param a The dividend NonZeroUint16.
      * @param b The divisor NonZeroUint16.
      * @returns `⌊a / b⌋` clamped to [1, 65535] as a NonZeroUint16.

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

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

@@ -1,22 +1,17 @@
 /**
- * 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.
  */
 export declare const isNonZeroUint32: (a: number) => a is PositiveUint32;
 /**
  * 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
- * ```
  */
 export declare const asNonZeroUint32: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -34,52 +29,38 @@ export declare const asNonZeroUint32: <N extends number>(x: N) => number & {
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
 /**
- * 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.
  */
 export declare 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.
      */
     readonly is: (a: number) => a is PositiveUint32;
     /**
      * The minimum value for a 32-bit non-zero unsigned integer.
+     *
      * @readonly
      */
     readonly MIN_VALUE: 1;
     /**
      * The maximum value for a 32-bit non-zero unsigned integer.
+     *
      * @readonly
      */
     readonly MAX_VALUE: number;
     /**
      * Returns the smaller of two NonZeroUint32 values.
+     *
      * @param a The first NonZeroUint32.
      * @param b The second NonZeroUint32.
      * @returns The minimum value as a NonZeroUint32.
@@ -87,6 +68,7 @@ export declare const NonZeroUint32: {
     readonly min: (...values: readonly WithSmallInt<PositiveUint32, 40>[]) => PositiveUint32;
     /**
      * Returns the larger of two NonZeroUint32 values.
+     *
      * @param a The first NonZeroUint32.
      * @param b The second NonZeroUint32.
      * @returns The maximum value as a NonZeroUint32.
@@ -94,17 +76,20 @@ export declare const NonZeroUint32: {
     readonly max: (...values: readonly WithSmallInt<PositiveUint32, 40>[]) => PositiveUint32;
     /**
      * Clamps a number to the NonZeroUint32 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [1, 4294967295] as a NonZeroUint32.
      */
     readonly clamp: (x: number) => PositiveUint32;
     /**
      * Generates a random NonZeroUint32 value within the valid range.
+     *
      * @returns A random NonZeroUint32 between 1 and 4294967295.
      */
     readonly random: (min?: WithSmallInt<PositiveUint32, 40> | undefined, max?: WithSmallInt<PositiveUint32, 40> | undefined) => PositiveUint32;
     /**
      * 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.
@@ -112,6 +97,7 @@ export declare const NonZeroUint32: {
     readonly pow: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
     /**
      * Adds two NonZeroUint32 values.
+     *
      * @param a The first NonZeroUint32.
      * @param b The second NonZeroUint32.
      * @returns `a + b` clamped to [1, 4294967295] as a NonZeroUint32.
@@ -119,6 +105,7 @@ export declare const NonZeroUint32: {
     readonly add: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
     /**
      * 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).
@@ -126,6 +113,7 @@ export declare const NonZeroUint32: {
     readonly sub: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
     /**
      * Multiplies two NonZeroUint32 values.
+     *
      * @param a The first NonZeroUint32.
      * @param b The second NonZeroUint32.
      * @returns `a * b` clamped to [1, 4294967295] as a NonZeroUint32.
@@ -133,6 +121,7 @@ export declare const NonZeroUint32: {
     readonly mul: (x: WithSmallInt<PositiveUint32, 40>, y: WithSmallInt<PositiveUint32, 40>) => PositiveUint32;
     /**
      * 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.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint32.mts"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH,eAAO,MAAM,eAAe,oCAAK,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":"non-zero-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint32.mts"],"names":[],"mappings":"AAiCA;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,oCAAK,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"}