ts-data-forge 14.10.1 → 14.11.0

package/dist/number/branded-types/negative-finite-number.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"negative-finite-number.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/negative-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAMpE,MAAM,iBAAiB,GAAG,0BAA0B,CAAC;AAErD,MAAM,EACJ,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,iBAAiB,CAI3D;IACA,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,iBAAiB;CACT,CAAC,CAAC;AAEZ,MAAM,GAAG,GAAG,CAAC,CAAc,EAAwB,EAAE,CACnD,oBAAoB,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAE/C,MAAM,KAAK,GAAG,CACZ,CAAc,EAC8C,EAAE;AAC9D,oEAAoE;AACpE,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D,CAAC;AAE9E,MAAM,IAAI,GAAG,CACX,CAAc,EAGd,EAAE;AACF,oEAAoE;AACpE,IAAI,CAAC,IAAI,CAAC,CAAC,CAEV,CAAC;AAEJ,MAAM,KAAK,GAAG,CACZ,CAAc,EAGd,EAAE;AACF,oEAAoE;AACpE,IAAI,CAAC,KAAK,CACR,CAAC,CAGF,CAAC;AAEJ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAEzC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,QAAQ,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC;;;;;;OAMG;IACH,EAAE;IAEF;;;;;OAKG;IACH,SAAS;IAET;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;OAMG;IACH,IAAI;IAEJ;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC"}
+{"version":3,"file":"negative-finite-number.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/negative-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,yCAAyC,CAAC;AAEjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAMpE,MAAM,iBAAiB,GAAG,0BAA0B,CAAC;AAErD,MAAM,GAAG,GAAG,CAAC,CAAc,EAAwB,EAAE,CACnD,oBAAoB,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAE/C,MAAM,KAAK,GAAG,CACZ,CAAc,EAC8C,EAAE;AAC9D,oEAAoE;AACpE,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D,CAAC;AAE9E,MAAM,IAAI,GAAG,CACX,CAAc,EAGd,EAAE;AACF,oEAAoE;AACpE,IAAI,CAAC,IAAI,CAAC,CAAC,CAEV,CAAC;AAEJ,MAAM,KAAK,GAAG,CACZ,CAAc,EAGd,EAAE;AACF,oEAAoE;AACpE,IAAI,CAAC,KAAK,CACR,CAAC,CAGF,CAAC;AAEJ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,KAAa,EACkB,EAAE,CACjC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC;AAEvD;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,KAAQ,EACkB,EAAE;IAC5B,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,EAAE,CAAC;QACnC,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,oBAAoB,GAAG;IAClC;;;;;;OAMG;IACH,EAAE,EAAE,sBAAsB;IAE1B;;;;;OAKG;IACH,SAAS;IAET;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;OAMG;IACH,IAAI;IAEJ;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC"}

package/dist/number/branded-types/negative-int.d.mts

@@ -12,7 +12,7 @@ declare const abs: (x: WithSmallInt<ElementType>) => PositiveInt;
  * @param value - The value to check
  * @returns `true` if the value is a negative integer, `false` otherwise
  */
-export declare const isNegativeInt: (a: number) => a is TtfImported_NegativeInt;
+export declare const isNegativeInt: (value: number) => value is NegativeInt;
 /**
  * Casts a `number` to the `NegativeInt` branded type.
  *
@@ -23,20 +23,7 @@ export declare const isNegativeInt: (a: number) => a is TtfImported_NegativeInt;
  * @returns The value as a `NegativeInt`
  * @throws {TypeError} If the value is not a negative integer
  */
