ts-data-forge 14.10.2 → 14.11.1

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

@@ -9,7 +9,7 @@ export type NonPositiveSafeInt = TtfImported_NonPositiveSafeInt;
  * @param value - The value to check
  * @returns `true` if the value is a non-positive safe integer, `false` otherwise
  */
-export declare const isNonPositiveSafeInt: (a: number) => a is TtfImported_NonPositiveSafeInt;
+export declare const isNonPositiveSafeInt: (value: number) => value is NonPositiveSafeInt;
 /**
  * Casts a `number` to the `NonPositiveSafeInt` branded type.
  *
@@ -20,19 +20,7 @@ export declare const isNonPositiveSafeInt: (a: number) => a is TtfImported_NonPo
  * @returns The value as a `NonPositiveSafeInt`
  * @throws {TypeError} If the value is not a non-positive safe integer
  */
-export declare const asNonPositiveSafeInt: <N extends number>(x: N) => number & {
-    readonly "< 2^15": true;
-    readonly "< 2^16": true;
-    readonly "< 2^31": true;
-    readonly "< 2^32": true;
-    readonly "<=0": true;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-    readonly SafeInt: true;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asNonPositiveSafeInt: <N extends number>(value: N) => NonPositiveSafeInt & N;
 /**
  * Namespace providing type-safe operations for the `NonPositiveSafeInt` branded
  * type.
@@ -48,7 +36,7 @@ export declare const NonPositiveSafeInt: {
      * @returns `true` if the value is a non-positive safe integer, `false` otherwise
      * @see {@link isNonPositiveSafeInt} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NonPositiveSafeInt;
+    readonly is: typeof isNonPositiveSafeInt;
     /**
      * The smallest value representable as `NonPositiveSafeInt` (the lower
      * saturation target of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"non-positive-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,IAAI,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAG1F,MAAM,MAAM,kBAAkB,GAAG,8BAA8B,CAAC;AA6BhE;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,oDAAK,CAAC;AAEvC;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;MAAW,CAAC;AAE7C;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}
+{"version":3,"file":"non-positive-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,IAAI,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAa1F,MAAM,MAAM,kBAAkB,GAAG,8BAA8B,CAAC;AAIhE;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,UACxB,MAAM,KACZ,KAAK,IAAI,kBAA+D,CAAC;AAE5E;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,MAAM,SAC5C,CAAC,KACP,kBAAkB,GAAG,CAMvB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

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

@@ -1,11 +1,5 @@
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, MIN_VALUE, add, fromNumber, max as max_, min as min_, pow, random, sub, } from '../operators/non-positive-safe-int.mjs';
 const typeNameInMessage = 'a non-positive safe integer';
-const { MAX_VALUE, MIN_VALUE, add, castType, fromNumber, is, max: max_, min: min_, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    MIN_VALUE: Number.MIN_SAFE_INTEGER,
-    MAX_VALUE: 0,
-    typeNameInMessage,
-});
 
 
 
@@ -15,7 +9,7 @@ const { MAX_VALUE, MIN_VALUE, add, castType, fromNumber, is, max: max_, min: min
 
 
 
-export const isNonPositiveSafeInt = is;
+export const isNonPositiveSafeInt = (value) => Number.isSafeInteger(value) && value <= 0;
 
 
 
@@ -26,7 +20,12 @@ export const isNonPositiveSafeInt = is;
 
 
 
-export const asNonPositiveSafeInt = castType;
+export const asNonPositiveSafeInt = (value) => {
+    if (!isNonPositiveSafeInt(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -42,7 +41,7 @@ export const NonPositiveSafeInt = {
 
 
 
-    is,
+    is: isNonPositiveSafeInt,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"non-positive-safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,6BAA6B,CAAC;AAExD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,aAAa;IACnC,SAAS,EAAE,MAAM,CAAC,gBAAgB;IAClC,SAAS,EAAE,CAAC;IACZ,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AAEvC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,QAAQ,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;OAWG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC"}
+{"version":3,"file":"non-positive-safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,wCAAwC,CAAC;AAIhD,MAAM,iBAAiB,GAAG,6BAA6B,CAAC;AAExD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,KAAa,EACgB,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AAE5E;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,KAAQ,EACgB,EAAE;IAC1B,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC;;;;;;OAMG;IACH,EAAE,EAAE,oBAAoB;IAExB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;OAWG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC"}

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

@@ -1,5 +1,5 @@
 import type { NonZeroFiniteNumber as TtfImported_NonZeroFiniteNumber } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type NonZeroFiniteNumber = TtfImported_NonZeroFiniteNumber;
 type ElementType = NonZeroFiniteNumber;
 declare const floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
@@ -14,7 +14,7 @@ declare const round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils
  * @param value - The value to check
  * @returns `true` if the value is a non-zero finite number, `false` otherwise
  */
-export declare const isNonZeroFiniteNumber: (a: number) => a is TtfImported_NonZeroFiniteNumber;
+export declare const isNonZeroFiniteNumber: (value: number) => value is NonZeroFiniteNumber;
 /**
  * Casts a `number` to the `NonZeroFiniteNumber` branded type.
  *
@@ -25,13 +25,7 @@ export declare const isNonZeroFiniteNumber: (a: number) => a is TtfImported_NonZ
  * @returns The value as a `NonZeroFiniteNumber`
  * @throws {TypeError} If the value is not a non-zero finite number
  */
-export declare const asNonZeroFiniteNumber: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly Finite: true;
-    readonly NaNValue: false;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asNonZeroFiniteNumber: <N extends number>(value: N) => NonZeroFiniteNumber & N;
 /**
  * Namespace providing type-safe operations for the `NonZeroFiniteNumber`
  * branded type.
@@ -46,7 +40,7 @@ export declare const NonZeroFiniteNumber: {
      * @returns `true` if the value is a non-zero finite number, `false` otherwise
      * @see {@link isNonZeroFiniteNumber} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NonZeroFiniteNumber;
+    readonly is: typeof isNonZeroFiniteNumber;
     /**
      * Returns the absolute value of a non-zero finite number.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,mBAAmB,IAAI,+BAA+B,EACvD,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,mBAAmB,GAAG,+BAA+B,CAAC;AAElE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AAyBvC,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAc9E;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,qDAAK,CAAC;AAExC;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;;;;OAWG;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,mBAAmB,IAAI,+BAA+B,EACvD,MAAM,eAAe,CAAC;AAWvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE,MAAM,MAAM,mBAAmB,GAAG,+BAA+B,CAAC;AAElE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AAIvC,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAc9E;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,UACzB,MAAM,KACZ,KAAK,IAAI,mBAA4D,CAAC;AAEzE;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,MAAM,SAC7C,CAAC,KACP,mBAAmB,GAAG,CAMxB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;;;;OAWG;;;;;;;;CAEK,CAAC"}

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

@@ -1,12 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { abs, div, max as max_, min as min_, mul, pow, randomNonZero as random, } from '../operators/non-zero-finite-number.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 floor = (x) => 
 
 Math.floor(x);
@@ -27,7 +21,7 @@ Math.round(x);
 
 
 
-export const isNonZeroFiniteNumber = is;
+export const isNonZeroFiniteNumber = (value) => Number.isFinite(value) && value !== 0;
 
 
 
@@ -38,7 +32,12 @@ export const isNonZeroFiniteNumber = is;
 
 
 
-export const asNonZeroFiniteNumber = castType;
+export const asNonZeroFiniteNumber = (value) => {
+    if (!isNonZeroFiniteNumber(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -53,7 +52,7 @@ export const NonZeroFiniteNumber = {
 
 
 
-    is,
+    is: isNonZeroFiniteNumber,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-finite-number.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,0BAA0B,CAAC;AAErD,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;IACA,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;CACT,CAAC,CAAC;AAEZ,MAAM,KAAK,GAAG,CACZ,CAAc,EAC8C,EAAE;AAC9D,oEAAoE;AACpE,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D,CAAC;AAE9E,MAAM,IAAI,GAAG,CACX,CAAc,EAC8C,EAAE;AAC9D,oEAAoE;AACpE,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D,CAAC;AAE7E,MAAM,KAAK,GAAG,CACZ,CAAc,EAC8C,EAAE;AAC9D,oEAAoE;AACpE,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D,CAAC;AAE9E,UAAU,CAGR,GAAG,CAAC,CAAC;AAEP,UAAU,CAKR,GAAG,CAAC,CAAC;AAEP;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAExC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,QAAQ,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC;;;;;;OAMG;IACH,EAAE;IAEF;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;OAMG;IACH,IAAI;IAEJ;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;;;;;OAWG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAGR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"non-zero-finite-number.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,GAAG,EACH,GAAG,EACH,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,aAAa,IAAI,MAAM,GACxB,MAAM,yCAAyC,CAAC;AAOjD,MAAM,iBAAiB,GAAG,0BAA0B,CAAC;AAErD,MAAM,KAAK,GAAG,CACZ,CAAc,EAC8C,EAAE;AAC9D,oEAAoE;AACpE,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D,CAAC;AAE9E,MAAM,IAAI,GAAG,CACX,CAAc,EAC8C,EAAE;AAC9D,oEAAoE;AACpE,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D,CAAC;AAE7E,MAAM,KAAK,GAAG,CACZ,CAAc,EAC8C,EAAE;AAC9D,oEAAoE;AACpE,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D,CAAC;AAE9E,UAAU,CAGR,GAAG,CAAC,CAAC;AAEP,UAAU,CAKR,GAAG,CAAC,CAAC;AAEP;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,KAAa,EACiB,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC;AAEzE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,KAAQ,EACiB,EAAE;IAC3B,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAE,CAAC;QAClC,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC;;;;;;OAMG;IACH,EAAE,EAAE,qBAAqB;IAEzB;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;OAMG;IACH,IAAI;IAEJ;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;;;;;OAWG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAGR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}

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

@@ -9,7 +9,7 @@ export type NonZeroInt = TtfImported_NonZeroInt;
  * @param value - The value to check
  * @returns `true` if the value is a non-zero integer, `false` otherwise
  */
-export declare const isNonZeroInt: (a: number) => a is TtfImported_NonZeroInt;
+export declare const isNonZeroInt: (value: number) => value is NonZeroInt;
 /**
  * Casts a `number` to the `NonZeroInt` branded type.
  *
@@ -20,14 +20,7 @@ export declare const isNonZeroInt: (a: number) => a is TtfImported_NonZeroInt;
  * @returns The value as a `NonZeroInt`
  * @throws {TypeError} If the value is not a non-zero integer
  */
-export declare const asNonZeroInt: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asNonZeroInt: <N extends number>(value: N) => NonZeroInt & N;
 /**
  * Namespace providing type-safe operations for the `NonZeroInt` branded type.
  *
@@ -46,7 +39,7 @@ export declare const NonZeroInt: {
      * @returns `true` if the value is a non-zero integer, `false` otherwise
      * @see {@link isNonZeroInt} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NonZeroInt;
+    readonly is: typeof isNonZeroInt;
     /**
      * Returns the absolute value of a non-zero integer.
      *

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":"AAAA,OAAO,KAAK,EAAE,UAAU,IAAI,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAI1E,MAAM,MAAM,UAAU,GAAG,sBAAsB,CAAC;AA2BhD;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,4CAAK,CAAC;AAE/B;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU;IACrB;;;;;;OAMG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,IAAI,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAY1E,MAAM,MAAM,UAAU,GAAG,sBAAsB,CAAC;AAMhD;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,KAAK,IAAI,UACd,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,SAAS,CAAC,KAAG,UAAU,GAAG,CAMtE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU;IACrB;;;;;;OAMG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}

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

@@ -1,13 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { abs, max as max_, min as min_, mul, pow, randomNonZero as random, } from '../operators/non-zero-int.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,
-});
 
 
 
@@ -17,7 +10,7 @@ const { abs, castType, is, max: max_, min: min_, mul, pow, randomNonZero: random
 
 
 
-export const isNonZeroInt = is;
+export const isNonZeroInt = (value) => Number.isInteger(value) && value !== 0;
 
 
 
@@ -28,7 +21,12 @@ export const isNonZeroInt = is;
 
 
 
-export const asNonZeroInt = castType;
+export const asNonZeroInt = (value) => {
+    if (!isNonZeroInt(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -47,7 +45,7 @@ export const NonZeroInt = {
 
 
 
-    is,
+    is: isNonZeroInt,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AAE/C,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;IACA,oBAAoB,EAAE,SAAS;IAC/B,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,CAAC;AAE/B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,QAAQ,CAAC;AAErC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB;;;;;;OAMG;IACH,EAAE;IAEF;;;;;;;;;OASG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAGR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"non-zero-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,GAAG,EACH,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,aAAa,IAAI,MAAM,GACxB,MAAM,+BAA+B,CAAC;AAOvC,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AAE/C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAa,EAAuB,EAAE,CACjE,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC;AAEzC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAmB,KAAQ,EAAkB,EAAE;IACzE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB;;;;;;OAMG;IACH,EAAE,EAAE,YAAY;IAEhB;;;;;;;;;OASG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAGR,IAAI,CAAC,CAAC"}

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

@@ -9,7 +9,7 @@ export type NonZeroInt16 = TtfImported_NonZeroInt16;
  * @param value - The value to check
  * @returns `true` if the value is a non-zero integer in [-2^15, 2^15), `false` otherwise
  */
-export declare const isNonZeroInt16: (a: number) => a is TtfImported_NonZeroInt16;
+export declare const isNonZeroInt16: (value: number) => value is NonZeroInt16;
 /**
  * Casts a `number` to the `NonZeroInt16` branded type.
  *
@@ -20,23 +20,7 @@ export declare const isNonZeroInt16: (a: number) => a is TtfImported_NonZeroInt1
  * @returns The value as a `NonZeroInt16`
  * @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 "!=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;
-}> & N;
+export declare const asNonZeroInt16: <N extends number>(value: N) => NonZeroInt16 & N;
 /**
  * Namespace providing type-safe operations for the `NonZeroInt16` branded type.
  *
@@ -51,7 +35,7 @@ export declare const NonZeroInt16: {
      * @returns `true` if the value is a non-zero integer in [-2^15, 2^15), `false` otherwise
      * @see {@link isNonZeroInt16} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NonZeroInt16;
+    readonly is: typeof isNonZeroInt16;
     /**
      * The smallest value representable as `NonZeroInt16` (the lower saturation
      * target of `fromNumber`).

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":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAI9E,MAAM,MAAM,YAAY,GAAG,wBAAwB,CAAC;AA8BpD;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,8CAAK,CAAC;AAEjC;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAe9E,MAAM,MAAM,YAAY,GAAG,wBAAwB,CAAC;AAMpD;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,UAAW,MAAM,KAAG,KAAK,IAAI,YAIlC,CAAC;AAEvB;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,MAAM,SACtC,CAAC,KACP,YAAY,GAAG,CAMjB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}

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

@@ -1,13 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, MIN_VALUE, abs, fromNumber, max as max_, min as min_, mul, pow, randomNonZero as random, } from '../operators/non-zero-int16.mjs';
 const typeNameInMessage = 'a non-zero integer in [-2^15, 2^15)';
-const { MAX_VALUE, MIN_VALUE, abs, castType, fromNumber, is, max: max_, min: min_, mul, pow, randomNonZero: random, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    nonZero: true,
-    MIN_VALUE: -(2 ** 15),
-    MAX_VALUE: 2 ** 15 - 1,
-    typeNameInMessage,
-});
 
 
 
@@ -17,7 +10,10 @@ const { MAX_VALUE, MIN_VALUE, abs, castType, fromNumber, is, max: max_, min: min
 
 
 
-export const isNonZeroInt16 = is;
+export const isNonZeroInt16 = (value) => Number.isSafeInteger(value) &&
+    value !== 0 &&
+    -(2 ** 15) <= value &&
+    value <= 2 ** 15 - 1;
 
 
 
@@ -28,7 +24,12 @@ export const isNonZeroInt16 = is;
 
 
 
-export const asNonZeroInt16 = castType;
+export const asNonZeroInt16 = (value) => {
+    if (!isNonZeroInt16(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -43,7 +44,7 @@ export const NonZeroInt16 = {
 
 
 
-    is,
+    is: isNonZeroInt16,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,qCAAqC,CAAC;AAEhE,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,UAAU,EACV,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;IACA,oBAAoB,EAAE,aAAa;IACnC,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACrB,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,CAAC;AAEjC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,QAAQ,CAAC;AAEvC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"non-zero-int16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,aAAa,IAAI,MAAM,GACxB,MAAM,iCAAiC,CAAC;AAOzC,MAAM,iBAAiB,GAAG,qCAAqC,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAa,EAAyB,EAAE,CACrE,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC;IAC3B,KAAK,KAAK,CAAC;IACX,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK;IACnB,KAAK,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAEvB;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,KAAQ,EACU,EAAE;IACpB,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B;;;;;;OAMG;IACH,EAAE,EAAE,cAAc;IAElB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}

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

@@ -9,7 +9,7 @@ export type NonZeroInt32 = TtfImported_NonZeroInt32;
  * @param value - The value to check
  * @returns `true` if the value is a non-zero integer in [-2^31, 2^31), `false` otherwise
  */
-export declare const isNonZeroInt32: (a: number) => a is TtfImported_NonZeroInt32;
+export declare const isNonZeroInt32: (value: number) => value is NonZeroInt32;
 /**
  * Casts a `number` to the `NonZeroInt32` branded type.
  *
@@ -20,19 +20,7 @@ export declare const isNonZeroInt32: (a: number) => a is TtfImported_NonZeroInt3
  * @returns The value as a `NonZeroInt32`
  * @throws {TypeError} If the value is not a non-zero integer in [-2^31, 2^31)
  */
-export declare const asNonZeroInt32: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly "< 2^31": true;
-    readonly "< 2^32": true;
-    readonly "> -2^32": 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;
-}> & N;
+export declare const asNonZeroInt32: <N extends number>(value: N) => NonZeroInt32 & N;
 /**
  * Namespace providing type-safe operations for the `NonZeroInt32` branded type.
  *
@@ -47,7 +35,7 @@ export declare const NonZeroInt32: {
      * @returns `true` if the value is a non-zero integer in [-2^31, 2^31), `false` otherwise
      * @see {@link isNonZeroInt32} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NonZeroInt32;
+    readonly is: typeof isNonZeroInt32;
     /**
      * The smallest value representable as `NonZeroInt32` (the lower saturation
      * target of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAI9E,MAAM,MAAM,YAAY,GAAG,wBAAwB,CAAC;AA8BpD;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,8CAAK,CAAC;AAEjC;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,IAAI,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAe9E,MAAM,MAAM,YAAY,GAAG,wBAAwB,CAAC;AAMpD;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,UAAW,MAAM,KAAG,KAAK,IAAI,YAIlC,CAAC;AAEvB;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,MAAM,SACtC,CAAC,KACP,YAAY,GAAG,CAMjB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}

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

@@ -1,13 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, MIN_VALUE, abs, fromNumber, max as max_, min as min_, mul, pow, randomNonZero as random, } from '../operators/non-zero-int32.mjs';
 const typeNameInMessage = 'a non-zero integer in [-2^31, 2^31)';
-const { MAX_VALUE, MIN_VALUE, abs, castType, fromNumber, is, max: max_, min: min_, mul, pow, randomNonZero: random, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    nonZero: true,
-    MIN_VALUE: -(2 ** 31),
-    MAX_VALUE: 2 ** 31 - 1,
-    typeNameInMessage,
-});
 
 
 
@@ -17,7 +10,10 @@ const { MAX_VALUE, MIN_VALUE, abs, castType, fromNumber, is, max: max_, min: min
 
 
 
-export const isNonZeroInt32 = is;
+export const isNonZeroInt32 = (value) => Number.isSafeInteger(value) &&
+    value !== 0 &&
+    -(2 ** 31) <= value &&
+    value <= 2 ** 31 - 1;
 
 
 
@@ -28,7 +24,12 @@ export const isNonZeroInt32 = is;
 
 
 
-export const asNonZeroInt32 = castType;
+export const asNonZeroInt32 = (value) => {
+    if (!isNonZeroInt32(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -43,7 +44,7 @@ export const NonZeroInt32 = {
 
 
 
-    is,
+    is: isNonZeroInt32,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,qCAAqC,CAAC;AAEhE,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,UAAU,EACV,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;IACA,oBAAoB,EAAE,aAAa;IACnC,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACrB,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,CAAC;AAEjC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,QAAQ,CAAC;AAEvC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"non-zero-int32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,aAAa,IAAI,MAAM,GACxB,MAAM,iCAAiC,CAAC;AAOzC,MAAM,iBAAiB,GAAG,qCAAqC,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,KAAa,EAAyB,EAAE,CACrE,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC;IAC3B,KAAK,KAAK,CAAC;IACX,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK;IACnB,KAAK,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAEvB;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,KAAQ,EACU,EAAE;IACpB,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B;;;;;;OAMG;IACH,EAAE,EAAE,cAAc;IAElB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}

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

@@ -1,4 +1,4 @@
-import type { SafeInt, SafeUint, NonZeroSafeInt as TtfImported_NonZeroSafeInt } from 'ts-type-forge';
+import type { NonZeroSafeInt as TtfImported_NonZeroSafeInt } from 'ts-type-forge';
 export type NonZeroSafeInt = TtfImported_NonZeroSafeInt;
 /**
  * Type guard that checks if a value is a non-zero safe integer.
@@ -9,7 +9,7 @@ export type NonZeroSafeInt = TtfImported_NonZeroSafeInt;
  * @param value - The value to check
  * @returns `true` if the value is a non-zero safe integer, `false` otherwise
  */
