ts-data-forge 9.0.0 → 9.0.1

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

@@ -1 +1 @@
-{"version":3,"file":"non-positive-safe-int.mjs","sources":["../../../src/number/branded-types/non-positive-safe-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAOA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;IACnC,SAAS,EAAE,MAAM,CAAC,gBAAgB;AAClC,IAAA,SAAS,EAAE,CAAC;IACZ,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,oBAAoB,GAAG;AAEpC;;;;;;AAMG;AACI,MAAM,oBAAoB,GAAG;AAEpC;;;;;;;;AAQG;AACI,MAAM,kBAAkB,GAAG;AAChC;;;;;;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;;;;;;AAMG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-positive-safe-int.mjs","sources":["../../../src/number/branded-types/non-positive-safe-int.mts"],"sourcesContent":["import { type NonPositiveSafeInt as TtfImported_NonPositiveSafeInt } from 'ts-type-forge';\nimport { TsDataForgeInternals } from '../refined-number-utils.mjs';\n\nexport type NonPositiveSafeInt = TtfImported_NonPositiveSafeInt;\n\ntype ElementType = NonPositiveSafeInt;\n\nconst typeNameInMessage = 'a non-positive safe integer';\n\nconst {\n  MAX_VALUE,\n  MIN_VALUE,\n  add,\n  castType,\n  clamp,\n  is,\n  max: max_,\n  min: min_,\n  pow,\n  random,\n  sub,\n} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<\n  ElementType,\n  number,\n  0\n>({\n  integerOrSafeInteger: 'SafeInteger',\n  MIN_VALUE: Number.MIN_SAFE_INTEGER,\n  MAX_VALUE: 0,\n  typeNameInMessage,\n} as const);\n\n/**\n * Checks if a number is a NonPositiveSafeInt (non-positive safe integer in the\n * range [Number.MIN_SAFE_INTEGER, 0]).\n *\n * @param value The value to check.\n * @returns `true` if the value is a NonPositiveSafeInt, `false` otherwise.\n */\nexport const isNonPositiveSafeInt = is;\n\n/**\n * Casts a number to a NonPositiveSafeInt type.\n *\n * @param value The value to cast.\n * @returns The value as a NonPositiveSafeInt type.\n * @throws {TypeError} If the value is not a non-positive safe integer.\n */\nexport const asNonPositiveSafeInt = castType;\n\n/**\n * Namespace providing type-safe arithmetic operations for non-positive\n * safe integers.\n *\n * All operations automatically clamp results to the valid NonPositiveSafeInt\n * range [Number.MIN_SAFE_INTEGER, 0]. This ensures that all arithmetic\n * maintains the non-positive safe integer constraint, with positive results\n * clamped to 0 and underflow results clamped to MIN_VALUE.\n */\nexport const NonPositiveSafeInt = {\n  /**\n   * Type guard to check if a value is a NonPositiveSafeInt.\n   *\n   * @param value The value to check.\n   * @returns `true` if the value is a non-positive safe integer, `false`\n   *   otherwise.\n   */\n  is,\n\n  /**\n   * The minimum value for a non-positive safe integer.\n   *\n   * @readonly\n   */\n  MIN_VALUE,\n\n  /**\n   * The maximum value for a non-positive safe integer.\n   *\n   * @readonly\n   */\n  MAX_VALUE,\n\n  /**\n   * Returns the smaller of two NonPositiveSafeInt values.\n   *\n   * @param a The first NonPositiveSafeInt.\n   * @param b The second NonPositiveSafeInt.\n   * @returns The minimum value as a NonPositiveSafeInt.\n   */\n  min: min_,\n\n  /**\n   * Returns the larger of two NonPositiveSafeInt values.\n   *\n   * @param a The first NonPositiveSafeInt.\n   * @param b The second NonPositiveSafeInt.\n   * @returns The maximum value as a NonPositiveSafeInt.\n   */\n  max: max_,\n\n  /**\n   * Clamps a number to the NonPositiveSafeInt range.\n   *\n   * @param value The number to clamp.\n   * @returns The value clamped to [Number.MIN_SAFE_INTEGER, 0] as a\n   *   NonPositiveSafeInt.\n   */\n  clamp,\n\n  /**\n   * Generates a random NonPositiveSafeInt value within the valid range.\n   *\n   * @returns A random NonPositiveSafeInt between Number.MIN_SAFE_INTEGER and 0.\n   */\n  random,\n\n  /**\n   * Raises a NonPositiveSafeInt to the power of another NonPositiveSafeInt.\n   *\n   * @param a The base NonPositiveSafeInt.\n   * @param b The exponent NonPositiveSafeInt.\n   * @returns `a ** b` clamped to [Number.MIN_SAFE_INTEGER, 0] as a\n   *   NonPositiveSafeInt.\n   */\n  pow,\n\n  /**\n   * Adds two NonPositiveSafeInt values.\n   *\n   * @param a The first NonPositiveSafeInt.\n   * @param b The second NonPositiveSafeInt.\n   * @returns `a + b` clamped to [Number.MIN_SAFE_INTEGER, 0] as a\n   *   NonPositiveSafeInt.\n   */\n  add,\n\n  /**\n   * Subtracts one NonPositiveSafeInt from another.\n   *\n   * @param a The minuend NonPositiveSafeInt.\n   * @param b The subtrahend NonPositiveSafeInt.\n   * @returns `a - b` clamped to [Number.MIN_SAFE_INTEGER, 0] as a\n   *   NonPositiveSafeInt (maximum 0).\n   */\n  sub,\n} as const;\n"],"names":[],"mappings":";;AAOA,MAAM,iBAAA,GAAoB,6BAAA;AAE1B,MAAM;AAAA,EACJ,SAAA;AAAA,EACA,SAAA;AAAA,EACA,GAAA;AAAA,EACA,QAAA;AAAA,EACA,KAAA;AAAA,EACA,EAAA;AAAA,EACA,GAAA,EAAK,IAAA;AAAA,EACL,GAAA,EAAK,IAAA;AAAA,EACL,GAAA;AAAA,EACA,MAAA;AAAA,EACA;AACF,CAAA,GAAI,oBAAA,CAAqB,mBAAmB,mBAAA,CAI1C;AAAA,EACA,oBAAA,EAAsB,aAAA;AAAA,EACtB,WAAW,MAAA,CAAO,gBAAA;AAAA,EAClB,SAAA,EAAW,CAAA;AAAA,EACX;AACF,CAAU,CAAA;AASH,MAAM,oBAAA,GAAuB;AAS7B,MAAM,oBAAA,GAAuB;AAW7B,MAAM,kBAAA,GAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQhC,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASL,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASL,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA;AACF;;;;"}

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

@@ -17,9 +17,9 @@ export declare const isNonZeroFiniteNumber: (a: number) => a is TtfImported_NonZ
  * @throws {TypeError} If the value is not a non-zero finite number.
  */
 export declare const asNonZeroFiniteNumber: <N extends number>(x: N) => number & {
-    readonly NaNValue: false;
-    readonly Finite: true;
     readonly "!=0": true;
+    readonly Finite: true;
+    readonly NaNValue: false;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
@@ -118,9 +118,9 @@ export declare const NonZeroFiniteNumber: {
      * @returns `a / b` as a NonZeroFiniteNumber.
      */
     readonly div: (x: TtfImported_NonZeroFiniteNumber, y: number & {
-        readonly NaNValue: false;
-        readonly Finite: true;
         readonly "!=0": true;
+        readonly Finite: true;
+        readonly NaNValue: false;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
     }>) => TtfImported_NonZeroFiniteNumber;

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

@@ -1,132 +1,123 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
-const typeNameInMessage = 'a non-zero finite number';
-const { abs, castType, div, is, max: max_, min: min_, mul, pow, randomNonZero: random, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
-    nonZero: true,
-    MIN_VALUE: -Number.MAX_VALUE,
-    MAX_VALUE: Number.MAX_VALUE,
-    typeNameInMessage,
+const typeNameInMessage = "a non-zero finite number";
+const {
+  abs,
+  castType,
+  div,
+  is,
+  max: max_,
+  min: min_,
+  mul,
+  pow,
+  randomNonZero: random
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
+  nonZero: true,
+  MIN_VALUE: -Number.MAX_VALUE,
+  MAX_VALUE: Number.MAX_VALUE,
+  typeNameInMessage
 });
-// Not provided because reasonable rounding operations that avoid becoming 0 cannot be defined
-const floor = (x) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-Math.floor(x);
-const ceil = (x) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-Math.ceil(x);
-const round = (x) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-Math.round(x);
-/**
- * Checks if a number is a NonZeroFiniteNumber (a finite number that is not 0).
- *
- * @param value The value to check.
- * @returns `true` if the value is a NonZeroFiniteNumber, `false` otherwise.
- */
+const floor = (x) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  Math.floor(x)
+);
+const ceil = (x) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  Math.ceil(x)
+);
+const round = (x) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  Math.round(x)
+);
 const isNonZeroFiniteNumber = is;