-export declare const asNegativeInt: <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 "<=0": true;
-    readonly ">=0": false;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asNegativeInt: <N extends number>(value: N) => NegativeInt & N;
 /**
  * Namespace providing type-safe operations for the `NegativeInt` branded type.
  *
@@ -55,7 +42,7 @@ export declare const NegativeInt: {
      * @returns `true` if the value is a negative integer, `false` otherwise
      * @see {@link isNegativeInt} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NegativeInt;
+    readonly is: typeof isNegativeInt;
     /**
      * The largest value representable as `NegativeInt` (the upper saturation
      * target of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"negative-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,IAAI,uBAAuB,EACtC,YAAY,EACb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AAElD,KAAK,WAAW,GAAG,WAAW,CAAC;AA2B/B,QAAA,MAAM,GAAG,MAAO,YAAY,CAAC,WAAW,CAAC,KAAG,WACP,CAAC;AAEtC;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,6CAAK,CAAC;AAEhC;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}
+{"version":3,"file":"negative-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,IAAI,uBAAuB,EACtC,YAAY,EACb,MAAM,eAAe,CAAC;AAWvB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AAElD,KAAK,WAAW,GAAG,WAAW,CAAC;AAI/B,QAAA,MAAM,GAAG,MAAO,YAAY,CAAC,WAAW,CAAC,KAAG,WACP,CAAC;AAEtC;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,KAAK,IAAI,WACf,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,MAAM,SAAS,CAAC,KAAG,WAAW,GAAG,CAMxE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}

package/dist/number/branded-types/negative-int.mjs

@@ -1,13 +1,6 @@
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, add, fromNumber, max as max_, min as min_, pow, random, sub, } from '../operators/negative-int.mjs';
 import { PositiveInt } from './positive-int.mjs';
 const typeNameInMessage = 'a negative integer';
-const { MAX_VALUE, add, castType, fromNumber, is, max: max_, min: min_, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'Integer',
-    nonZero: true,
-    MIN_VALUE: -Number.MAX_VALUE,
-    MAX_VALUE: -1,
-    typeNameInMessage,
-});
 const abs = (x) => PositiveInt.fromNumber(Math.abs(x));
 
 
@@ -18,7 +11,7 @@ const abs = (x) => PositiveInt.fromNumber(Math.abs(x));
 
 
 
-export const isNegativeInt = is;
+export const isNegativeInt = (value) => Number.isInteger(value) && value <= -1;
 
 
 
@@ -29,7 +22,12 @@ export const isNegativeInt = is;
 
 
 
-export const asNegativeInt = castType;
+export const asNegativeInt = (value) => {
+    if (!isNegativeInt(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -48,7 +46,7 @@ export const NegativeInt = {
 
 
 
-    is,
+    is: isNegativeInt,
 
 
 

package/dist/number/branded-types/negative-int.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"negative-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/negative-int.mts"],"names":[],"mappings":"AAIA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAMjD,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AAE/C,MAAM,EACJ,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,SAAS;IAC/B,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,CAAC,CAAC;IACb,iBAAiB;CACT,CAAC,CAAC;AAEZ,MAAM,GAAG,GAAG,CAAC,CAA4B,EAAe,EAAE,CACxD,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAC;AAEhC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,QAAQ,CAAC;AAEtC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;;;;;;;OASG;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;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC"}
+{"version":3,"file":"negative-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/negative-int.mts"],"names":[],"mappings":"AAIA,OAAO,EACL,SAAS,EACT,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAMjD,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AAE/C,MAAM,GAAG,GAAG,CAAC,CAA4B,EAAe,EAAE,CACxD,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAa,EAAwB,EAAE,CACnE,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC;AAEzC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAmB,KAAQ,EAAmB,EAAE;IAC3E,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,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,WAAW,GAAG;IACzB;;;;;;OAMG;IACH,EAAE,EAAE,aAAa;IAEjB;;;OAGG;IACH,SAAS;IAET;;;;;;;;;OASG;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;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC"}

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

@@ -12,7 +12,7 @@ declare const abs: (x: WithSmallInt<ElementType>) => PositiveSafeInt;
  * @param value - The value to check
  * @returns `true` if the value is a negative safe integer, `false` otherwise
  */
-export declare const isNegativeSafeInt: (a: number) => a is TtfImported_NegativeSafeInt;
+export declare const isNegativeSafeInt: (value: number) => value is NegativeSafeInt;
 /**
  * Casts a `number` to the `NegativeSafeInt` branded type.
  *
@@ -23,21 +23,7 @@ export declare const isNegativeSafeInt: (a: number) => a is TtfImported_Negative
  * @returns The value as a `NegativeSafeInt`
  * @throws {TypeError} If the value is not a negative safe integer
  */