-export declare const isNonZeroSafeInt: (a: number) => a is TtfImported_NonZeroSafeInt;
+export declare const isNonZeroSafeInt: (value: number) => value is NonZeroSafeInt;
 /**
  * Casts a `number` to the `NonZeroSafeInt` branded type.
  *
@@ -20,15 +20,7 @@ export declare const isNonZeroSafeInt: (a: number) => a is TtfImported_NonZeroSa
  * @returns The value as a `NonZeroSafeInt`
  * @throws {TypeError} If the value is not a non-zero safe integer
  */
-export declare const asNonZeroSafeInt: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-    readonly SafeInt: true;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asNonZeroSafeInt: <N extends number>(value: N) => NonZeroSafeInt & N;
 /**
  * Namespace providing type-safe operations for the `NonZeroSafeInt` branded
  * type.
@@ -44,17 +36,17 @@ export declare const NonZeroSafeInt: {
      * @returns `true` if the value is a non-zero safe integer, `false` otherwise
      * @see {@link isNonZeroSafeInt} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NonZeroSafeInt;
+    readonly is: typeof isNonZeroSafeInt;
     /**
      * The smallest value representable as `NonZeroSafeInt` (the lower saturation
      * target of `fromNumber`).
      */
-    readonly MIN_VALUE: SafeInt;
+    readonly MIN_VALUE: import("ts-type-forge").SafeInt;
     /**
      * The largest value representable as `NonZeroSafeInt` (the upper saturation
      * target of `fromNumber`).
      */
