ts-data-forge 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -49,7 +49,7 @@ export { Uint32, asUint32, isUint32 } from './number/branded-types/uint32.mjs';
 export { Int8, asInt8, isInt8 } from './number/enum/int8.mjs';
 export { Uint8, asUint8, isUint8 } from './number/enum/uint8.mjs';
 export { Num } from './number/num.mjs';
-export { TsVerifiedInternals } from './number/refined-number-utils.mjs';
+export { TsDataForgeInternals } from './number/refined-number-utils.mjs';
 export { Obj } from './object/object.mjs';
 export { castDeepMutable, castMutable } from './others/cast-mutable.mjs';
 export { castDeepReadonly, castReadonly } from './others/cast-readonly.mjs';

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

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 type ElementType = FiniteNumber;
 /**
  * Type guard that checks if a value is a finite number.
@@ -115,7 +115,7 @@ export declare const FiniteNumber: {
      * FiniteNumber.abs(asFiniteNumber(3.2)); // FiniteNumber (3.2)
      * ```
      */
-    readonly abs: (x: FiniteNumber) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<FiniteNumber>;
+    readonly abs: (x: FiniteNumber) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<FiniteNumber>;
     /**
      * Returns the minimum value from a list of finite numbers.
      *
@@ -160,7 +160,7 @@ export declare const FiniteNumber: {
      * FiniteNumber.floor(asFiniteNumber(-5.2)); // Int (-6)
      * ```
      */
-    readonly floor: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Returns the smallest integer greater than or equal to the given finite number.
      * @param x - The finite number to ceil