-export declare const asNegativeSafeInt: <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 "<=0": true;
-    readonly ">=0": false;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-    readonly SafeInt: true;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asNegativeSafeInt: <N extends number>(value: N) => NegativeSafeInt & N;
 /**
  * Namespace providing type-safe operations for the `NegativeSafeInt` branded
  * type.
@@ -53,7 +39,7 @@ export declare const NegativeSafeInt: {
      * @returns `true` if the value is a negative safe integer, `false` otherwise
      * @see {@link isNegativeSafeInt} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NegativeSafeInt;
+    readonly is: typeof isNegativeSafeInt;
     /**
      * The smallest value representable as `NegativeSafeInt` (the lower saturation
      * target of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"negative-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,IAAI,2BAA2B,EAC9C,YAAY,EACb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,MAAM,MAAM,eAAe,GAAG,2BAA2B,CAAC;AAE1D,KAAK,WAAW,GAAG,eAAe,CAAC;AA4BnC,QAAA,MAAM,GAAG,MAAO,YAAY,CAAC,WAAW,CAAC,KAAG,eACH,CAAC;AAE1C;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,iDAAK,CAAC;AAEpC;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}
+{"version":3,"file":"negative-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,IAAI,2BAA2B,EAC9C,YAAY,EACb,MAAM,eAAe,CAAC;AAYvB,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D,MAAM,MAAM,eAAe,GAAG,2BAA2B,CAAC;AAE1D,KAAK,WAAW,GAAG,eAAe,CAAC;AAInC,QAAA,MAAM,GAAG,MAAO,YAAY,CAAC,WAAW,CAAC,KAAG,eACH,CAAC;AAE1C;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,UAAW,MAAM,KAAG,KAAK,IAAI,eACf,CAAC;AAE7C;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,MAAM,SACzC,CAAC,KACP,eAAe,GAAG,CAMpB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

package/dist/number/branded-types/negative-safe-int.mjs

@@ -1,13 +1,6 @@
-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/negative-safe-int.mjs';
 import { PositiveSafeInt } from './positive-safe-int.mjs';
 const typeNameInMessage = 'a negative safe integer';
-const { MAX_VALUE, MIN_VALUE, add, castType, fromNumber, is, max: max_, min: min_, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    nonZero: true,
-    MIN_VALUE: Number.MIN_SAFE_INTEGER,
-    MAX_VALUE: -1,
-    typeNameInMessage,
-});
 const abs = (x) => PositiveSafeInt.fromNumber(Math.abs(x));
 
 
@@ -18,7 +11,7 @@ const abs = (x) => PositiveSafeInt.fromNumber(Math.abs(x));
 
 
 
-export const isNegativeSafeInt = is;
+export const isNegativeSafeInt = (value) => Number.isSafeInteger(value) && value <= -1;
 
 
 
@@ -29,7 +22,12 @@ export const isNegativeSafeInt = is;
 
 
 
-export const asNegativeSafeInt = castType;
+export const asNegativeSafeInt = (value) => {
+    if (!isNegativeSafeInt(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -45,7 +43,7 @@ export const NegativeSafeInt = {
 
 
 
-    is,
+    is: isNegativeSafeInt,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"negative-safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/negative-safe-int.mts"],"names":[],"mappings":"AAIA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAM1D,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,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,aAAa;IACnC,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,MAAM,CAAC,gBAAgB;IAClC,SAAS,EAAE,CAAC,CAAC;IACb,iBAAiB;CACT,CAAC,CAAC;AAEZ,MAAM,GAAG,GAAG,CAAC,CAA4B,EAAmB,EAAE,CAC5D,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAE1C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAEpC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,QAAQ,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B;;;;;;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;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC"}
+{"version":3,"file":"negative-safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/negative-safe-int.mts"],"names":[],"mappings":"AAIA,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,oCAAoC,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAM1D,MAAM,iBAAiB,GAAG,yBAAyB,CAAC;AAEpD,MAAM,GAAG,GAAG,CAAC,CAA4B,EAAmB,EAAE,CAC5D,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAE1C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,KAAa,EAA4B,EAAE,CAC3E,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC;AAE7C;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,KAAQ,EACa,EAAE;IACvB,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,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,eAAe,GAAG;IAC7B;;;;;;OAMG;IACH,EAAE,EAAE,iBAAiB;IAErB;;;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;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC"}

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

@@ -1,5 +1,5 @@
 import type { NonNegativeFiniteNumber as TtfImported_NonNegativeFiniteNumber } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type NonNegativeFiniteNumber = TtfImported_NonNegativeFiniteNumber;
 type ElementType = NonNegativeFiniteNumber;
 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-negative finite number, `false` otherwise
  */