-/**
- * Casts a number to a NonZeroFiniteNumber type.
- *
- * @param value The value to cast.
- * @returns The value as a NonZeroFiniteNumber type.
- * @throws {TypeError} If the value is not a non-zero finite number.
- */
 const asNonZeroFiniteNumber = castType;
-/**
- * Namespace providing type-safe arithmetic operations for non-zero finite
- * numbers.
- *
- * All operations maintain the non-zero constraint while ensuring results remain
- * finite (excluding NaN and Infinity). This type is useful for values that must
- * never be zero, such as denominators, scaling factors, and ratios.
- */
 const NonZeroFiniteNumber = {
-    /**
-     * Type guard to check if a value is a NonZeroFiniteNumber.
-     *
-     * @param value The value to check.
-     * @returns `true` if the value is a non-zero finite number, `false`
-     *   otherwise.
-     */
-    is,
-    /**
-     * Returns the absolute value of a non-zero finite number.
-     *
-     * @param a The NonZeroFiniteNumber.
-     * @returns The absolute value as a NonZeroFiniteNumber.
-     */
-    abs,
-    /**
-     * Returns the smaller of two NonZeroFiniteNumber values.
-     *
-     * @param a The first NonZeroFiniteNumber.
-     * @param b The second NonZeroFiniteNumber.
-     * @returns The minimum value as a NonZeroFiniteNumber.
-     */
-    min: min_,
-    /**
-     * Returns the larger of two NonZeroFiniteNumber values.
-     *
-     * @param a The first NonZeroFiniteNumber.
-     * @param b The second NonZeroFiniteNumber.
-     * @returns The maximum value as a NonZeroFiniteNumber.
-     */
-    max: max_,
-    /**
-     * Rounds down a NonZeroFiniteNumber to the nearest integer.
-     *
-     * @param x The NonZeroFiniteNumber to round down.
-     * @returns The floor value as a NonZeroInt.
-     */
-    floor,
-    /**
-     * Rounds up a NonZeroFiniteNumber to the nearest integer.
-     *
-     * @param x The NonZeroFiniteNumber to round up.
-     * @returns The ceiling value as a NonZeroInt.
-     */
-    ceil,
-    /**
-     * Rounds a NonZeroFiniteNumber to the nearest integer.
-     *
-     * @param x The NonZeroFiniteNumber to round.
-     * @returns The rounded value as a NonZeroInt.
-     */
-    round,
-    /**
-     * Generates a random NonZeroFiniteNumber value.
-     *
-     * @returns A random non-zero finite number.
-     */
-    random,
-    /**
-     * Raises a NonZeroFiniteNumber to the power of another NonZeroFiniteNumber.
-     *
-     * @param a The base NonZeroFiniteNumber.
-     * @param b The exponent NonZeroFiniteNumber.
-     * @returns `a ** b` as a NonZeroFiniteNumber.
-     */
-    pow,
-    /**
-     * Multiplies two NonZeroFiniteNumber values.
-     *
-     * @param a The first NonZeroFiniteNumber.
-     * @param b The second NonZeroFiniteNumber.
-     * @returns `a * b` as a NonZeroFiniteNumber.
-     */
-    mul,
-    /**
-     * Divides one NonZeroFiniteNumber by another.
-     *
-     * Exact (non-flooring) division of two non-zero finite numbers is always
-     * non-zero, so this stays closed. For the non-closed operations (`add`/`sub`,
-     * whose result may be `0`) use {@link Num.add}/{@link Num.sub}.
-     *
-     * @param a The dividend NonZeroFiniteNumber.
-     * @param b The divisor NonZeroFiniteNumber.
-     * @returns `a / b` as a NonZeroFiniteNumber.
-     */
-    div,
+  /**
+   * Type guard to check if a value is a NonZeroFiniteNumber.
+   *
+   * @param value The value to check.
+   * @returns `true` if the value is a non-zero finite number, `false`
+   *   otherwise.
+   */
+  is,
+  /**
+   * Returns the absolute value of a non-zero finite number.
+   *
+   * @param a The NonZeroFiniteNumber.
+   * @returns The absolute value as a NonZeroFiniteNumber.
+   */
+  abs,
+  /**
+   * Returns the smaller of two NonZeroFiniteNumber values.
+   *
+   * @param a The first NonZeroFiniteNumber.
+   * @param b The second NonZeroFiniteNumber.
+   * @returns The minimum value as a NonZeroFiniteNumber.
+   */
+  min: min_,
+  /**
+   * Returns the larger of two NonZeroFiniteNumber values.
+   *
+   * @param a The first NonZeroFiniteNumber.
+   * @param b The second NonZeroFiniteNumber.
+   * @returns The maximum value as a NonZeroFiniteNumber.
+   */
+  max: max_,
+  /**
+   * Rounds down a NonZeroFiniteNumber to the nearest integer.
+   *
+   * @param x The NonZeroFiniteNumber to round down.
+   * @returns The floor value as a NonZeroInt.
+   */
+  floor,
+  /**
+   * Rounds up a NonZeroFiniteNumber to the nearest integer.
+   *
+   * @param x The NonZeroFiniteNumber to round up.
+   * @returns The ceiling value as a NonZeroInt.
+   */
+  ceil,
+  /**
+   * Rounds a NonZeroFiniteNumber to the nearest integer.
+   *
+   * @param x The NonZeroFiniteNumber to round.
+   * @returns The rounded value as a NonZeroInt.
+   */
+  round,
+  /**
+   * Generates a random NonZeroFiniteNumber value.
+   *
+   * @returns A random non-zero finite number.
+   */
+  random,
+  /**
+   * Raises a NonZeroFiniteNumber to the power of another NonZeroFiniteNumber.
+   *
+   * @param a The base NonZeroFiniteNumber.
+   * @param b The exponent NonZeroFiniteNumber.
+   * @returns `a ** b` as a NonZeroFiniteNumber.
+   */
+  pow,
+  /**
+   * Multiplies two NonZeroFiniteNumber values.
+   *
+   * @param a The first NonZeroFiniteNumber.
+   * @param b The second NonZeroFiniteNumber.
+   * @returns `a * b` as a NonZeroFiniteNumber.
+   */
+  mul,
+  /**
+   * Divides one NonZeroFiniteNumber by another.
+   *
+   * Exact (non-flooring) division of two non-zero finite numbers is always
+   * non-zero, so this stays closed. For the non-closed operations (`add`/`sub`,
+   * whose result may be `0`) use {@link Num.add}/{@link Num.sub}.
+   *
+   * @param a The dividend NonZeroFiniteNumber.
+   * @param b The divisor NonZeroFiniteNumber.
+   * @returns `a / b` as a NonZeroFiniteNumber.
+   */
+  div
 };
 
 export { NonZeroFiniteNumber, asNonZeroFiniteNumber, isNonZeroFiniteNumber };

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":";;AAaA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,GAAG,EACH,QAAQ,EACR,GAAG,EACH,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,GACtB,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;;;;;;;;;;AAUG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-zero-finite-number.mjs","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"sourcesContent":["import {\n  type Int,\n  type NonZeroInt,\n  type PositiveFiniteNumber,\n  type NonZeroFiniteNumber as TtfImported_NonZeroFiniteNumber,\n} from 'ts-type-forge';\nimport { expectType } from '../../expect-type.mjs';\nimport { TsDataForgeInternals } from '../refined-number-utils.mjs';\n\nexport type NonZeroFiniteNumber = TtfImported_NonZeroFiniteNumber;\n\ntype ElementType = NonZeroFiniteNumber;\n\nconst typeNameInMessage = 'a non-zero finite number';\n\nconst {\n  abs,\n  castType,\n  div,\n  is,\n  max: max_,\n  min: min_,\n  mul,\n  pow,\n  randomNonZero: random,\n} = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat<\n  ElementType,\n  number,\n  number\n>({\n  nonZero: true,\n  MIN_VALUE: -Number.MAX_VALUE,\n  MAX_VALUE: Number.MAX_VALUE,\n  typeNameInMessage,\n} as const);\n\n// Not provided because reasonable rounding operations that avoid becoming 0 cannot be defined\n\nconst floor = (\n  x: ElementType,\n): TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Math.floor(x) as TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;\n\nconst ceil = (\n  x: ElementType,\n): TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Math.ceil(x) as TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;\n\nconst round = (\n  x: ElementType,\n): TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Math.round(x) as TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;\n\nexpectType<\n  TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>,\n  NonZeroInt\n>('=');\n\nexpectType<\n  TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<\n    TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>\n  >,\n  Int\n>('=');\n\n/**\n * Checks if a number is a NonZeroFiniteNumber (a finite number that is not 0).\n *\n * @param value The value to check.\n * @returns `true` if the value is a NonZeroFiniteNumber, `false` otherwise.\n */\nexport const isNonZeroFiniteNumber = is;\n\n/**\n * Casts a number to a NonZeroFiniteNumber type.\n *\n * @param value The value to cast.\n * @returns The value as a NonZeroFiniteNumber type.\n * @throws {TypeError} If the value is not a non-zero finite number.\n */\nexport const asNonZeroFiniteNumber = castType;\n\n/**\n * Namespace providing type-safe arithmetic operations for non-zero finite\n * numbers.\n *\n * All operations maintain the non-zero constraint while ensuring results remain\n * finite (excluding NaN and Infinity). This type is useful for values that must\n * never be zero, such as denominators, scaling factors, and ratios.\n */\nexport const NonZeroFiniteNumber = {\n  /**\n   * Type guard to check if a value is a NonZeroFiniteNumber.\n   *\n   * @param value The value to check.\n   * @returns `true` if the value is a non-zero finite number, `false`\n   *   otherwise.\n   */\n  is,\n\n  /**\n   * Returns the absolute value of a non-zero finite number.\n   *\n   * @param a The NonZeroFiniteNumber.\n   * @returns The absolute value as a NonZeroFiniteNumber.\n   */\n  abs,\n\n  /**\n   * Returns the smaller of two NonZeroFiniteNumber values.\n   *\n   * @param a The first NonZeroFiniteNumber.\n   * @param b The second NonZeroFiniteNumber.\n   * @returns The minimum value as a NonZeroFiniteNumber.\n   */\n  min: min_,\n\n  /**\n   * Returns the larger of two NonZeroFiniteNumber values.\n   *\n   * @param a The first NonZeroFiniteNumber.\n   * @param b The second NonZeroFiniteNumber.\n   * @returns The maximum value as a NonZeroFiniteNumber.\n   */\n  max: max_,\n\n  /**\n   * Rounds down a NonZeroFiniteNumber to the nearest integer.\n   *\n   * @param x The NonZeroFiniteNumber to round down.\n   * @returns The floor value as a NonZeroInt.\n   */\n  floor,\n\n  /**\n   * Rounds up a NonZeroFiniteNumber to the nearest integer.\n   *\n   * @param x The NonZeroFiniteNumber to round up.\n   * @returns The ceiling value as a NonZeroInt.\n   */\n  ceil,\n\n  /**\n   * Rounds a NonZeroFiniteNumber to the nearest integer.\n   *\n   * @param x The NonZeroFiniteNumber to round.\n   * @returns The rounded value as a NonZeroInt.\n   */\n  round,\n\n  /**\n   * Generates a random NonZeroFiniteNumber value.\n   *\n   * @returns A random non-zero finite number.\n   */\n  random,\n\n  /**\n   * Raises a NonZeroFiniteNumber to the power of another NonZeroFiniteNumber.\n   *\n   * @param a The base NonZeroFiniteNumber.\n   * @param b The exponent NonZeroFiniteNumber.\n   * @returns `a ** b` as a NonZeroFiniteNumber.\n   */\n  pow,\n\n  /**\n   * Multiplies two NonZeroFiniteNumber values.\n   *\n   * @param a The first NonZeroFiniteNumber.\n   * @param b The second NonZeroFiniteNumber.\n   * @returns `a * b` as a NonZeroFiniteNumber.\n   */\n  mul,\n\n  /**\n   * Divides one NonZeroFiniteNumber by another.\n   *\n   * Exact (non-flooring) division of two non-zero finite numbers is always\n   * non-zero, so this stays closed. For the non-closed operations (`add`/`sub`,\n   * whose result may be `0`) use {@link Num.add}/{@link Num.sub}.\n   *\n   * @param a The dividend NonZeroFiniteNumber.\n   * @param b The divisor NonZeroFiniteNumber.\n   * @returns `a / b` as a NonZeroFiniteNumber.\n   */\n  div,\n} as const;\n\nexpectType<\n  TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<ElementType>,\n  PositiveFiniteNumber\n>('=');\n\nexpectType<\n  keyof typeof NonZeroFiniteNumber,\n  keyof TsDataForgeInternals.RefinedNumberUtils.NumberClass<\n    ElementType,\n    never,\n    'div' | 'mul'\n  >\n>('=');\n\nexpectType<\n  typeof NonZeroFiniteNumber,\n  TsDataForgeInternals.RefinedNumberUtils.NumberClass<\n    ElementType,\n    never,\n    'div' | 'mul'\n  >\n>('<=');\n"],"names":[],"mappings":";;AAaA,MAAM,iBAAA,GAAoB,0BAAA;AAE1B,MAAM;AAAA,EACJ,GAAA;AAAA,EACA,QAAA;AAAA,EACA,GAAA;AAAA,EACA,EAAA;AAAA,EACA,GAAA,EAAK,IAAA;AAAA,EACL,GAAA,EAAK,IAAA;AAAA,EACL,GAAA;AAAA,EACA,GAAA;AAAA,EACA,aAAA,EAAe;AACjB,CAAA,GAAI,oBAAA,CAAqB,mBAAmB,iBAAA,CAI1C;AAAA,EACA,OAAA,EAAS,IAAA;AAAA,EACT,SAAA,EAAW,CAAC,MAAA,CAAO,SAAA;AAAA,EACnB,WAAW,MAAA,CAAO,SAAA;AAAA,EAClB;AACF,CAAU,CAAA;AAIV,MAAM,QAAQ,CACZ,CAAA;AAAA;AAAA,EAGA,IAAA,CAAK,MAAM,CAAC;AAAA,CAAA;AAEd,MAAM,OAAO,CACX,CAAA;AAAA;AAAA,EAGA,IAAA,CAAK,KAAK,CAAC;AAAA,CAAA;AAEb,MAAM,QAAQ,CACZ,CAAA;AAAA;AAAA,EAGA,IAAA,CAAK,MAAM,CAAC;AAAA,CAAA;AAoBP,MAAM,qBAAA,GAAwB;AAS9B,MAAM,qBAAA,GAAwB;AAU9B,MAAM,mBAAA,GAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQjC,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASL,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQL,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA;AACF;;;;"}

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