@@ -171,7 +171,7 @@ export declare const FiniteNumber: {
      * FiniteNumber.ceil(asFiniteNumber(-5.8)); // Int (-5)
      * ```
      */
-    readonly ceil: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds a finite number to the nearest integer.
      * @param x - The finite number to round
@@ -183,7 +183,7 @@ export declare const FiniteNumber: {
      * FiniteNumber.round(asFiniteNumber(5.5)); // Int (6)
      * ```
      */
-    readonly round: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Generates a random finite number within the specified range.
      *
@@ -209,7 +209,7 @@ export declare const FiniteNumber: {
      * );
      * ```
      */
-    readonly random: (min: FiniteNumber, max: FiniteNumber) => FiniteNumber;
+    readonly random: (min?: FiniteNumber | undefined, max?: FiniteNumber | undefined) => FiniteNumber;
     /**
      * Raises a finite number to a power.
      * @param a - The base finite number

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

@@ -1 +1 @@
-{"version":3,"file":"finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,KAAK,WAAW,GAAG,YAAY,CAAC;AA8ChC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;OAOG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;OASG;wBAnLA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAqL1D;;;;;;;;;OASG;uBAzLA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA2L1D;;;;;;;;;;OAUG;wBAhMA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAkM1D;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,YAAY,CAAC;AAgDhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;OAOG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;;;;;;;OAeG;;IAGH;;;;;;;;;OASG;wBArLA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAuL3D;;;;;;;;;OASG;uBA3LA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA6L3D;;;;;;;;;;OAUG;wBAlMA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAoM3D;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;;;;;;;;CAEK,CAAC"}

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

@@ -1,9 +1,9 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a finite number';
-const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForFloat({
-    MIN_VALUE: undefined,
-    MAX_VALUE: undefined,
+const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
     typeNameInMessage,
 });
 const floor = (x) => 

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

@@ -1 +1 @@
-{"version":3,"file":"finite-number.mjs","sources":["../../../src/number/branded-types/finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iBAAiB;AAE3C,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,iBAAiB,CAI1D;AACA,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAE5E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA8D;AAE3E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAI5E;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;AASG;IACH,KAAK;AAEL;;;;;;;;;AASG;IACH,IAAI;AAEJ;;;;;;;;;;AAUG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"finite-number.mjs","sources":["../../../src/number/branded-types/finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,iBAAiB;AAE3C,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAM7E;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;AAeG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;AASG;IACH,KAAK;AAEL;;;;;;;;;AASG;IACH,IAAI;AAEJ;;;;;;;;;;AAUG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
  * Type guard that checks if a value is an integer.
  *
@@ -114,7 +114,7 @@ export declare const Int: {
      * Int.abs(asInt(-0));  // Int (0)
      * ```
      */
-    readonly abs: (x: WithSmallInt<Int, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<Int>;
+    readonly abs: (x: WithSmallInt<Int, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<Int>;
     /**
      * Returns the minimum value from a list of integers.
      *
@@ -163,7 +163,7 @@ export declare const Int: {
      * const temp = Int.random(asInt(-10), asInt(10));
      * ```
      */
-    readonly random: (min: WithSmallInt<Int, 40>, max: WithSmallInt<Int, 40>) => Int;
+    readonly random: (min?: WithSmallInt<Int, 40> | undefined, max?: WithSmallInt<Int, 40> | undefined) => Int;
     /**
      * Raises an integer to a power.
      * @param a - The base integer

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

@@ -1 +1 @@
-{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AA6BlE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,yBAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;OAOG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA6BnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,yBAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,KAAK;;;;;;MAAW,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,GAAG;IACd;;;;;;;OAOG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;OAWG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;;;;;;;;;;;;OAqBG;;;;;;;;;CAEK,CAAC"}

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

@@ -1,10 +1,10 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'an integer';
-const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+const { abs, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'Integer',
-    MIN_VALUE: undefined,
-    MAX_VALUE: undefined,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
     typeNameInMessage,
 });
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;;;;;"}
+{"version":3,"file":"int.mjs","sources":["../../../src/number/branded-types/int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,YAAY;AAEtC,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,KAAK,GAAG;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;AACI,MAAM,GAAG,GAAG;AACjB;;;;;;;AAOG;IACH,EAAE;AAEF;;;;;;;;;;;;;;;;AAgBG;IACH,GAAG;AAEH;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;AAWG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;;AAqBG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
  * Checks if a number is an Int16 (16-bit signed integer in the range [-2^15, 2^15)).
  * @param value The value to check.
@@ -81,7 +81,7 @@ export declare const Int16: {
      * @param a The Int16 value.
      * @returns The absolute value as an Int16, clamped to valid range.
      */
-    readonly abs: (x: WithSmallInt<Int16, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<Int16>;
+    readonly abs: (x: WithSmallInt<Int16, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<Int16>;
     /**
      * Returns the smaller of two Int16 values.
      * @param a The first Int16.
@@ -106,7 +106,7 @@ export declare const Int16: {
      * Generates a random Int16 value within the valid range.
      * @returns A random Int16 between MIN_VALUE and MAX_VALUE.
      */
-    readonly random: (min: WithSmallInt<Int16, 40>, max: WithSmallInt<Int16, 40>) => Int16;
+    readonly random: (min?: WithSmallInt<Int16, 40> | undefined, max?: WithSmallInt<Int16, 40> | undefined) => Int16;
     /**
      * Raises an Int16 to the power of another Int16.
      * @param a The base Int16.

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

@@ -1 +1 @@
-{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAgClE;;;;GAIG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,KAAK;IAChB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgCnE;;;;GAIG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,KAAK;IAChB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,7 +1,7 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'an integer in [-2^15, 2^15)';
-const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, abs, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, abs, pow, add, sub, mul, div, random, is, castType, clamp, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'SafeInteger',
     MIN_VALUE: -32768,
     MAX_VALUE: 2 ** 15 - 1,

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

@@ -1 +1 @@
-{"version":3,"file":"int16.mjs","sources":["../../../src/number/branded-types/int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;AAYG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,KAAK,GAAG;AACnB;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"int16.mjs","sources":["../../../src/number/branded-types/int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;AAYG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,KAAK,GAAG;AACnB;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
  * Checks if a number is an Int32 (32-bit signed integer in the range [-2^31, 2^31)).
  * @param value The value to check.
@@ -78,7 +78,7 @@ export declare const Int32: {
      * @param a The Int32 value.
      * @returns The absolute value as an Int32, clamped to valid range.
      */
-    readonly abs: (x: WithSmallInt<Int32, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<Int32>;
+    readonly abs: (x: WithSmallInt<Int32, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<Int32>;
     /**
      * Returns the smaller of two Int32 values.
      * @param a The first Int32.
@@ -103,7 +103,7 @@ export declare const Int32: {
      * Generates a random Int32 value within the valid range.
      * @returns A random Int32 between MIN_VALUE and MAX_VALUE.
      */
-    readonly random: (min: WithSmallInt<Int32, 40>, max: WithSmallInt<Int32, 40>) => Int32;
+    readonly random: (min?: WithSmallInt<Int32, 40> | undefined, max?: WithSmallInt<Int32, 40> | undefined) => Int32;
     /**
      * Raises an Int32 to the power of another Int32.
      * @param a The base Int32.

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

@@ -1 +1 @@
-{"version":3,"file":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAgClE;;;;GAIG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,KAAK;IAChB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAgCnE;;;;GAIG;AACH,eAAO,MAAM,OAAO,2BAAK,CAAC;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,KAAK;IAChB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,7 +1,7 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'an integer in [-2^31, 2^31)';
-const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, abs, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, abs, pow, add, sub, mul, div, random, is, castType, clamp, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'SafeInteger',
     MIN_VALUE: -2147483648,
     MAX_VALUE: 2 ** 31 - 1,

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

@@ -1 +1 @@
-{"version":3,"file":"int32.mjs","sources":["../../../src/number/branded-types/int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,WAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;AAYG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,KAAK,GAAG;AACnB;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"int32.mjs","sources":["../../../src/number/branded-types/int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,WAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;AAYG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,KAAK,GAAG;AACnB;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 type ElementType = NonNegativeFiniteNumber;
 /**
  * Checks if a number is a NonNegativeFiniteNumber (a finite number >= 0).
@@ -96,24 +96,24 @@ export declare const NonNegativeFiniteNumber: {
      * @param x The NonNegativeFiniteNumber to round down.
      * @returns The floor value as a Uint.
      */
-    readonly floor: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds up a NonNegativeFiniteNumber to the nearest integer.
      * @param x The NonNegativeFiniteNumber to round up.
      * @returns The ceiling value as a Uint.
      */
-    readonly ceil: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds a NonNegativeFiniteNumber to the nearest integer.
      * @param x The NonNegativeFiniteNumber to round.
      * @returns The rounded value as a Uint.
      */
-    readonly round: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Generates a random NonNegativeFiniteNumber value.
      * @returns A random non-negative finite number.
      */
-    readonly random: (min: NonNegativeFiniteNumber, max: NonNegativeFiniteNumber) => NonNegativeFiniteNumber;
+    readonly random: (min?: NonNegativeFiniteNumber | undefined, max?: NonNegativeFiniteNumber | undefined) => NonNegativeFiniteNumber;
     /**
      * Raises a NonNegativeFiniteNumber to the power of another NonNegativeFiniteNumber.
      * @param a The base NonNegativeFiniteNumber.

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":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAiD3C;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,6CAAK,CAAC;AAE5C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;wBAjHA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAmH1D;;;;OAIG;uBAlHA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAoH1D;;;;OAIG;wBAnHA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAqH1D;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,uBAAuB,CAAC;AAiD3C;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,6CAAK,CAAC;AAE5C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;wBAjHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAmH3D;;;;OAIG;uBAlHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAoH3D;;;;OAIG;wBAnHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAqH3D;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,9 +1,9 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a non-negative finite number';
-const { MIN_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForFloat({
+const { MIN_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
     MIN_VALUE: 0,
-    MAX_VALUE: undefined,
+    MAX_VALUE: Number.MAX_VALUE,
     typeNameInMessage,
 });
 const floor = (x) => 

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-finite-number.mjs","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,8BAA8B;AAExD,MAAM,EACJ,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,iBAAiB,CAI1D;AACA,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAE5E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA8D;AAE3E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAM5E;;;;AAIG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;;;;;AAYG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,uBAAuB,GAAG;AACrC;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,IAAI;AAEJ;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-negative-finite-number.mjs","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,8BAA8B;AAExD,MAAM,EACJ,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAM7E;;;;AAIG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;;;;;AAYG;AACI,MAAM,yBAAyB,GAAG;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,uBAAuB,GAAG;AACrC;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,IAAI;AAEJ;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -103,7 +103,7 @@ export declare const NonNegativeInt16: {
      * Generates a random NonNegativeInt16 value within the valid range.
      * @returns A random NonNegativeInt16 between 0 and 32767.
      */
-    readonly random: (min: WithSmallInt<NonNegativeInt16, 40>, max: WithSmallInt<NonNegativeInt16, 40>) => NonNegativeInt16;
+    readonly random: (min?: WithSmallInt<NonNegativeInt16, 40> | undefined, max?: WithSmallInt<NonNegativeInt16, 40> | undefined) => NonNegativeInt16;
     /**
      * Raises a NonNegativeInt16 to the power of another NonNegativeInt16.
      * @param a The base NonNegativeInt16.

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

@@ -1,7 +1,7 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a non-negative integer in [0, 2^15)';
-const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'SafeInteger',
     MIN_VALUE: 0,
     MAX_VALUE: 2 ** 15 - 1,

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int16.mjs","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;AAYG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-negative-int16.mjs","sources":["../../../src/number/branded-types/non-negative-int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;AAYG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -101,7 +101,7 @@ export declare const NonNegativeInt32: {
      * Generates a random NonNegativeInt32 value within the valid range.
      * @returns A random NonNegativeInt32 between 0 and 2147483647.
      */
-    readonly random: (min: WithSmallInt<NonNegativeInt32, 40>, max: WithSmallInt<NonNegativeInt32, 40>) => NonNegativeInt32;
+    readonly random: (min?: WithSmallInt<NonNegativeInt32, 40> | undefined, max?: WithSmallInt<NonNegativeInt32, 40> | undefined) => NonNegativeInt32;
     /**
      * Raises a NonNegativeInt32 to the power of another NonNegativeInt32.
      * @param a The base NonNegativeInt32.

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

@@ -1,7 +1,7 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a non-negative integer in [0, 2^31)';
-const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'SafeInteger',
     MIN_VALUE: 0,
     MAX_VALUE: 2 ** 31 - 1,

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

@@ -1 +1 @@
-{"version":3,"file":"non-negative-int32.mjs","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;AAYG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-negative-int32.mjs","sources":["../../../src/number/branded-types/non-negative-int32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;AAYG;AACI,MAAM,kBAAkB,GAAG;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,gBAAgB,GAAG;AAC9B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 type ElementType = NonZeroFiniteNumber;
 /**
  * Checks if a number is a NonZeroFiniteNumber (a finite number that is not 0).
@@ -70,7 +70,7 @@ export declare const NonZeroFiniteNumber: {
      * @param a The NonZeroFiniteNumber.
      * @returns The absolute value as a NonZeroFiniteNumber.
      */
-    readonly abs: (x: NonZeroFiniteNumber) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<NonZeroFiniteNumber>;
+    readonly abs: (x: NonZeroFiniteNumber) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroFiniteNumber>;
     /**
      * Returns the smaller of two NonZeroFiniteNumber values.
      * @param a The first NonZeroFiniteNumber.
@@ -90,24 +90,24 @@ export declare const NonZeroFiniteNumber: {
      * @param x The NonZeroFiniteNumber to round down.
      * @returns The floor value as a NonZeroInt.
      */
-    readonly floor: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds up a NonZeroFiniteNumber to the nearest integer.
      * @param x The NonZeroFiniteNumber to round up.
      * @returns The ceiling value as a NonZeroInt.
      */
-    readonly ceil: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly ceil: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Rounds a NonZeroFiniteNumber to the nearest integer.
      * @param x The NonZeroFiniteNumber to round.
      * @returns The rounded value as a NonZeroInt.
      */
-    readonly round: (x: ElementType) => TsVerifiedInternals.RefinedNumberUtils.ToInt<ElementType>;
+    readonly round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>;
     /**
      * Generates a random NonZeroFiniteNumber value.
      * @returns A random non-zero finite number.
      */
-    readonly random: (min: NonZeroFiniteNumber, max: NonZeroFiniteNumber) => NonZeroFiniteNumber;
+    readonly random: (min?: NonZeroFiniteNumber | undefined, max?: NonZeroFiniteNumber | undefined) => NonZeroFiniteNumber;
     /**
      * Raises a NonZeroFiniteNumber to the power of another NonZeroFiniteNumber.
      * @param a The base NonZeroFiniteNumber.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AA2DvC;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,yCAAK,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;wBAtHA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAwH1D;;;;OAIG;uBAvHA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAyH1D;;;;OAIG;wBAxHA,WAAW,KACb,mBAAmB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA0H1D;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AA2DvC;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,yCAAK,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;wBAtHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAwH3D;;;;OAIG;uBAvHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IAyH3D;;;;OAIG;wBAxHA,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC;IA0H3D;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;CAEK,CAAC"}

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

@@ -1,10 +1,10 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a non-zero finite number';
-const { abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: random, is, castType, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForFloat({
+const { abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: random, is, castType, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
     nonZero: true,
-    MIN_VALUE: undefined,
-    MAX_VALUE: undefined,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
     typeNameInMessage,
 });
 // Not provided because reasonable rounding operations that avoid becoming 0 cannot be defined

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-finite-number.mjs","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,EAAE,EACF,QAAQ,GACT,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,iBAAiB,CAI1D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX;AAEA,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAE5E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA8D;AAE3E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA8D;AAc5E;;;;AAIG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;;;AAYG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACI,MAAM,mBAAmB,GAAG;AACjC;;;;AAIG;IACH,EAAE;AAEF;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,IAAI;AAEJ;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-zero-finite-number.mjs","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,0BAA0B;AAEpD,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,EAAE,EACF,QAAQ,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;AACA,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;AAEA,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAE7E,MAAM,IAAI,GAAG,CACX,CAAc;AAEd;AACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D;AAE5E,MAAM,KAAK,GAAG,CACZ,CAAc;AAEd;AACA,IAAI,CAAC,KAAK,CAAC,CAAC,CAA+D;AAc7E;;;;AAIG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;;;AAYG;AACI,MAAM,qBAAqB,GAAG;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACI,MAAM,mBAAmB,GAAG;AACjC;;;;AAIG;IACH,EAAE;AAEF;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,IAAI;AAEJ;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
  * Checks if a number is a NonZeroInt.
  * @param value The value to check.
@@ -65,7 +65,7 @@ export declare const NonZeroInt: {
      * @param a The non-zero integer.
      * @returns The absolute value as a NonZeroInt.
      */
-    readonly abs: (x: WithSmallInt<NonZeroInt, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt>;
+    readonly abs: (x: WithSmallInt<NonZeroInt, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt>;
     /**
      * Returns the smaller of two non-zero integers.
      * @param a The first non-zero integer.
@@ -84,7 +84,7 @@ export declare const NonZeroInt: {
      * Generates a random non-zero integer.
      * @returns A random NonZeroInt value.
      */
-    readonly random: (min: WithSmallInt<NonZeroInt, 40>, max: WithSmallInt<NonZeroInt, 40>) => NonZeroInt;
+    readonly random: (min?: WithSmallInt<NonZeroInt, 40> | undefined, max?: WithSmallInt<NonZeroInt, 40> | undefined) => NonZeroInt;
     /**
      * Raises a non-zero integer to the power of another non-zero integer.
      * @param a The base non-zero integer.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AA8BlE;;;;GAIG;AACH,eAAO,MAAM,YAAY,gCAAK,CAAC;AAE/B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,UAAU;IACrB;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AA8BnE;;;;GAIG;AACH,eAAO,MAAM,YAAY,gCAAK,CAAC;AAE/B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,UAAU;IACrB;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;CAEK,CAAC"}

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

@@ -1,11 +1,11 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a non-zero integer';
-const { abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: random, is, castType, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+const { abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: random, is, castType, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'Integer',
     nonZero: true,
-    MIN_VALUE: undefined,
-    MAX_VALUE: undefined,
+    MIN_VALUE: -Number.MAX_VALUE,
+    MAX_VALUE: Number.MAX_VALUE,
     typeNameInMessage,
 });
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int.mjs","sources":["../../../src/number/branded-types/non-zero-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,EAAE,EACF,QAAQ,GACT,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,SAAS;AACpB,IAAA,SAAS,EAAE,SAAS;IACpB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;;;;;;;AAYG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,UAAU,GAAG;AACxB;;;;AAIG;IACH,EAAE;AAEF;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-zero-int.mjs","sources":["../../../src/number/branded-types/non-zero-int.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,oBAAoB;AAE9C,MAAM,EACJ,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,EAAE,EACF,QAAQ,GACT,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,CAAC,MAAM,CAAC,SAAS;IAC5B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;;;;;;;AAYG;AACI,MAAM,YAAY,GAAG;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,UAAU,GAAG;AACxB;;;;AAIG;IACH,EAAE;AAEF;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
  * Checks if a number is a NonZeroInt16 (16-bit non-zero signed integer in the range [-2^15, 2^15) excluding 0).
  * @param value The value to check.
@@ -85,7 +85,7 @@ export declare const NonZeroInt16: {
      * @param a The NonZeroInt16 value.
      * @returns The absolute value as a NonZeroInt16, clamped to valid range.
      */
-    readonly abs: (x: WithSmallInt<NonZeroInt16, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt16>;
+    readonly abs: (x: WithSmallInt<NonZeroInt16, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt16>;
     /**
      * Returns the smaller of two NonZeroInt16 values.
      * @param a The first NonZeroInt16.
@@ -110,7 +110,7 @@ export declare const NonZeroInt16: {
      * Generates a random NonZeroInt16 value within the valid range.
      * @returns A random NonZeroInt16 between MIN_VALUE and MAX_VALUE (excluding 0).
      */
-    readonly random: (min: WithSmallInt<NonZeroInt16, 40>, max: WithSmallInt<NonZeroInt16, 40>) => NonZeroInt16;
+    readonly random: (min?: WithSmallInt<NonZeroInt16, 40> | undefined, max?: WithSmallInt<NonZeroInt16, 40> | undefined) => NonZeroInt16;
     /**
      * Raises a NonZeroInt16 to the power of another NonZeroInt16.
      * @param a The base NonZeroInt16.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAiClE;;;;GAIG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,YAAY;IACvB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAiCnE;;;;GAIG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,YAAY;IACvB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,7 +1,7 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
 const typeNameInMessage = 'a non-zero integer in [-2^15, 2^15)';
-const { MIN_VALUE, MAX_VALUE, abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+const { MIN_VALUE, MAX_VALUE, abs, min: min_, max: max_, pow, add, sub, mul, div, randomNonZero: random, is, castType, clamp, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
     integerOrSafeInteger: 'SafeInteger',
     nonZero: true,
     MIN_VALUE: -32768,

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int16.mjs","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;AAYG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"non-zero-int16.mjs","sources":["../../../src/number/branded-types/non-zero-int16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,qCAAqC;AAE/D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,EACrB,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,OAAO,EAAE,IAAI;AACb,IAAA,SAAS,EAAE,MAAU;AACrB,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;AAYG;AACI,MAAM,cAAc,GAAG;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,YAAY,GAAG;AAC1B;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;IACH,GAAG;AAEH;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -1,4 +1,4 @@
-import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 /**
  * Checks if a number is a NonZeroInt32 (32-bit non-zero signed integer in the range [-2^31, 2^31) excluding 0).
  * @param value The value to check.
@@ -81,7 +81,7 @@ export declare const NonZeroInt32: {
      * @param a The NonZeroInt32 value.
      * @returns The absolute value as a NonZeroInt32, clamped to valid range.
      */
-    readonly abs: (x: WithSmallInt<NonZeroInt32, 40>) => TsVerifiedInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt32>;
+    readonly abs: (x: WithSmallInt<NonZeroInt32, 40>) => TsDataForgeInternals.RefinedNumberUtils.ToNonNegative<NonZeroInt32>;
     /**
      * Returns the smaller of two NonZeroInt32 values.
      * @param a The first NonZeroInt32.
@@ -106,7 +106,7 @@ export declare const NonZeroInt32: {
      * Generates a random NonZeroInt32 value within the valid range.
      * @returns A random NonZeroInt32 between MIN_VALUE and MAX_VALUE (excluding 0).
      */
-    readonly random: (min: WithSmallInt<NonZeroInt32, 40>, max: WithSmallInt<NonZeroInt32, 40>) => NonZeroInt32;
+    readonly random: (min?: WithSmallInt<NonZeroInt32, 40> | undefined, max?: WithSmallInt<NonZeroInt32, 40> | undefined) => NonZeroInt32;
     /**
      * Raises a NonZeroInt32 to the power of another NonZeroInt32.
      * @param a The base NonZeroInt32.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAiClE;;;;GAIG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,YAAY;IACvB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAiCnE;;;;GAIG;AACH,eAAO,MAAM,cAAc,kCAAK,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;MAAW,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,YAAY;IACvB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;;;;;;;;;;;;;CAEK,CAAC"}