-export declare const isNonNegativeFiniteNumber: (a: number) => a is TtfImported_NonNegativeFiniteNumber;
+export declare const isNonNegativeFiniteNumber: (value: number) => value is NonNegativeFiniteNumber;
 /**
  * Casts a `number` to the `NonNegativeFiniteNumber` branded type.
  *
@@ -25,17 +25,7 @@ export declare const isNonNegativeFiniteNumber: (a: number) => a is TtfImported_
  * @returns The value as a `NonNegativeFiniteNumber`
  * @throws {TypeError} If the value is not a non-negative finite number
  */
-export declare const asNonNegativeFiniteNumber: <N extends number>(x: N) => number & {
-    readonly "> -2^16": true;
-    readonly "> -2^32": true;
-    readonly ">= -2^15": true;
-    readonly ">= -2^31": true;
-    readonly ">=0": true;
-    readonly Finite: true;
-    readonly NaNValue: false;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asNonNegativeFiniteNumber: <N extends number>(value: N) => NonNegativeFiniteNumber & N;
 /**
  * Namespace providing type-safe operations for the `NonNegativeFiniteNumber`
  * branded type.
@@ -50,7 +40,7 @@ export declare const NonNegativeFiniteNumber: {
      * @returns `true` if the value is a non-negative finite number, `false` otherwise
      * @see {@link isNonNegativeFiniteNumber} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NonNegativeFiniteNumber;
+    readonly is: typeof isNonNegativeFiniteNumber;
     /**
      * The smallest value representable as `NonNegativeFiniteNumber` (the lower
      * saturation target of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,IAAI,mCAAmC,EAE/D,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AA2B3C,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;AAM9E;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,yDAAK,CAAC;AAE5C;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,IAAI,mCAAmC,EAE/D,MAAM,eAAe,CAAC;AAcvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAI3C,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;AAM9E;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,UAC7B,MAAM,KACZ,KAAK,IAAI,uBAA+D,CAAC;AAE5E;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAAI,CAAC,SAAS,MAAM,SACjD,CAAC,KACP,uBAAuB,GAAG,CAM5B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,11 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MIN_VALUE, add, div, fromNumber, max as max_, min as min_, mul, pow, random, sub, } from '../operators/non-negative-finite-number.mjs';
 const typeNameInMessage = 'a non-negative finite number';
-const { MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
-    MIN_VALUE: 0,
-    MAX_VALUE: Number.MAX_VALUE,
-    typeNameInMessage,
-});
 const floor = (x) => 
 
 Math.floor(x);
@@ -25,7 +20,7 @@ Math.round(x);
 
 
 
-export const isNonNegativeFiniteNumber = is;
+export const isNonNegativeFiniteNumber = (value) => Number.isFinite(value) && value >= 0;
 
 
 
@@ -36,7 +31,12 @@ export const isNonNegativeFiniteNumber = is;
 
 
 
-export const asNonNegativeFiniteNumber = castType;
+export const asNonNegativeFiniteNumber = (value) => {
+    if (!isNonNegativeFiniteNumber(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -51,7 +51,7 @@ export const NonNegativeFiniteNumber = {
 
 
 
-    is,
+    is: isNonNegativeFiniteNumber,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-finite-number.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,8BAA8B,CAAC;AAEzD,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,GAAG,EACH,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;IACA,SAAS,EAAE,CAAC;IACZ,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,CACR,GAAG,CACJ,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,CAAC;AAE5C;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,QAAQ,CAAC;AAElD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;OAMG;IACH,IAAI;IAEJ;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"non-negative-finite-number.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,GAAG,EACH,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,6CAA6C,CAAC;AAOrD,MAAM,iBAAiB,GAAG,8BAA8B,CAAC;AAEzD,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,CACR,GAAG,CACJ,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,KAAa,EACqB,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AAE5E;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,KAAQ,EACqB,EAAE;IAC/B,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC,EAAE,CAAC;QACtC,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,uBAAuB,GAAG;IACrC;;;;;;OAMG;IACH,EAAE,EAAE,yBAAyB;IAE7B;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;OAMG;IACH,IAAI;IAEJ;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}

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

@@ -9,7 +9,7 @@ export type NonNegativeInt16 = TtfImported_NonNegativeInt16;
  * @param value - The value to check
  * @returns `true` if the value is a non-negative integer in [0, 2^15), `false` otherwise
  */
-export declare const isNonNegativeInt16: (a: number) => a is TtfImported_NonNegativeInt16;
+export declare const isNonNegativeInt16: (value: number) => value is NonNegativeInt16;
 /**
  * Casts a `number` to the `NonNegativeInt16` branded type.
  *
@@ -20,23 +20,7 @@ export declare const isNonNegativeInt16: (a: number) => a is TtfImported_NonNega
  * @returns The value as a `NonNegativeInt16`
  * @throws {TypeError} If the value is not a non-negative integer in [0, 2^15)
  */
-export declare const asNonNegativeInt16: <N extends number>(x: N) => number & {
-    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 ">=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 asNonNegativeInt16: <N extends number>(value: N) => NonNegativeInt16 & N;
 /**
  * Namespace providing type-safe operations for the `NonNegativeInt16` branded
  * type.
@@ -52,7 +36,7 @@ export declare const NonNegativeInt16: {
      * @returns `true` if the value is a non-negative integer in [0, 2^15), `false` otherwise
      * @see {@link isNonNegativeInt16} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NonNegativeInt16;
+    readonly is: typeof isNonNegativeInt16;
     /**
      * The smallest value representable as `NonNegativeInt16` (the lower
      * saturation target of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,IAAI,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAItF,MAAM,MAAM,gBAAgB,GAAG,4BAA4B,CAAC;AA+B5D;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,kDAAK,CAAC;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,IAAI,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAiBtF,MAAM,MAAM,gBAAgB,GAAG,4BAA4B,CAAC;AAM5D;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,UAAW,MAAM,KAAG,KAAK,IAAI,gBACO,CAAC;AAEpE;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,MAAM,SAC1C,CAAC,KACP,gBAAgB,GAAG,CAMrB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,12 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, MIN_VALUE, add, div, fromNumber, max as max_, min as min_, mul, pow, random, sub, } from '../operators/non-negative-int16.mjs';
 const typeNameInMessage = 'a non-negative integer in [0, 2^15)';
-const { MAX_VALUE, MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    MIN_VALUE: 0,
-    MAX_VALUE: 2 ** 15 - 1,
-    typeNameInMessage,
-});
 
 
 
@@ -16,7 +10,7 @@ const { MAX_VALUE, MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min
 
 
 
-export const isNonNegativeInt16 = is;
+export const isNonNegativeInt16 = (value) => Number.isSafeInteger(value) && 0 <= value && value <= 2 ** 15 - 1;
 
 
 
@@ -27,7 +21,12 @@ export const isNonNegativeInt16 = is;
 
 
 
-export const asNonNegativeInt16 = castType;
+export const asNonNegativeInt16 = (value) => {
+    if (!isNonNegativeInt16(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -43,7 +42,7 @@ export const NonNegativeInt16 = {
 
 
 
-    is,
+    is: isNonNegativeInt16,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-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,GAAG,EACH,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,aAAa;IACnC,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAErC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,QAAQ,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;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;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;;OAQG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"non-negative-int16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,qCAAqC,CAAC;AAO7C,MAAM,iBAAiB,GAAG,qCAAqC,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,KAAa,EAA6B,EAAE,CAC7E,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,KAAQ,EACc,EAAE;IACxB,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/B,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,gBAAgB,GAAG;IAC9B;;;;;;OAMG;IACH,EAAE,EAAE,kBAAkB;IAEtB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;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;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;;OAQG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,IAAI,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAItF,MAAM,MAAM,gBAAgB,GAAG,4BAA4B,CAAC;AA+B5D;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,kDAAK,CAAC;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;MAAW,CAAC;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,IAAI,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAiBtF,MAAM,MAAM,gBAAgB,GAAG,4BAA4B,CAAC;AAM5D;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,UAAW,MAAM,KAAG,KAAK,IAAI,gBACO,CAAC;AAEpE;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,MAAM,SAC1C,CAAC,KACP,gBAAgB,GAAG,CAMrB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,12 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, MIN_VALUE, add, div, fromNumber, max as max_, min as min_, mul, pow, random, sub, } from '../operators/non-negative-int32.mjs';
 const typeNameInMessage = 'a non-negative integer in [0, 2^31)';
-const { MAX_VALUE, MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    MIN_VALUE: 0,
-    MAX_VALUE: 2 ** 31 - 1,
-    typeNameInMessage,
-});
 
 
 
@@ -16,7 +10,7 @@ const { MAX_VALUE, MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min
 
 
 
-export const isNonNegativeInt32 = is;
+export const isNonNegativeInt32 = (value) => Number.isSafeInteger(value) && 0 <= value && value <= 2 ** 31 - 1;
 
 
 
@@ -27,7 +21,12 @@ export const isNonNegativeInt32 = is;
 
 
 
-export const asNonNegativeInt32 = castType;
+export const asNonNegativeInt32 = (value) => {
+    if (!isNonNegativeInt32(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -43,7 +42,7 @@ export const NonNegativeInt32 = {
 
 
 
-    is,
+    is: isNonNegativeInt32,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-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,GAAG,EACH,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,aAAa;IACnC,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAErC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,QAAQ,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;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;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;;OAQG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"non-negative-int32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,qCAAqC,CAAC;AAO7C,MAAM,iBAAiB,GAAG,qCAAqC,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,KAAa,EAA6B,EAAE,CAC7E,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,KAAQ,EACc,EAAE;IACxB,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/B,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,gBAAgB,GAAG;IAC9B;;;;;;OAMG;IACH,EAAE,EAAE,kBAAkB;IAEtB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;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;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;;OAQG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}

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

@@ -1,5 +1,5 @@
 import type { NonPositiveFiniteNumber as TtfImported_NonPositiveFiniteNumber } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type NonPositiveFiniteNumber = TtfImported_NonPositiveFiniteNumber;
 type ElementType = NonPositiveFiniteNumber;
 declare const floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<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-positive finite number, `false` otherwise
  */
-export declare const isNonPositiveFiniteNumber: (a: number) => a is TtfImported_NonPositiveFiniteNumber;
+export declare const isNonPositiveFiniteNumber: (value: number) => value is NonPositiveFiniteNumber;
 /**
  * Casts a `number` to the `NonPositiveFiniteNumber` branded type.
  *
@@ -25,17 +25,7 @@ export declare const isNonPositiveFiniteNumber: (a: number) => a is TtfImported_
  * @returns The value as a `NonPositiveFiniteNumber`
  * @throws {TypeError} If the value is not a non-positive finite number
  */
-export declare const asNonPositiveFiniteNumber: <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 NaNValue: false;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asNonPositiveFiniteNumber: <N extends number>(value: N) => NonPositiveFiniteNumber & N;
 /**
  * Namespace providing type-safe operations for the `NonPositiveFiniteNumber`
  * branded type.
@@ -50,7 +40,7 @@ export declare const NonPositiveFiniteNumber: {
      * @returns `true` if the value is a non-positive finite number, `false` otherwise
      * @see {@link isNonPositiveFiniteNumber} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_NonPositiveFiniteNumber;
+    readonly is: typeof isNonPositiveFiniteNumber;
     /**
      * The largest value representable as `NonPositiveFiniteNumber` (the upper
      * saturation target of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"non-positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,IAAI,mCAAmC,EAAE,MAAM,eAAe,CAAC;AACpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAyB3C,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAKzD,CAAC;AAEJ,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,yDAAK,CAAC;AAE5C;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}
+{"version":3,"file":"non-positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,IAAI,mCAAmC,EAAE,MAAM,eAAe,CAAC;AAWpG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAI3C,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAKzD,CAAC;AAEJ,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,UAC7B,MAAM,KACZ,KAAK,IAAI,uBAA+D,CAAC;AAE5E;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAAI,CAAC,SAAS,MAAM,SACjD,CAAC,KACP,uBAAuB,GAAG,CAM5B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

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

@@ -1,10 +1,5 @@
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, add, fromNumber, max as max_, min as min_, pow, random, sub, } from '../operators/non-positive-finite-number.mjs';
 const typeNameInMessage = 'a non-positive finite number';
-const { MAX_VALUE, add, castType, fromNumber, is, max: max_, min: min_, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
-    MIN_VALUE: -Number.MAX_VALUE,
-    MAX_VALUE: 0,
-    typeNameInMessage,
-});
 const floor = (x) => 
 
 Math.floor(x);
@@ -23,7 +18,7 @@ Math.round(x);
 
 
 
-export const isNonPositiveFiniteNumber = is;
+export const isNonPositiveFiniteNumber = (value) => Number.isFinite(value) && value <= 0;
 
 
 
@@ -34,7 +29,12 @@ export const isNonPositiveFiniteNumber = is;
 
 
 
-export const asNonPositiveFiniteNumber = castType;
+export const asNonPositiveFiniteNumber = (value) => {
+    if (!isNonPositiveFiniteNumber(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -49,7 +49,7 @@ export const NonPositiveFiniteNumber = {
 
 
 
-    is,
+    is: isNonPositiveFiniteNumber,