-    readonly MAX_VALUE: SafeUint;
+    readonly MAX_VALUE: import("ts-type-forge").SafeUint;
     /**
      * Returns the absolute value of a non-zero safe integer.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,QAAQ,EACR,cAAc,IAAI,0BAA0B,EAC7C,MAAM,eAAe,CAAC;AAIvB,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AAgCxD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,gDAAK,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;MAAW,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAelF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AAMxD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,UAAW,MAAM,KAAG,KAAK,IAAI,cACd,CAAC;AAE7C;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,MAAM,SACxC,CAAC,KACP,cAAc,GAAG,CAMnB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

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

@@ -1,15 +1,8 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, MIN_VALUE, abs, fromNumber, max as max_, min as min_, mul, pow, randomNonZero as random, } from '../operators/non-zero-safe-int.mjs';
 const typeNameInMessage = 'a non-zero safe integer';
-const { MAX_VALUE, MIN_VALUE, abs, castType, fromNumber, is, max: max_, min: min_, mul, pow, randomNonZero: random, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    nonZero: true,
 
-    MIN_VALUE: Number.MIN_SAFE_INTEGER,
 
-    MAX_VALUE: Number.MAX_SAFE_INTEGER,
-    typeNameInMessage,
-});
 
 
 
@@ -17,9 +10,9 @@ const { MAX_VALUE, MIN_VALUE, abs, castType, fromNumber, is, max: max_, min: min
 
 
 
+export const isNonZeroSafeInt = (value) => Number.isSafeInteger(value) && value !== 0;
 
 
-export const isNonZeroSafeInt = is;
 
 
 
@@ -28,9 +21,12 @@ export const isNonZeroSafeInt = is;
 
 
 
-
-
-export const asNonZeroSafeInt = castType;
+export const asNonZeroSafeInt = (value) => {
+    if (!isNonZeroSafeInt(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -46,7 +42,7 @@ export const NonZeroSafeInt = {
 
 
 
-    is,
+    is: isNonZeroSafeInt,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,yBAAyB,CAAC;AAEpD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,UAAU,EACV,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;IACA,oBAAoB,EAAE,aAAa;IACnC,OAAO,EAAE,IAAI;IACb,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC,gBAA2B;IAC7C,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAEnC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,QAAQ,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"non-zero-safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,aAAa,IAAI,MAAM,GACxB,MAAM,oCAAoC,CAAC;AAO5C,MAAM,iBAAiB,GAAG,yBAAyB,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAA2B,EAAE,CACzE,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC;AAE7C;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,KAAQ,EACY,EAAE;IACtB,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B;;;;;;OAMG;IACH,EAAE,EAAE,gBAAgB;IAEpB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}