ts-data-forge 14.10.1 → 14.11.0

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"}

package/dist/number/branded-types/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/uint16.mjs';
 const typeNameInMessage = 'a non-negative integer less than 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: 0,
-    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 isUint16 = is;
+export const isUint16 = (value) => Number.isSafeInteger(value) && 0 <= value && value <= 2 ** 16 - 1;
 
 
 
@@ -27,7 +21,12 @@ export const isUint16 = is;
 
 
 
-export const asUint16 = castType;
+export const asUint16 = (value) => {
+    if (!isUint16(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -42,7 +41,7 @@ export const Uint16 = {
 
 
 
-    is,
+    is: isUint16,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"uint16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/uint16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,uCAAuC,CAAC;AAElE,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,QAAQ,GAAG,EAAE,CAAC;AAE3B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,QAAQ,CAAC;AAEjC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB;;;;;;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;;;;;;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":"uint16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/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,yBAAyB,CAAC;AAOjC,MAAM,iBAAiB,GAAG,uCAAuC,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAa,EAAmB,EAAE,CACzD,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,QAAQ,GAAG,CAAmB,KAAQ,EAAc,EAAE;IACjE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACrB,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,MAAM,GAAG;IACpB;;;;;;OAMG;IACH,EAAE,EAAE,QAAQ;IAEZ;;;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;;;;;;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/uint32.d.mts

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

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

@@ -1 +1 @@
-{"version":3,"file":"uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint32.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":"uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint32.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"}

package/dist/number/branded-types/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/uint32.mjs';
 const typeNameInMessage = 'a non-negative integer less than 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: 0,
-    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 isUint32 = is;
+export const isUint32 = (value) => Number.isSafeInteger(value) && 0 <= value && value <= 2 ** 32 - 1;
 
 
 
@@ -27,7 +21,12 @@ export const isUint32 = is;
 
 
 
-export const asUint32 = castType;
+export const asUint32 = (value) => {
+    if (!isUint32(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -42,7 +41,7 @@ export const Uint32 = {
 
 
 
-    is,
+    is: isUint32,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"uint32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/uint32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,uCAAuC,CAAC;AAElE,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,QAAQ,GAAG,EAAE,CAAC;AAE3B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,QAAQ,CAAC;AAEjC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB;;;;;;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;;;;;;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":"uint32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/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,yBAAyB,CAAC;AAOjC,MAAM,iBAAiB,GAAG,uCAAuC,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAa,EAAmB,EAAE,CACzD,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,QAAQ,GAAG,CAAmB,KAAQ,EAAc,EAAE;IACjE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACrB,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,MAAM,GAAG;IACpB;;;;;;OAMG;IACH,EAAE,EAAE,QAAQ;IAEZ;;;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;;;;;;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/enum/int8.d.mts

@@ -1,17 +1,5 @@
 import type { AbsoluteValue, StrictExclude, Int8 as TtfImported_Int8 } from 'ts-type-forge';
 export type Int8 = TtfImported_Int8;
-declare const is: (x: number) => x is Int8;
-declare const castType: (x: number) => Int8;
-declare const fromNumber: (a: number) => Int8;
-declare const abs: <N extends Int8>(x: N) => AbsoluteValue<N>;
-declare const min_: (...values: readonly Int8[]) => Int8;
-declare const max_: (...values: readonly Int8[]) => Int8;
-declare const pow: (x: Int8, y: Int8) => Int8;
-declare const add: (x: Int8, y: Int8) => Int8;
-declare const sub: (x: Int8, y: Int8) => Int8;
-declare const mul: (x: Int8, y: Int8) => Int8;
-declare const div: (x: Int8, y: StrictExclude<Int8, 0>) => Int8;
-declare const random: (min: Int8, max: Int8) => Int8;
 /**
  * Type guard that checks if a value is an integer in [-128, 127].
  *
@@ -21,7 +9,7 @@ declare const random: (min: Int8, max: Int8) => Int8;
  * @param value - The value to check
  * @returns `true` if the value is an integer in [-128, 127], `false` otherwise
  */
-export declare const isInt8: typeof is;
+export declare const isInt8: (value: number) => value is Int8;
 /**
  * Casts a `number` to the `Int8` branded type.
  *
@@ -32,7 +20,17 @@ export declare const isInt8: typeof is;
  * @returns The value as an `Int8`
  * @throws {TypeError} If the value is not an integer in [-128, 127]
  */
-export declare const asInt8: typeof castType;
+export declare const asInt8: (value: number) => Int8;
+declare const fromNumber: (a: number) => Int8;
+declare const abs: <N extends Int8>(x: N) => AbsoluteValue<N>;
+declare const min_: (...values: readonly Int8[]) => Int8;
+declare const max_: (...values: readonly Int8[]) => Int8;
+declare const pow: (x: Int8, y: Int8) => Int8;
+declare const add: (x: Int8, y: Int8) => Int8;
+declare const sub: (x: Int8, y: Int8) => Int8;
+declare const mul: (x: Int8, y: Int8) => Int8;
+declare const div: (x: Int8, y: StrictExclude<Int8, 0>) => Int8;
+declare const random: (min: Int8, max: Int8) => Int8;
 /**
  * Namespace providing type-safe operations for the `Int8` branded type.
  *
@@ -47,7 +45,7 @@ export declare const Int8: {
      * @returns `true` if the value is an integer in [-128, 127], `false` otherwise
      * @see {@link isInt8} for usage examples
      */
-    readonly is: typeof is;
+    readonly is: typeof isInt8;
     /**
      * The smallest value representable as `Int8` (the lower saturation target of
      * `fromNumber`).

package/dist/number/enum/int8.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"int8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/int8.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,aAAa,EACb,IAAI,IAAI,gBAAgB,EACzB,MAAM,eAAe,CAAC;AAIvB,MAAM,MAAM,IAAI,GAAG,gBAAgB,CAAC;AAsBpC,QAAA,MAAM,EAAE,MAAO,MAAM,KAAG,CAAC,IAAI,IAAiB,CAAC;AAE/C,QAAA,MAAM,QAAQ,MAAO,MAAM,KAAG,IAEL,CAAC;AAE1B,QAAA,MAAM,UAAU,MAAO,MAAM,KAAG,IAAmC,CAAC;AAEpE,QAAA,MAAM,GAAG,GAAI,CAAC,SAAS,IAAI,KAAK,CAAC,KAAG,aAAa,CAAC,CAAC,CAEP,CAAC;AAE7C,QAAA,MAAM,IAAI,cAAe,SAAS,IAAI,EAAE,KAAG,IACZ,CAAC;AAEhC,QAAA,MAAM,IAAI,cAAe,SAAS,IAAI,EAAE,KAAG,IACZ,CAAC;AAEhC,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAA0B,CAAC;AAE3D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAAyB,CAAC;AAE1D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAAyB,CAAC;AAE1D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAAyB,CAAC;AAE1D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC,KAAG,IACnB,CAAC;AAEhC,QAAA,MAAM,MAAM,QAAS,IAAI,OAAO,IAAI,KAAG,IACqB,CAAC;AAE7D;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,WAAK,CAAC;AAEzB;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,iBAAW,CAAC;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}
+{"version":3,"file":"int8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/int8.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAEb,aAAa,EACb,IAAI,IAAI,gBAAgB,EACzB,MAAM,eAAe,CAAC;AAWvB,MAAM,MAAM,IAAI,GAAG,gBAAgB,CAAC;AAIpC;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,UAAW,MAAM,KAAG,KAAK,IAAI,IACc,CAAC;AAE/D;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,UAAW,MAAM,KAAG,IAMtC,CAAC;AAEF,QAAA,MAAM,UAAU,MAAO,MAAM,KAAG,IAAiC,CAAC;AAElE,QAAA,MAAM,GAAG,GAAI,CAAC,SAAS,IAAI,KAAK,CAAC,KAAG,aAAa,CAAC,CAAC,CAEP,CAAC;AAE7C,QAAA,MAAM,IAAI,cAAe,SAAS,IAAI,EAAE,KAAG,IAAmC,CAAC;AAE/E,QAAA,MAAM,IAAI,cAAe,SAAS,IAAI,EAAE,KAAG,IAAmC,CAAC;AAE/E,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAA0B,CAAC;AAE3D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAAyB,CAAC;AAE1D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAAyB,CAAC;AAE1D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,IAAI,KAAG,IAAyB,CAAC;AAE1D,QAAA,MAAM,GAAG,MAAO,IAAI,KAAK,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC,KAAG,IACnB,CAAC;AAEhC,QAAA,MAAM,MAAM,QAAS,IAAI,OAAO,IAAI,KAAG,IACmB,CAAC;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

package/dist/number/enum/int8.mjs

@@ -1,28 +1,7 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, MIN_VALUE, castType as castTypeImpl, fromNumber as fromNumberImpl, random as randomImpl, } from '../operators/int8.mjs';
 const typeNameInMessage = 'an integer in [-128, 127]';
-const { MAX_VALUE, MIN_VALUE, castType: castTypeImpl, fromNumber: fromNumberImpl, is: isImpl, random: randomImpl, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    MIN_VALUE: -128,
-    MAX_VALUE: 127,
-    typeNameInMessage,
-});
-const is = (x) => isImpl(x);
-const castType = (x) => 
-
-castTypeImpl(x);
-const fromNumber = (a) => castType(fromNumberImpl(a));
-const abs = (x) => 
 
-Math.abs(x);
-const min_ = (...values) => castType(Math.min(...values));
-const max_ = (...values) => castType(Math.max(...values));
-const pow = (x, y) => fromNumber(x ** y);
-const add = (x, y) => fromNumber(x + y);
-const sub = (x, y) => fromNumber(x - y);
-const mul = (x, y) => fromNumber(x * y);
-const div = (x, y) => fromNumber(Math.floor(x / y));
-const random = (min, max) => castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));
 
 
 
@@ -31,8 +10,8 @@ const random = (min, max) => castType(randomImpl(castTypeImpl(min), castTypeImpl
 
 
 
+export const isInt8 = (value) => Number.isSafeInteger(value) && -128 <= value && value <= 127;
 
-export const isInt8 = is;
 
 
 
@@ -42,8 +21,24 @@ export const isInt8 = is;
 
 
 
+export const asInt8 = (value) => {
+    if (!isInt8(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
+const fromNumber = (a) => asInt8(fromNumberImpl(a));
+const abs = (x) => 
 
-export const asInt8 = castType;
+Math.abs(x);
+const min_ = (...values) => asInt8(Math.min(...values));
+const max_ = (...values) => asInt8(Math.max(...values));
+const pow = (x, y) => fromNumber(x ** y);
+const add = (x, y) => fromNumber(x + y);
+const sub = (x, y) => fromNumber(x - y);
+const mul = (x, y) => fromNumber(x * y);
+const div = (x, y) => fromNumber(Math.floor(x / y));
+const random = (min, max) => asInt8(randomImpl(castTypeImpl(min), castTypeImpl(max)));
 
 
 
@@ -58,7 +53,7 @@ export const Int8 = {
 
 
 
-    is,
+    is: isInt8,
 
 
 

package/dist/number/enum/int8.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"int8.mjs","sourceRoot":"","sources":["../../../src/number/enum/int8.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"int8.mjs","sourceRoot":"","sources":["../../../src/number/enum/int8.mts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,QAAQ,IAAI,YAAY,EACxB,UAAU,IAAI,cAAc,EAC5B,MAAM,IAAI,UAAU,GACrB,MAAM,uBAAuB,CAAC;AAK/B,MAAM,iBAAiB,GAAG,2BAA2B,CAAC;AAEtD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,KAAa,EAAiB,EAAE,CACrD,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,KAAK,IAAI,KAAK,IAAI,GAAG,CAAC;AAE/D;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,KAAa,EAAQ,EAAE;IAC5C,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,MAAM,UAAU,GAAG,CAAC,CAAS,EAAQ,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;AAElE,MAAM,GAAG,GAAG,CAAiB,CAAI,EAAoB,EAAE;AACrD,kOAAkO;AAClO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAgC,CAAC;AAE7C,MAAM,IAAI,GAAG,CAAC,GAAG,MAAuB,EAAQ,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;AAE/E,MAAM,IAAI,GAAG,CAAC,GAAG,MAAuB,EAAQ,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;AAE/E,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,EAAQ,EAAE,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;AAE3D,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,EAAQ,EAAE,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAE1D,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,EAAQ,EAAE,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAE1D,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,EAAQ,EAAE,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAE1D,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAyB,EAAQ,EAAE,CACvD,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAEhC,MAAM,MAAM,GAAG,CAAC,GAAS,EAAE,GAAS,EAAQ,EAAE,CAC5C,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAE3D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB;;;;;;OAMG;IACH,EAAE,EAAE,MAAM;IAEV;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;OASG;IACH,UAAU;IAEV;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;;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"}

package/dist/number/enum/uint8.d.mts

@@ -1,16 +1,5 @@
 import type { StrictExclude, Uint8 as TtfImported_Uint8 } from 'ts-type-forge';
 export type Uint8 = TtfImported_Uint8;
-declare const is: (x: number) => x is Uint8;
-declare const castType: (x: number) => Uint8;
-declare const fromNumber: (a: number) => Uint8;
-declare const min_: (...values: readonly Uint8[]) => Uint8;
-declare const max_: (...values: readonly Uint8[]) => Uint8;
-declare const pow: (x: Uint8, y: Uint8) => Uint8;
-declare const add: (x: Uint8, y: Uint8) => Uint8;
-declare const sub: (x: Uint8, y: Uint8) => Uint8;
-declare const mul: (x: Uint8, y: Uint8) => Uint8;
-declare const div: (x: Uint8, y: StrictExclude<Uint8, 0>) => Uint8;
-declare const random: (min: Uint8, max: Uint8) => Uint8;
 /**
  * Type guard that checks if a value is an non-negative integer less than 256.
  *
@@ -20,7 +9,7 @@ declare const random: (min: Uint8, max: Uint8) => Uint8;
  * @param value - The value to check
  * @returns `true` if the value is an non-negative integer less than 256, `false` otherwise
  */
-export declare const isUint8: typeof is;
+export declare const isUint8: (value: number) => value is Uint8;
 /**
  * Casts a `number` to the `Uint8` branded type.
  *
@@ -31,7 +20,16 @@ export declare const isUint8: typeof is;
  * @returns The value as an `Uint8`
  * @throws {TypeError} If the value is not an non-negative integer less than 256
  */
-export declare const asUint8: typeof castType;
+export declare const asUint8: (value: number) => Uint8;
+declare const fromNumber: (a: number) => Uint8;
+declare const min_: (...values: readonly Uint8[]) => Uint8;
+declare const max_: (...values: readonly Uint8[]) => Uint8;
+declare const pow: (x: Uint8, y: Uint8) => Uint8;
+declare const add: (x: Uint8, y: Uint8) => Uint8;
+declare const sub: (x: Uint8, y: Uint8) => Uint8;
+declare const mul: (x: Uint8, y: Uint8) => Uint8;
+declare const div: (x: Uint8, y: StrictExclude<Uint8, 0>) => Uint8;
+declare const random: (min: Uint8, max: Uint8) => Uint8;
 /**
  * Namespace providing type-safe operations for the `Uint8` branded type.
  *
@@ -46,7 +44,7 @@ export declare const Uint8: {
      * @returns `true` if the value is an non-negative integer less than 256, `false` otherwise
      * @see {@link isUint8} for usage examples
      */
-    readonly is: typeof is;
+    readonly is: typeof isUint8;
     /**
      * The smallest value representable as `Uint8` (the lower saturation target of
      * `fromNumber`).

package/dist/number/enum/uint8.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"uint8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/uint8.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,KAAK,IAAI,iBAAiB,EAE3B,MAAM,eAAe,CAAC;AAIvB,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAoBtC,QAAA,MAAM,EAAE,MAAO,MAAM,KAAG,CAAC,IAAI,KAAkB,CAAC;AAEhD,QAAA,MAAM,QAAQ,MAAO,MAAM,KAAG,KAEJ,CAAC;AAE3B,QAAA,MAAM,UAAU,MAAO,MAAM,KAAG,KAAoC,CAAC;AAErE,QAAA,MAAM,IAAI,cAAe,SAAS,KAAK,EAAE,KAAG,KACb,CAAC;AAEhC,QAAA,MAAM,IAAI,cAAe,SAAS,KAAK,EAAE,KAAG,KACb,CAAC;AAEhC,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA2B,CAAC;AAE9D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA0B,CAAC;AAE7D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA0B,CAAC;AAE7D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA0B,CAAC;AAE7D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,KAAG,KACrB,CAAC;AAEhC,QAAA,MAAM,MAAM,QAAS,KAAK,OAAO,KAAK,KAAG,KACmB,CAAC;AAE7D;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,WAAK,CAAC;AAE1B;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,iBAAW,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;;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":"uint8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/uint8.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,KAAK,IAAI,iBAAiB,EAE3B,MAAM,eAAe,CAAC;AAWvB,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAItC;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,UAAW,MAAM,KAAG,KAAK,IAAI,KACU,CAAC;AAE5D;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,UAAW,MAAM,KAAG,KAMvC,CAAC;AAEF,QAAA,MAAM,UAAU,MAAO,MAAM,KAAG,KAAmC,CAAC;AAEpE,QAAA,MAAM,IAAI,cAAe,SAAS,KAAK,EAAE,KAAG,KACd,CAAC;AAE/B,QAAA,MAAM,IAAI,cAAe,SAAS,KAAK,EAAE,KAAG,KACd,CAAC;AAE/B,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA2B,CAAC;AAE9D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA0B,CAAC;AAE7D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA0B,CAAC;AAE7D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,KAAK,KAAG,KAA0B,CAAC;AAE7D,QAAA,MAAM,GAAG,MAAO,KAAK,KAAK,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,KAAG,KACrB,CAAC;AAEhC,QAAA,MAAM,MAAM,QAAS,KAAK,OAAO,KAAK,KAAG,KACkB,CAAC;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;;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"}

package/dist/number/enum/uint8.mjs

@@ -1,25 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, MIN_VALUE, castType as castTypeImpl, fromNumber as fromNumberImpl, random as randomImpl, } from '../operators/uint8.mjs';
 const typeNameInMessage = 'an non-negative integer less than 256';
-const { MAX_VALUE, MIN_VALUE, castType: castTypeImpl, fromNumber: fromNumberImpl, is: isImpl, random: randomImpl, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    MIN_VALUE: 0,
-    MAX_VALUE: 255,
-    typeNameInMessage,
-});
-const is = (x) => isImpl(x);
-const castType = (x) => 
-
-castTypeImpl(x);
-const fromNumber = (a) => castType(fromNumberImpl(a));
-const min_ = (...values) => castType(Math.min(...values));
-const max_ = (...values) => castType(Math.max(...values));
-const pow = (x, y) => fromNumber(x ** y);
-const add = (x, y) => fromNumber(x + y);
-const sub = (x, y) => fromNumber(x - y);
-const mul = (x, y) => fromNumber(x * y);
-const div = (x, y) => fromNumber(Math.floor(x / y));
-const random = (min, max) => castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));
 
 
 
@@ -29,7 +10,7 @@ const random = (min, max) => castType(randomImpl(castTypeImpl(min), castTypeImpl
 
 
 
-export const isUint8 = is;
+export const isUint8 = (value) => Number.isSafeInteger(value) && 0 <= value && value <= 255;
 
 
 
@@ -40,7 +21,21 @@ export const isUint8 = is;
 
 
 
-export const asUint8 = castType;
+export const asUint8 = (value) => {
+    if (!isUint8(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
+const fromNumber = (a) => asUint8(fromNumberImpl(a));
+const min_ = (...values) => asUint8(Math.min(...values));
+const max_ = (...values) => asUint8(Math.max(...values));
+const pow = (x, y) => fromNumber(x ** y);
+const add = (x, y) => fromNumber(x + y);
+const sub = (x, y) => fromNumber(x - y);
+const mul = (x, y) => fromNumber(x * y);
+const div = (x, y) => fromNumber(Math.floor(x / y));
+const random = (min, max) => asUint8(randomImpl(castTypeImpl(min), castTypeImpl(max)));
 
 
 
@@ -55,7 +50,7 @@ export const Uint8 = {
 
 
 
-    is,
+    is: isUint8,