ts-data-forge 14.10.2 → 14.11.0

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

@@ -1,13 +1,7 @@
 
-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/positive-safe-int.mjs';
 const typeNameInMessage = 'a positive safe integer';
-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: 1,
 
-    MAX_VALUE: Number.MAX_SAFE_INTEGER,
-    typeNameInMessage,
-});
 
 
 
@@ -28,8 +22,8 @@ const { MAX_VALUE, MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min
 
 
 
+export const isPositiveSafeInt = (value) => Number.isSafeInteger(value) && value >= 1;
 
-export const isPositiveSafeInt = is;
 
 
 
@@ -49,8 +43,12 @@ export const isPositiveSafeInt = is;
 
 
 
-
-export const asPositiveSafeInt = castType;
+export const asPositiveSafeInt = (value) => {
+    if (!isPositiveSafeInt(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -78,7 +76,7 @@ export const PositiveSafeInt = {
 
 
 
-    is,
+    is: isPositiveSafeInt,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"positive-safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"names":[],"mappings":"AAIA,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,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,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,QAAQ,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B;;;;;;;;;;;;;;;;;;OAkBG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,UAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM;IAEN;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"positive-safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-safe-int.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,oCAAoC,CAAC;AAO5C,MAAM,iBAAiB,GAAG,yBAAyB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,KAAa,EAA4B,EAAE,CAC3E,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;GAmBG;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;;;;;;;;;;;;;;;;;;OAkBG;IACH,EAAE,EAAE,iBAAiB;IAErB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,UAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM;IAEN;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}

package/dist/number/branded-types/positive-uint16.d.mts

@@ -9,7 +9,7 @@ export type PositiveUint16 = TtfImported_PositiveUint16;
  * @param value - The value to check
  * @returns `true` if the value is a positive integer in [1, 2^16), `false` otherwise
  */
-export declare const isPositiveUint16: (a: number) => a is TtfImported_PositiveUint16;
+export declare const isPositiveUint16: (value: number) => value is PositiveUint16;
 /**
  * Casts a `number` to the `PositiveUint16` branded type.
  *
@@ -20,24 +20,7 @@ export declare const isPositiveUint16: (a: number) => a is TtfImported_PositiveU
  * @returns The value as a `PositiveUint16`
  * @throws {TypeError} If the value is not a positive integer in [1, 2^16)
  */
-export declare const asPositiveUint16: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly "< 2^16": true;
-    readonly "< 2^31": true;
-    readonly "< 2^32": true;
-    readonly "<=0": false;
-    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 asPositiveUint16: <N extends number>(value: N) => PositiveUint16 & N;
 /**
  * Namespace providing type-safe operations for the `PositiveUint16` branded
  * type.
@@ -53,7 +36,7 @@ export declare const PositiveUint16: {
      * @returns `true` if the value is a positive integer in [1, 2^16), `false` otherwise
      * @see {@link isPositiveUint16} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_PositiveUint16;
+    readonly is: typeof isPositiveUint16;
     /**
      * The smallest value representable as `PositiveUint16` (the lower saturation
      * target of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"positive-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint16.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAIlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AA+BxD;;;;;;;;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;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint16.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAiBlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AAMxD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,UAAW,MAAM,KAAG,KAAK,IAAI,cACS,CAAC;AAEpE;;;;;;;;;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;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/positive-uint16.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/positive-uint16.mjs';
 const typeNameInMessage = 'a positive integer in [1, 2^16)';
-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: 1,
-    MAX_VALUE: 2 ** 16 - 1,
-    typeNameInMessage,
-});
 
 
 
@@ -16,7 +10,7 @@ const { MAX_VALUE, MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min
 
 
 
-export const isPositiveUint16 = is;
+export const isPositiveUint16 = (value) => Number.isSafeInteger(value) && 1 <= value && value <= 2 ** 16 - 1;
 
 
 
@@ -27,7 +21,12 @@ export const isPositiveUint16 = is;
 
 
 
-export const asPositiveUint16 = castType;
+export const asPositiveUint16 = (value) => {
+    if (!isPositiveUint16(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -43,7 +42,7 @@ export const PositiveUint16 = {
 
 
 
-    is,
+    is: isPositiveUint16,
 
 
 

package/dist/number/branded-types/positive-uint16.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"positive-uint16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D,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,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;;;;;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;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"positive-uint16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint16.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,kCAAkC,CAAC;AAO1C,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAA2B,EAAE,CACzE,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,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;;;;;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;IAEH;;;;;;OAMG;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/positive-uint32.d.mts

@@ -9,7 +9,7 @@ export type PositiveUint32 = TtfImported_PositiveUint32;
  * @param value - The value to check
  * @returns `true` if the value is a positive integer in [1, 2^32), `false` otherwise
  */
-export declare const isPositiveUint32: (a: number) => a is TtfImported_PositiveUint32;
+export declare const isPositiveUint32: (value: number) => value is PositiveUint32;
 /**
  * Casts a `number` to the `PositiveUint32` branded type.
  *
@@ -20,22 +20,7 @@ export declare const isPositiveUint32: (a: number) => a is TtfImported_PositiveU
  * @returns The value as a `PositiveUint32`
  * @throws {TypeError} If the value is not a positive integer in [1, 2^32)
  */
-export declare const asPositiveUint32: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly "< 2^32": true;
-    readonly "<=0": false;
-    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 asPositiveUint32: <N extends number>(value: N) => PositiveUint32 & N;
 /**
  * Namespace providing type-safe operations for the `PositiveUint32` branded
  * type.
@@ -51,7 +36,7 @@ export declare const PositiveUint32: {
      * @returns `true` if the value is a positive integer in [1, 2^32), `false` otherwise
      * @see {@link isPositiveUint32} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_PositiveUint32;
+    readonly is: typeof isPositiveUint32;
     /**
      * The smallest value representable as `PositiveUint32` (the lower saturation
      * target of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"positive-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint32.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAIlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AA+BxD;;;;;;;;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;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint32.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAiBlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AAMxD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,UAAW,MAAM,KAAG,KAAK,IAAI,cACS,CAAC;AAEpE;;;;;;;;;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;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/positive-uint32.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/positive-uint32.mjs';
 const typeNameInMessage = 'a positive integer in [1, 2^32)';
-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: 1,
-    MAX_VALUE: 2 ** 32 - 1,
-    typeNameInMessage,
-});
 
 
 
@@ -16,7 +10,7 @@ const { MAX_VALUE, MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min
 
 
 
-export const isPositiveUint32 = is;
+export const isPositiveUint32 = (value) => Number.isSafeInteger(value) && 1 <= value && value <= 2 ** 32 - 1;
 
 
 
@@ -27,7 +21,12 @@ export const isPositiveUint32 = is;
 
 
 
-export const asPositiveUint32 = castType;
+export const asPositiveUint32 = (value) => {
+    if (!isPositiveUint32(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -43,7 +42,7 @@ export const PositiveUint32 = {
 
 
 
-    is,
+    is: isPositiveUint32,
 
 
 

package/dist/number/branded-types/positive-uint32.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"positive-uint32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D,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,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;;;;;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;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"positive-uint32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint32.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,kCAAkC,CAAC;AAO1C,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAA2B,EAAE,CACzE,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,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;;;;;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;IAEH;;;;;;OAMG;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/safe-int.d.mts

@@ -1,4 +1,4 @@
-import type { SafeUint, SafeInt as TtfImported_SafeInt } from 'ts-type-forge';
+import type { SafeInt as TtfImported_SafeInt } from 'ts-type-forge';
 export type SafeInt = TtfImported_SafeInt;
 /**
  * Type guard that checks if a value is a safe integer.
@@ -18,7 +18,7 @@ export type SafeInt = TtfImported_SafeInt;
  * @param value - The value to check
  * @returns `true` if the value is a safe integer, `false` otherwise
  */
-export declare const isSafeInt: (a: number) => a is TtfImported_SafeInt;
+export declare const isSafeInt: (value: number) => value is SafeInt;
 /**
  * Casts a `number` to the `SafeInt` branded type.
  *
@@ -39,14 +39,7 @@ export declare const isSafeInt: (a: number) => a is TtfImported_SafeInt;
  * @returns The value as a `SafeInt`
  * @throws {TypeError} If the value is not a safe integer
  */
-export declare const asSafeInt: <N extends number>(x: N) => number & {
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-    readonly SafeInt: true;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asSafeInt: <N extends number>(value: N) => SafeInt & N;
 /**
  * Namespace providing type-safe operations for the `SafeInt` branded type.
  *
@@ -71,7 +64,7 @@ export declare const SafeInt: {
      * @returns `true` if the value is a safe integer, `false` otherwise
      * @see {@link isSafeInt} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_SafeInt;
+    readonly is: typeof isSafeInt;
     /**
      * The smallest value representable as `SafeInt` (the lower saturation target
      * of `fromNumber`).
@@ -81,7 +74,7 @@ export declare const SafeInt: {
      * The largest value representable as `SafeInt` (the upper saturation target
      * of `fromNumber`).
      */
-    readonly MAX_VALUE: SafeUint;
+    readonly MAX_VALUE: import("ts-type-forge").SafeUint;
     /**
      * Returns the absolute value of a safe integer.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAI9E,MAAM,MAAM,OAAO,GAAG,mBAAmB,CAAC;AAkC1C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS,yCAAK,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,SAAS;;;;;;;MAAW,CAAC;AAElC;;;;;GAKG;AACH,eAAO,MAAM,OAAO;IAClB;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAkBpE,MAAM,MAAM,OAAO,GAAG,mBAAmB,CAAC;AAM1C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS,UAAW,MAAM,KAAG,KAAK,IAAI,OACtB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,SAAS,CAAC,KAAG,OAAO,GAAG,CAMhE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,OAAO;IAClB;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,14 +1,8 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, MIN_VALUE, abs, add, div, fromNumber, max as max_, min as min_, mul, pow, random, sub, } from '../operators/safe-int.mjs';
 const typeNameInMessage = 'a safe integer';
-const { MAX_VALUE, MIN_VALUE, abs, add, castType, div, fromNumber, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
 
-    MIN_VALUE: Number.MIN_SAFE_INTEGER,
 
-    MAX_VALUE: Number.MAX_SAFE_INTEGER,
-    typeNameInMessage,
-});
 
 
 
@@ -25,9 +19,9 @@ const { MAX_VALUE, MIN_VALUE, abs, add, castType, div, fromNumber, is, max: max_
 
 
 
+export const isSafeInt = (value) => Number.isSafeInteger(value);
 
 
-export const isSafeInt = is;
 
 
 
@@ -46,9 +40,12 @@ export const isSafeInt = is;
 
 
 
-
-
-export const asSafeInt = castType;
+export const asSafeInt = (value) => {
+    if (!isSafeInt(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -73,7 +70,7 @@ export const SafeInt = {
 
 
 
-    is,
+    is: isSafeInt,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,gBAAgB,CAAC;AAE3C,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,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,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC,gBAA2B;IAC7C,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,QAAQ,CAAC;AAElC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,UAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM;IAEN;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,2BAA2B,CAAC;AAOnC,MAAM,iBAAiB,GAAG,gBAAgB,CAAC;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAa,EAAoB,EAAE,CAC3D,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAmB,KAAQ,EAAe,EAAE;IACnE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QACtB,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,OAAO,GAAG;IACrB;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE,EAAE,SAAS;IAEb;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,UAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM;IAEN;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}

package/dist/number/branded-types/safe-uint.d.mts

@@ -9,7 +9,7 @@ export type SafeUint = TtfImported_SafeUint;
  * @param value - The value to check
  * @returns `true` if the value is a non-negative safe integer, `false` otherwise
  */
-export declare const isSafeUint: (a: number) => a is TtfImported_SafeUint;
+export declare const isSafeUint: (value: number) => value is SafeUint;
 /**
  * Casts a `number` to the `SafeUint` branded type.
  *
@@ -20,19 +20,7 @@ export declare const isSafeUint: (a: number) => a is TtfImported_SafeUint;
  * @returns The value as a `SafeUint`
  * @throws {TypeError} If the value is not a non-negative safe integer
  */
-export declare const asSafeUint: <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 Int: true;
-    readonly NaNValue: false;
-    readonly SafeInt: true;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asSafeUint: <N extends number>(value: N) => SafeUint & N;
 /**
  * Namespace providing type-safe operations for the `SafeUint` branded type.
  *
@@ -47,7 +35,7 @@ export declare const SafeUint: {
      * @returns `true` if the value is a non-negative safe integer, `false` otherwise
      * @see {@link isSafeUint} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_SafeUint;
+    readonly is: typeof isSafeUint;
     /**
      * The smallest value representable as `SafeUint` (the lower saturation target
      * of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"safe-uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/safe-uint.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,IAAI,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAItE,MAAM,MAAM,QAAQ,GAAG,oBAAoB,CAAC;AAgC5C;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,0CAAK,CAAC;AAE7B;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;MAAW,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"safe-uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/safe-uint.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,IAAI,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAiBtE,MAAM,MAAM,QAAQ,GAAG,oBAAoB,CAAC;AAM5C;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,UAAW,MAAM,KAAG,KAAK,IAAI,QACT,CAAC;AAE5C;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,MAAM,SAAS,CAAC,KAAG,QAAQ,GAAG,CAMlE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/safe-uint.mjs

@@ -1,13 +1,7 @@
 
-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/safe-uint.mjs';
 const typeNameInMessage = 'a non-negative safe integer';
-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: Number.MAX_SAFE_INTEGER,
-    typeNameInMessage,
-});
 
 
 
@@ -16,8 +10,8 @@ const { MAX_VALUE, MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min
 
 
 
+export const isSafeUint = (value) => Number.isSafeInteger(value) && value >= 0;
 
-export const isSafeUint = is;
 
 
 
@@ -27,8 +21,12 @@ export const isSafeUint = is;
 
 
 
-
-export const asSafeUint = castType;
+export const asSafeUint = (value) => {
+    if (!isSafeUint(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -43,7 +41,7 @@ export const SafeUint = {
 
 
 
-    is,
+    is: isSafeUint,
 
 
 

package/dist/number/branded-types/safe-uint.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"safe-uint.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/safe-uint.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,6BAA6B,CAAC;AAExD,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,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,EAAE,CAAC;AAE7B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,QAAQ,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;OASG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;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":"safe-uint.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/safe-uint.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,4BAA4B,CAAC;AAOpC,MAAM,iBAAiB,GAAG,6BAA6B,CAAC;AAExD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAa,EAAqB,EAAE,CAC7D,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AAE5C;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAmB,KAAQ,EAAgB,EAAE;IACrE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,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,QAAQ,GAAG;IACtB;;;;;;OAMG;IACH,EAAE,EAAE,UAAU;IAEd;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;OASG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;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/uint.d.mts

@@ -20,7 +20,7 @@ export type Uint = TtfImported_Uint;
  * @param value - The value to check
  * @returns `true` if the value is a non-negative integer, `false` otherwise
  */
-export declare const isUint: (a: number) => a is import("ts-type-forge").NonNegativeInt;
+export declare const isUint: (value: number) => value is Uint;
 /**
  * Casts a `number` to the `Uint` branded type.
  *
@@ -41,18 +41,7 @@ export declare const isUint: (a: number) => a is import("ts-type-forge").NonNega
  * @returns The value as an `Uint`
  * @throws {TypeError} If the value is not a non-negative integer
  */
-export declare const asUint: <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 Int: true;
-    readonly NaNValue: false;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asUint: <N extends number>(value: N) => Uint & N;
 /**
  * Namespace providing type-safe operations for the `Uint` branded type.
  *
@@ -81,7 +70,7 @@ export declare const Uint: {
      * @returns `true` if the value is a non-negative integer, `false` otherwise
      * @see {@link isUint} for usage examples
      */
-    readonly is: (a: number) => a is import("ts-type-forge").NonNegativeInt;
+    readonly is: typeof isUint;
     /**
      * The smallest value representable as `Uint` (the lower saturation target of
      * `fromNumber`).

package/dist/number/branded-types/uint.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,IAAI,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAI9D,MAAM,MAAM,IAAI,GAAG,gBAAgB,CAAC;AA8BpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,4DAAK,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;MAAW,CAAC;AAE/B;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;OAGG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;OAeG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"uint.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,IAAI,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAgB9D,MAAM,MAAM,IAAI,GAAG,gBAAgB,CAAC;AAMpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,UAAW,MAAM,KAAG,KAAK,IAAI,IACT,CAAC;AAExC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,MAAM,SAAS,CAAC,KAAG,IAAI,GAAG,CAM1D,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;OAGG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;OAaG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;OAeG;;;;;;;;;;;;;;CAEK,CAAC"}

package/dist/number/branded-types/uint.mjs

@@ -1,12 +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/uint.mjs';
 const typeNameInMessage = 'a non-negative integer';
-const { MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'Integer',
-    MIN_VALUE: 0,
-    MAX_VALUE: Number.MAX_VALUE,
-    typeNameInMessage,
-});
 
 
 
@@ -27,7 +21,7 @@ const { MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min: min_, mul
 
 
 
-export const isUint = is;
+export const isUint = (value) => Number.isInteger(value) && value >= 0;
 
 
 
@@ -48,7 +42,12 @@ export const isUint = is;
 
 
 
-export const asUint = castType;
+export const asUint = (value) => {
+    if (!isUint(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -77,7 +76,7 @@ export const Uint = {
 
 
 
-    is,
+    is: isUint,
 
 
 

package/dist/number/branded-types/uint.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"uint.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/uint.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,wBAAwB,CAAC;AAEnD,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,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,SAAS;IAC/B,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,EAAE,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,QAAQ,CAAC;AAE/B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,UAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM;IAEN;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;OAeG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"uint.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/uint.mts"],"names":[],"mappings":"AACA,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,uBAAuB,CAAC;AAO/B,MAAM,iBAAiB,GAAG,wBAAwB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,KAAa,EAAiB,EAAE,CACrD,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AAExC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAmB,KAAQ,EAAY,EAAE;IAC7D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACnB,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,IAAI,GAAG;IAClB;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE,EAAE,MAAM;IAEV;;;OAGG;IACH,SAAS;IAET;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,UAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM;IAEN;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;OAeG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}

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

@@ -9,7 +9,7 @@ export type Uint16 = TtfImported_Uint16;
  * @param value - The value to check
  * @returns `true` if the value is a non-negative integer less than 2^16, `false` otherwise
  */
-export declare const isUint16: (a: number) => a is TtfImported_Uint16;
+export declare const isUint16: (value: number) => value is Uint16;
 /**
  * Casts a `number` to the `Uint16` branded type.
  *
@@ -20,22 +20,7 @@ export declare const isUint16: (a: number) => a is TtfImported_Uint16;
  * @returns The value as an `Uint16`
  * @throws {TypeError} If the value is not a non-negative integer less than 2^16
  */
-export declare const asUint16: <N extends number>(x: N) => number & {
-    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 asUint16: <N extends number>(value: N) => Uint16 & N;
 /**
  * Namespace providing type-safe operations for the `Uint16` branded type.
  *
@@ -50,7 +35,7 @@ export declare const Uint16: {
      * @returns `true` if the value is a non-negative integer less than 2^16, `false` otherwise
      * @see {@link isUint16} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_Uint16;
+    readonly is: typeof isUint16;
     /**
      * The smallest value representable as `Uint16` (the lower saturation target
      * of `fromNumber`).

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

@@ -1 +1 @@
-{"version":3,"file":"uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint16.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAIlE,MAAM,MAAM,MAAM,GAAG,kBAAkB,CAAC;AA+BxC;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,wCAAK,CAAC;AAE3B;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint16.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAiBlE,MAAM,MAAM,MAAM,GAAG,kBAAkB,CAAC;AAMxC;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,UAAW,MAAM,KAAG,KAAK,IAAI,MACiB,CAAC;AAEpE;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,SAAS,CAAC,KAAG,MAAM,GAAG,CAM9D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}