ts-data-forge 3.2.0 → 3.3.1

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-finite-number.mjs","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,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,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;AAEA,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;AAc7E;;;;AAIG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;;;AAYG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACI,MAAM,mBAAmB,GAAG;AACjC;;;;AAIG;IACH,EAAE;AAEF;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;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-zero-finite-number.mjs","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,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,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;AAEA,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;AAc7E;;;;;AAKG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;AAMG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;AAOG;AACI,MAAM,mBAAmB,GAAG;AACjC;;;;;;AAMG;IACH,EAAE;AAEF;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,IAAI;AAEJ;;;;;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-int.d.mts

@@ -1,22 +1,17 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
  * Checks if a number is a NonZeroInt.
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt, `false` otherwise.
  */
 export declare const isNonZeroInt: (a: number) => a is NonZeroInt;
 /**
  * Casts a number to a NonZeroInt type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroInt type.
  * @throws {TypeError} If the value is not a non-zero integer.
- * @example
- * ```typescript
- * const x = asNonZeroInt(5); // NonZeroInt
- * const y = asNonZeroInt(-3); // NonZeroInt
- * // asNonZeroInt(0); // throws TypeError
- * // asNonZeroInt(1.5); // throws TypeError
- * ```
  */
 export declare const asNonZeroInt: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -29,45 +24,28 @@ export declare const asNonZeroInt: <N extends number>(x: N) => number & {
 /**
  * Namespace providing type-safe arithmetic operations for non-zero integers.
  *
- * All operations maintain the non-zero constraint, ensuring that results are always valid NonZeroInt values.
- * Division operations return floor division results, and all arithmetic maintains integer precision.
- *
- * @example
- * ```typescript
- * const a = asNonZeroInt(10);
- * const b = asNonZeroInt(-5);
- *
- * // Arithmetic operations
- * const sum = NonZeroInt.add(a, b);     // NonZeroInt (5)
- * const diff = NonZeroInt.sub(a, b);    // NonZeroInt (15)
- * const product = NonZeroInt.mul(a, b); // NonZeroInt (-50)
- * const quotient = NonZeroInt.div(a, b); // NonZeroInt (-2)
- *
- * // Utility operations
- * const absolute = NonZeroInt.abs(b);   // NonZeroInt (5)
- * const power = NonZeroInt.pow(a, asNonZeroInt(2)); // NonZeroInt (100)
- * const minimum = NonZeroInt.min(a, b); // NonZeroInt (-5)
- * const maximum = NonZeroInt(a, b); // NonZeroInt (10)
- *
- * // Random generation
- * const randomInt = NonZeroInt.random(); // NonZeroInt (random non-zero integer)
- * ```
+ * All operations maintain the non-zero constraint, ensuring that results are
+ * always valid NonZeroInt values. Division operations return floor division
+ * results, and all arithmetic maintains integer precision.
  */
 export declare const NonZeroInt: {
     /**
      * Type guard to check if a value is a NonZeroInt.
+     *
      * @param value The value to check.
      * @returns `true` if the value is a non-zero integer, `false` otherwise.
      */
     readonly is: (a: number) => a is NonZeroInt;
     /**
      * Returns the absolute value of a non-zero integer.
+     *
      * @param a The non-zero integer.
      * @returns The absolute value as a NonZeroInt.
      */
     readonly abs: (x: WithSmallInt<NonZeroInt, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt>;
     /**
      * Returns the smaller of two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns The minimum value as a NonZeroInt.
@@ -75,6 +53,7 @@ export declare const NonZeroInt: {
     readonly min: (...values: readonly WithSmallInt<NonZeroInt, 40>[]) => NonZeroInt;
     /**
      * Returns the larger of two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns The maximum value as a NonZeroInt.
@@ -82,11 +61,13 @@ export declare const NonZeroInt: {
     readonly max: (...values: readonly WithSmallInt<NonZeroInt, 40>[]) => NonZeroInt;
     /**
      * Generates a random non-zero integer.
+     *
      * @returns A random NonZeroInt value.
      */
     readonly random: (min?: WithSmallInt<NonZeroInt, 40> | undefined, max?: WithSmallInt<NonZeroInt, 40> | undefined) => NonZeroInt;
     /**
      * Raises a non-zero integer to the power of another non-zero integer.
+     *
      * @param a The base non-zero integer.
      * @param b The exponent non-zero integer.
      * @returns `a ** b` as a NonZeroInt.
@@ -94,6 +75,7 @@ export declare const NonZeroInt: {
     readonly pow: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
     /**
      * Adds two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns `a + b` as a NonZeroInt.
@@ -101,6 +83,7 @@ export declare const NonZeroInt: {
     readonly add: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
     /**
      * Subtracts one non-zero integer from another.
+     *
      * @param a The minuend non-zero integer.
      * @param b The subtrahend non-zero integer.
      * @returns `a - b` as a NonZeroInt.
@@ -108,6 +91,7 @@ export declare const NonZeroInt: {
     readonly sub: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
     /**
      * Multiplies two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns `a * b` as a NonZeroInt.
@@ -115,6 +99,7 @@ export declare const NonZeroInt: {
     readonly mul: (x: WithSmallInt<NonZeroInt, 40>, y: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
     /**
      * Divides one non-zero integer by another using floor division.
+     *
      * @param a The dividend non-zero integer.
      * @param b The divisor non-zero integer.
      * @returns `⌊a / b⌋` as a NonZeroInt.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA8BnE;;;;GAIG;AACH,eAAO,MAAM,YAAY,gCAAK,CAAC;AAE/B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,UAAU;IACrB;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA8BnE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,gCAAK,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,UAAU;IACrB;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;CAEK,CAAC"}

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

@@ -10,66 +10,44 @@ const { abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: rando
 });
 /**
  * Checks if a number is a NonZeroInt.
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt, `false` otherwise.
  */
 const isNonZeroInt = is;
 /**
  * Casts a number to a NonZeroInt type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroInt type.
  * @throws {TypeError} If the value is not a non-zero integer.
- * @example
- * ```typescript
- * const x = asNonZeroInt(5); // NonZeroInt
- * const y = asNonZeroInt(-3); // NonZeroInt
- * // asNonZeroInt(0); // throws TypeError
- * // asNonZeroInt(1.5); // throws TypeError
- * ```
  */
 const asNonZeroInt = castType;
 /**
  * Namespace providing type-safe arithmetic operations for non-zero integers.
  *
- * All operations maintain the non-zero constraint, ensuring that results are always valid NonZeroInt values.
- * Division operations return floor division results, and all arithmetic maintains integer precision.
- *
- * @example
- * ```typescript
- * const a = asNonZeroInt(10);
- * const b = asNonZeroInt(-5);
- *
- * // Arithmetic operations
- * const sum = NonZeroInt.add(a, b);     // NonZeroInt (5)
- * const diff = NonZeroInt.sub(a, b);    // NonZeroInt (15)
- * const product = NonZeroInt.mul(a, b); // NonZeroInt (-50)
- * const quotient = NonZeroInt.div(a, b); // NonZeroInt (-2)
- *
- * // Utility operations
- * const absolute = NonZeroInt.abs(b);   // NonZeroInt (5)
- * const power = NonZeroInt.pow(a, asNonZeroInt(2)); // NonZeroInt (100)
- * const minimum = NonZeroInt.min(a, b); // NonZeroInt (-5)
- * const maximum = NonZeroInt(a, b); // NonZeroInt (10)
- *
- * // Random generation
- * const randomInt = NonZeroInt.random(); // NonZeroInt (random non-zero integer)
- * ```
+ * All operations maintain the non-zero constraint, ensuring that results are
+ * always valid NonZeroInt values. Division operations return floor division
+ * results, and all arithmetic maintains integer precision.
  */
 const NonZeroInt = {
     /**
      * Type guard to check if a value is a NonZeroInt.
+     *
      * @param value The value to check.
      * @returns `true` if the value is a non-zero integer, `false` otherwise.
      */
     is,
     /**
      * Returns the absolute value of a non-zero integer.
+     *
      * @param a The non-zero integer.
      * @returns The absolute value as a NonZeroInt.
      */
     abs,
     /**
      * Returns the smaller of two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns The minimum value as a NonZeroInt.
@@ -77,6 +55,7 @@ const NonZeroInt = {
     min: min_,
     /**
      * Returns the larger of two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns The maximum value as a NonZeroInt.
@@ -84,11 +63,13 @@ const NonZeroInt = {
     max: max_,
     /**
      * Generates a random non-zero integer.
+     *
      * @returns A random NonZeroInt value.
      */
     random,
     /**
      * Raises a non-zero integer to the power of another non-zero integer.
+     *
      * @param a The base non-zero integer.
      * @param b The exponent non-zero integer.
      * @returns `a ** b` as a NonZeroInt.
@@ -96,6 +77,7 @@ const NonZeroInt = {
     pow,
     /**
      * Adds two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns `a + b` as a NonZeroInt.
@@ -103,6 +85,7 @@ const NonZeroInt = {
     add,
     /**
      * Subtracts one non-zero integer from another.
+     *
      * @param a The minuend non-zero integer.
      * @param b The subtrahend non-zero integer.
      * @returns `a - b` as a NonZeroInt.
@@ -110,6 +93,7 @@ const NonZeroInt = {
     sub,
     /**
      * Multiplies two non-zero integers.
+     *
      * @param a The first non-zero integer.
      * @param b The second non-zero integer.
      * @returns `a * b` as a NonZeroInt.
@@ -117,6 +101,7 @@ const NonZeroInt = {
     mul,
     /**
      * Divides one non-zero integer by another using floor division.
+     *
      * @param a The dividend non-zero integer.
      * @param b The divisor non-zero integer.
      * @returns `⌊a / b⌋` as a NonZeroInt.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int.mjs","sources":["../../../src/number/branded-types/non-zero-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,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,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;;;;;;;AAYG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,UAAU,GAAG;AACxB;;;;AAIG;IACH,EAAE;AAEF;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;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-int.mjs","sources":["../../../src/number/branded-types/non-zero-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,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,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;AAKG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;AAMG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;AAMG;AACI,MAAM,UAAU,GAAG;AACxB;;;;;AAKG;IACH,EAAE;AAEF;;;;;AAKG;IACH,GAAG;AAEH;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;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-int16.d.mts

@@ -1,22 +1,18 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
- * Checks if a number is a NonZeroInt16 (16-bit non-zero signed integer in the range [-2^15, 2^15) excluding 0).
+ * Checks if a number is a NonZeroInt16 (16-bit non-zero signed integer in the
+ * range [-2^15, 2^15) excluding 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt16, `false` otherwise.
  */
 export declare const isNonZeroInt16: (a: number) => a is NonZeroInt16;
 /**
  * Casts a number to a NonZeroInt16 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroInt16 type.
  * @throws {TypeError} If the value is not a non-zero integer in [-2^15, 2^15).
- * @example
- * ```typescript
- * const x = asNonZeroInt16(1000); // NonZeroInt16
- * const y = asNonZeroInt16(-1000); // NonZeroInt16
- * // asNonZeroInt16(0); // throws TypeError
- * // asNonZeroInt16(32768); // throws TypeError
- * ```
  */
 export declare const asNonZeroInt16: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
@@ -36,58 +32,45 @@ export declare const asNonZeroInt16: <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 signed integers.
- *
- * All operations automatically clamp results to the valid NonZeroInt16 range [-32768, 32767]
- * excluding 0. This ensures that all arithmetic maintains the 16-bit non-zero signed integer
- * constraint, preventing zero results and overflow.
- *
- * @example
- * ```typescript
- * const a = asNonZeroInt16(30000);
- * const b = asNonZeroInt16(-10000);
- *
- * // Arithmetic operations with automatic clamping and non-zero constraint
- * const sum = NonZeroInt16.add(a, b);       // NonZeroInt16 (20000)
- * const diff = NonZeroInt16.sub(a, b);      // NonZeroInt16 (32767 - clamped to MAX_VALUE)
- * const product = NonZeroInt16.mul(a, b);   // NonZeroInt16 (-32768 - clamped to MIN_VALUE)
- *
- * // Utility operations
- * const absolute = NonZeroInt16.abs(b);         // NonZeroInt16 (10000)
- * const minimum = NonZeroInt16.min(a, b);       // NonZeroInt16 (-10000)
- * const maximum = NonZeroInt16.max(a, b);       // NonZeroInt16 (30000)
+ * Namespace providing type-safe arithmetic operations for 16-bit non-zero
+ * signed integers.
  *
- * // Range operations (avoiding zero)
- * const clamped = NonZeroInt16.clamp(0);        // NonZeroInt16 (1 or -1, avoiding zero)
- * const random = NonZeroInt16.random();         // NonZeroInt16 (random non-zero value in range)
- * const power = NonZeroInt16.pow(asNonZeroInt16(2), asNonZeroInt16(10)); // NonZeroInt16 (1024)
- * ```
+ * All operations automatically clamp results to the valid NonZeroInt16 range
+ * [-32768, 32767] excluding 0. This ensures that all arithmetic maintains the
+ * 16-bit non-zero signed integer constraint, preventing zero results and
+ * overflow.
  */
 export declare const NonZeroInt16: {
     /**
      * Type guard to check if a value is a NonZeroInt16.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 16-bit non-zero signed integer, `false` otherwise.
+     * @returns `true` if the value is a 16-bit non-zero signed integer, `false`
+     *   otherwise.
      */
     readonly is: (a: number) => a is NonZeroInt16;
     /**
      * The minimum value for a 16-bit non-zero signed integer.
+     *
      * @readonly
      */
     readonly MIN_VALUE: number;
     /**
      * The maximum value for a 16-bit non-zero signed integer.
+     *
      * @readonly
      */
     readonly MAX_VALUE: number;
     /**
      * Returns the absolute value of a 16-bit non-zero signed integer.
+     *
      * @param a The NonZeroInt16 value.
      * @returns The absolute value as a NonZeroInt16, clamped to valid range.
      */
     readonly abs: (x: WithSmallInt<NonZeroInt16, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt16>;
     /**
      * Returns the smaller of two NonZeroInt16 values.
+     *
      * @param a The first NonZeroInt16.
      * @param b The second NonZeroInt16.
      * @returns The minimum value as a NonZeroInt16.
@@ -95,6 +78,7 @@ export declare const NonZeroInt16: {
     readonly min: (...values: readonly WithSmallInt<NonZeroInt16, 40>[]) => NonZeroInt16;
     /**
      * Returns the larger of two NonZeroInt16 values.
+     *
      * @param a The first NonZeroInt16.
      * @param b The second NonZeroInt16.
      * @returns The maximum value as a NonZeroInt16.
@@ -102,17 +86,21 @@ export declare const NonZeroInt16: {
     readonly max: (...values: readonly WithSmallInt<NonZeroInt16, 40>[]) => NonZeroInt16;
     /**
      * Clamps a number to the NonZeroInt16 range (avoiding zero).
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [-32768, 32767] \ {0} as a NonZeroInt16.
      */
     readonly clamp: (x: number) => NonZeroInt16;
     /**
      * Generates a random NonZeroInt16 value within the valid range.
-     * @returns A random NonZeroInt16 between MIN_VALUE and MAX_VALUE (excluding 0).
+     *
+     * @returns A random NonZeroInt16 between MIN_VALUE and MAX_VALUE (excluding
+     *   0).
      */
     readonly random: (min?: WithSmallInt<NonZeroInt16, 40> | undefined, max?: WithSmallInt<NonZeroInt16, 40> | undefined) => NonZeroInt16;
     /**
      * Raises a NonZeroInt16 to the power of another NonZeroInt16.
+     *
      * @param a The base NonZeroInt16.
      * @param b The exponent NonZeroInt16.
      * @returns `a ** b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -120,6 +108,7 @@ export declare const NonZeroInt16: {
     readonly pow: (x: WithSmallInt<NonZeroInt16, 40>, y: WithSmallInt<NonZeroInt16, 40>) => NonZeroInt16;
     /**
      * Adds two NonZeroInt16 values.
+     *
      * @param a The first NonZeroInt16.
      * @param b The second NonZeroInt16.
      * @returns `a + b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -127,6 +116,7 @@ export declare const NonZeroInt16: {
     readonly add: (x: WithSmallInt<NonZeroInt16, 40>, y: WithSmallInt<NonZeroInt16, 40>) => NonZeroInt16;
     /**
      * Subtracts one NonZeroInt16 from another.
+     *
      * @param a The minuend NonZeroInt16.
      * @param b The subtrahend NonZeroInt16.
      * @returns `a - b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -134,6 +124,7 @@ export declare const NonZeroInt16: {
     readonly sub: (x: WithSmallInt<NonZeroInt16, 40>, y: WithSmallInt<NonZeroInt16, 40>) => NonZeroInt16;
     /**
      * Multiplies two NonZeroInt16 values.
+     *
      * @param a The first NonZeroInt16.
      * @param b The second NonZeroInt16.
      * @returns `a * b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -141,6 +132,7 @@ export declare const NonZeroInt16: {
     readonly mul: (x: WithSmallInt<NonZeroInt16, 40>, y: WithSmallInt<NonZeroInt16, 40>) => NonZeroInt16;
     /**
      * Divides one NonZeroInt16 by another using floor division.
+     *
      * @param a The dividend NonZeroInt16.
      * @param b The divisor NonZeroInt16.
      * @returns `⌊a / b⌋` clamped to [-32768, 32767] as a NonZeroInt16.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAiCnE;;;;GAIG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,YAAY;IACvB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;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-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAiCnE;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -9,78 +9,61 @@ const { MIN_VALUE, MAX_VALUE, abs, min: min_, max: max_, pow, add, sub, mul, div
     typeNameInMessage,
 });
 /**
- * Checks if a number is a NonZeroInt16 (16-bit non-zero signed integer in the range [-2^15, 2^15) excluding 0).
+ * Checks if a number is a NonZeroInt16 (16-bit non-zero signed integer in the
+ * range [-2^15, 2^15) excluding 0).
+ *
  * @param value The value to check.
  * @returns `true` if the value is a NonZeroInt16, `false` otherwise.
  */
 const isNonZeroInt16 = is;
 /**
  * Casts a number to a NonZeroInt16 type.
+ *
  * @param value The value to cast.
  * @returns The value as a NonZeroInt16 type.
  * @throws {TypeError} If the value is not a non-zero integer in [-2^15, 2^15).
- * @example
- * ```typescript
- * const x = asNonZeroInt16(1000); // NonZeroInt16
- * const y = asNonZeroInt16(-1000); // NonZeroInt16
- * // asNonZeroInt16(0); // throws TypeError
- * // asNonZeroInt16(32768); // throws TypeError
- * ```
  */
 const asNonZeroInt16 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 16-bit non-zero signed integers.
- *
- * All operations automatically clamp results to the valid NonZeroInt16 range [-32768, 32767]
- * excluding 0. This ensures that all arithmetic maintains the 16-bit non-zero signed integer
- * constraint, preventing zero results and overflow.
- *
- * @example
- * ```typescript
- * const a = asNonZeroInt16(30000);
- * const b = asNonZeroInt16(-10000);
- *
- * // Arithmetic operations with automatic clamping and non-zero constraint
- * const sum = NonZeroInt16.add(a, b);       // NonZeroInt16 (20000)
- * const diff = NonZeroInt16.sub(a, b);      // NonZeroInt16 (32767 - clamped to MAX_VALUE)
- * const product = NonZeroInt16.mul(a, b);   // NonZeroInt16 (-32768 - clamped to MIN_VALUE)
- *
- * // Utility operations
- * const absolute = NonZeroInt16.abs(b);         // NonZeroInt16 (10000)
- * const minimum = NonZeroInt16.min(a, b);       // NonZeroInt16 (-10000)
- * const maximum = NonZeroInt16.max(a, b);       // NonZeroInt16 (30000)
+ * Namespace providing type-safe arithmetic operations for 16-bit non-zero
+ * signed integers.
  *
- * // Range operations (avoiding zero)
- * const clamped = NonZeroInt16.clamp(0);        // NonZeroInt16 (1 or -1, avoiding zero)
- * const random = NonZeroInt16.random();         // NonZeroInt16 (random non-zero value in range)
- * const power = NonZeroInt16.pow(asNonZeroInt16(2), asNonZeroInt16(10)); // NonZeroInt16 (1024)
- * ```
+ * All operations automatically clamp results to the valid NonZeroInt16 range
+ * [-32768, 32767] excluding 0. This ensures that all arithmetic maintains the
+ * 16-bit non-zero signed integer constraint, preventing zero results and
+ * overflow.
  */
 const NonZeroInt16 = {
     /**
      * Type guard to check if a value is a NonZeroInt16.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is a 16-bit non-zero signed integer, `false` otherwise.
+     * @returns `true` if the value is a 16-bit non-zero signed integer, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for a 16-bit non-zero signed integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for a 16-bit non-zero signed integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the absolute value of a 16-bit non-zero signed integer.
+     *
      * @param a The NonZeroInt16 value.
      * @returns The absolute value as a NonZeroInt16, clamped to valid range.
      */
     abs,
     /**
      * Returns the smaller of two NonZeroInt16 values.
+     *
      * @param a The first NonZeroInt16.
      * @param b The second NonZeroInt16.
      * @returns The minimum value as a NonZeroInt16.
@@ -88,6 +71,7 @@ const NonZeroInt16 = {
     min: min_,
     /**
      * Returns the larger of two NonZeroInt16 values.
+     *
      * @param a The first NonZeroInt16.
      * @param b The second NonZeroInt16.
      * @returns The maximum value as a NonZeroInt16.
@@ -95,17 +79,21 @@ const NonZeroInt16 = {
     max: max_,
     /**
      * Clamps a number to the NonZeroInt16 range (avoiding zero).
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [-32768, 32767] \ {0} as a NonZeroInt16.
      */
     clamp,
     /**
      * Generates a random NonZeroInt16 value within the valid range.
-     * @returns A random NonZeroInt16 between MIN_VALUE and MAX_VALUE (excluding 0).
+     *
+     * @returns A random NonZeroInt16 between MIN_VALUE and MAX_VALUE (excluding
+     *   0).
      */
     random,
     /**
      * Raises a NonZeroInt16 to the power of another NonZeroInt16.
+     *
      * @param a The base NonZeroInt16.
      * @param b The exponent NonZeroInt16.
      * @returns `a ** b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -113,6 +101,7 @@ const NonZeroInt16 = {
     pow,
     /**
      * Adds two NonZeroInt16 values.
+     *
      * @param a The first NonZeroInt16.
      * @param b The second NonZeroInt16.
      * @returns `a + b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -120,6 +109,7 @@ const NonZeroInt16 = {
     add,
     /**
      * Subtracts one NonZeroInt16 from another.
+     *
      * @param a The minuend NonZeroInt16.
      * @param b The subtrahend NonZeroInt16.
      * @returns `a - b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -127,6 +117,7 @@ const NonZeroInt16 = {
     sub,
     /**
      * Multiplies two NonZeroInt16 values.
+     *
      * @param a The first NonZeroInt16.
      * @param b The second NonZeroInt16.
      * @returns `a * b` clamped to [-32768, 32767] as a NonZeroInt16.
@@ -134,6 +125,7 @@ const NonZeroInt16 = {
     mul,
     /**
      * Divides one NonZeroInt16 by another using floor division.
+     *
      * @param a The dividend NonZeroInt16.
      * @param b The divisor NonZeroInt16.
      * @returns `⌊a / b⌋` clamped to [-32768, 32767] as a NonZeroInt16.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int16.mjs","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,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;AACb,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;AAYG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;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-int16.mjs","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,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;AACb,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;AAMG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;AAQG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;AAMG;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;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}