@@ -15,10 +15,10 @@ export declare const isNonZeroInt: (a: number) => a is TtfImported_NonZeroInt;
  * @throws {TypeError} If the value is not a non-zero integer.
  */
 export declare const asNonZeroInt: <N extends number>(x: N) => number & {
-    readonly NaNValue: false;
+    readonly "!=0": true;
     readonly Finite: true;
     readonly Int: true;
-    readonly "!=0": true;
+    readonly NaNValue: false;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;

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

@@ -1,92 +1,81 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
-const typeNameInMessage = 'a non-zero integer';
-const { abs, castType, is, max: max_, min: min_, mul, pow, randomNonZero: random, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'Integer',
-    nonZero: true,
-    MIN_VALUE: -Number.MAX_VALUE,
-    MAX_VALUE: Number.MAX_VALUE,
-    typeNameInMessage,
+const typeNameInMessage = "a non-zero integer";
+const {
+  abs,
+  castType,
+  is,
+  max: max_,
+  min: min_,
+  mul,
+  pow,
+  randomNonZero: random
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
+  integerOrSafeInteger: "Integer",
+  nonZero: true,
+  MIN_VALUE: -Number.MAX_VALUE,
+  MAX_VALUE: Number.MAX_VALUE,
+  typeNameInMessage
 });
-/**
- * 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.
- */
 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.
- */
 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.
-     */
-    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.
-     */
-    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.
-     */
-    pow,
-    /**
-     * Multiplies two non-zero integers.
-     *
-     * The product of two non-zero integers is always non-zero, so this stays
-     * closed; for the non-closed operations (`add`/`sub`/`div`, whose result may
-     * be `0`) use {@link Num.add}/{@link Num.sub}/{@link Num.divInt}.
-     *
-     * @param a The first non-zero integer.
-     * @param b The second non-zero integer.
-     * @returns `a * b` as a NonZeroInt.
-     */
-    mul,
+  /**
+   * 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.
+   */
+  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.
+   */
+  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.
+   */
+  pow,
+  /**
+   * Multiplies two non-zero integers.
+   *
+   * The product of two non-zero integers is always non-zero, so this stays
+   * closed; for the non-closed operations (`add`/`sub`/`div`, whose result may
+   * be `0`) use {@link Num.add}/{@link Num.sub}/{@link Num.divInt}.
+   *
+   * @param a The first non-zero integer.
+   * @param b The second non-zero integer.
+   * @returns `a * b` as a NonZeroInt.
+   */
+  mul
 };
 
 export { NonZeroInt, asNonZeroInt, isNonZeroInt };

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":";;AAQA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,GAAG,EACH,QAAQ,EACR,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,GACtB,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;;;;;;;;;;AAUG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-zero-int.mjs","sources":["../../../src/number/branded-types/non-zero-int.mts"],"sourcesContent":["import { type NonZeroInt as TtfImported_NonZeroInt } from 'ts-type-forge';\nimport { expectType } from '../../expect-type.mjs';\nimport { TsDataForgeInternals } from '../refined-number-utils.mjs';\n\nexport type NonZeroInt = TtfImported_NonZeroInt;\n\ntype ElementType = NonZeroInt;\n\nconst typeNameInMessage = 'a non-zero integer';\n\nconst {\n  abs,\n  castType,\n  is,\n  max: max_,\n  min: min_,\n  mul,\n  pow,\n  randomNonZero: random,\n} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<\n  ElementType,\n  number,\n  number\n>({\n  integerOrSafeInteger: 'Integer',\n  nonZero: true,\n  MIN_VALUE: -Number.MAX_VALUE,\n  MAX_VALUE: Number.MAX_VALUE,\n  typeNameInMessage,\n} as const);\n\n/**\n * Checks if a number is a NonZeroInt.\n *\n * @param value The value to check.\n * @returns `true` if the value is a NonZeroInt, `false` otherwise.\n */\nexport const isNonZeroInt = is;\n\n/**\n * Casts a number to a NonZeroInt type.\n *\n * @param value The value to cast.\n * @returns The value as a NonZeroInt type.\n * @throws {TypeError} If the value is not a non-zero integer.\n */\nexport const asNonZeroInt = castType;\n\n/**\n * Namespace providing type-safe arithmetic operations for non-zero integers.\n *\n * All operations maintain the non-zero constraint, ensuring that results are\n * always valid NonZeroInt values. Division operations return floor division\n * results, and all arithmetic maintains integer precision.\n */\nexport const NonZeroInt = {\n  /**\n   * Type guard to check if a value is a NonZeroInt.\n   *\n   * @param value The value to check.\n   * @returns `true` if the value is a non-zero integer, `false` otherwise.\n   */\n  is,\n\n  /**\n   * Returns the absolute value of a non-zero integer.\n   *\n   * @param a The non-zero integer.\n   * @returns The absolute value as a NonZeroInt.\n   */\n  abs,\n\n  /**\n   * Returns the smaller of two non-zero integers.\n   *\n   * @param a The first non-zero integer.\n   * @param b The second non-zero integer.\n   * @returns The minimum value as a NonZeroInt.\n   */\n  min: min_,\n\n  /**\n   * Returns the larger of two non-zero integers.\n   *\n   * @param a The first non-zero integer.\n   * @param b The second non-zero integer.\n   * @returns The maximum value as a NonZeroInt.\n   */\n  max: max_,\n\n  /**\n   * Generates a random non-zero integer.\n   *\n   * @returns A random NonZeroInt value.\n   */\n  random,\n\n  /**\n   * Raises a non-zero integer to the power of another non-zero integer.\n   *\n   * @param a The base non-zero integer.\n   * @param b The exponent non-zero integer.\n   * @returns `a ** b` as a NonZeroInt.\n   */\n  pow,\n\n  /**\n   * Multiplies two non-zero integers.\n   *\n   * The product of two non-zero integers is always non-zero, so this stays\n   * closed; for the non-closed operations (`add`/`sub`/`div`, whose result may\n   * be `0`) use {@link Num.add}/{@link Num.sub}/{@link Num.divInt}.\n   *\n   * @param a The first non-zero integer.\n   * @param b The second non-zero integer.\n   * @returns `a * b` as a NonZeroInt.\n   */\n  mul,\n} as const;\n\nexpectType<\n  keyof typeof NonZeroInt,\n  keyof TsDataForgeInternals.RefinedNumberUtils.NumberClass<\n    ElementType,\n    'int',\n    'mul'\n  >\n>('=');\n\nexpectType<\n  typeof NonZeroInt,\n  TsDataForgeInternals.RefinedNumberUtils.NumberClass<ElementType, 'int', 'mul'>\n>('<=');\n"],"names":[],"mappings":";;AAQA,MAAM,iBAAA,GAAoB,oBAAA;AAE1B,MAAM;AAAA,EACJ,GAAA;AAAA,EACA,QAAA;AAAA,EACA,EAAA;AAAA,EACA,GAAA,EAAK,IAAA;AAAA,EACL,GAAA,EAAK,IAAA;AAAA,EACL,GAAA;AAAA,EACA,GAAA;AAAA,EACA,aAAA,EAAe;AACjB,CAAA,GAAI,oBAAA,CAAqB,mBAAmB,mBAAA,CAI1C;AAAA,EACA,oBAAA,EAAsB,SAAA;AAAA,EACtB,OAAA,EAAS,IAAA;AAAA,EACT,SAAA,EAAW,CAAC,MAAA,CAAO,SAAA;AAAA,EACnB,WAAW,MAAA,CAAO,SAAA;AAAA,EAClB;AACF,CAAU,CAAA;AAQH,MAAM,YAAA,GAAe;AASrB,MAAM,YAAA,GAAe;AASrB,MAAM,UAAA,GAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOxB,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASL,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOL,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA;AACF;;;;"}

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

@@ -16,18 +16,18 @@ export declare const isNonZeroInt16: (a: number) => a is TtfImported_NonZeroInt1
  * @throws {TypeError} If the value is not a non-zero integer in [-2^15, 2^15).
  */
 export declare const asNonZeroInt16: <N extends number>(x: N) => number & {
-    readonly NaNValue: false;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly "> -2^16": true;
-    readonly "> -2^32": true;
-    readonly ">= -2^15": true;
-    readonly ">= -2^31": true;
     readonly "!=0": true;
     readonly "< 2^15": true;
     readonly "< 2^16": true;
     readonly "< 2^31": true;
     readonly "< 2^32": true;
+    readonly "> -2^16": true;
+    readonly "> -2^32": true;
+    readonly ">= -2^15": true;
+    readonly ">= -2^31": true;
+    readonly Finite: true;
+    readonly Int: true;
+    readonly NaNValue: false;
     readonly SafeInt: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;