ts-data-forge 14.7.0 → 14.8.0

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

@@ -1,4 +1,4 @@
-import { type Int32 as TtfImported_Int32 } from 'ts-type-forge';
+import type { Int32 as TtfImported_Int32 } from 'ts-type-forge';
 export type Int32 = TtfImported_Int32;
 /**
  * Type guard that checks if a value is an integer in [-2^31, 2^31).

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":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIhE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/int32.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIhE,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AAgCtC;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,uCAAK,CAAC;AAE1B;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;MAAW,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;OAOG;;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/negative-finite-number.d.mts

@@ -1,4 +1,4 @@
-import { type NegativeFiniteNumber as TtfImported_NegativeFiniteNumber } from 'ts-type-forge';
+import type { NegativeFiniteNumber as TtfImported_NegativeFiniteNumber } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 import { PositiveFiniteNumber } from './positive-finite-number.mjs';
 export type NegativeFiniteNumber = TtfImported_NegativeFiniteNumber;

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

@@ -1 +1 @@
-{"version":3,"file":"negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,IAAI,gCAAgC,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AA0BxC,QAAA,MAAM,GAAG,MAAO,WAAW,KAAG,oBACgB,CAAC;AAE/C,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAKzD,CAAC;AAEJ,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}
+{"version":3,"file":"negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,IAAI,gCAAgC,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AA0BxC,QAAA,MAAM,GAAG,MAAO,WAAW,KAAG,oBACgB,CAAC;AAE/C,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAKzD,CAAC;AAEJ,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type NegativeInt as TtfImported_NegativeInt, type WithSmallInt } from 'ts-type-forge';
+import type { NegativeInt as TtfImported_NegativeInt, WithSmallInt } from 'ts-type-forge';
 import { PositiveInt } from './positive-int.mjs';
 export type NegativeInt = TtfImported_NegativeInt;
 type ElementType = NegativeInt;

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

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

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

@@ -1,4 +1,4 @@
-import { type NegativeSafeInt as TtfImported_NegativeSafeInt, type WithSmallInt } from 'ts-type-forge';
+import type { NegativeSafeInt as TtfImported_NegativeSafeInt, WithSmallInt } from 'ts-type-forge';
 import { PositiveSafeInt } from './positive-safe-int.mjs';
 export type NegativeSafeInt = TtfImported_NegativeSafeInt;
 type ElementType = NegativeSafeInt;

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

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

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

@@ -1,4 +1,4 @@
-import { type NonNegativeFiniteNumber as TtfImported_NonNegativeFiniteNumber } from 'ts-type-forge';
+import type { NonNegativeFiniteNumber as TtfImported_NonNegativeFiniteNumber } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type NonNegativeFiniteNumber = TtfImported_NonNegativeFiniteNumber;
 type ElementType = 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":"AAAA,OAAO,EACL,KAAK,uBAAuB,IAAI,mCAAmC,EAEpE,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AA2B3C,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAM9E;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,yDAAK,CAAC;AAE5C;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-negative-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-negative-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,IAAI,mCAAmC,EAE/D,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG,mCAAmC,CAAC;AAE1E,KAAK,WAAW,GAAG,uBAAuB,CAAC;AA2B3C,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAM9E;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,yDAAK,CAAC;AAE5C;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;MAAW,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type NonNegativeInt16 as TtfImported_NonNegativeInt16 } from 'ts-type-forge';
+import type { NonNegativeInt16 as TtfImported_NonNegativeInt16 } from 'ts-type-forge';
 export type NonNegativeInt16 = TtfImported_NonNegativeInt16;
 /**
  * Type guard that checks if a value is a non-negative integer in [0, 2^15).

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

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

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

@@ -1,4 +1,4 @@
-import { type NonNegativeInt32 as TtfImported_NonNegativeInt32 } from 'ts-type-forge';
+import type { NonNegativeInt32 as TtfImported_NonNegativeInt32 } from 'ts-type-forge';
 export type NonNegativeInt32 = TtfImported_NonNegativeInt32;
 /**
  * Type guard that checks if a value is a non-negative integer in [0, 2^31).

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

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

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

@@ -1,4 +1,4 @@
-import { type NonPositiveFiniteNumber as TtfImported_NonPositiveFiniteNumber } from 'ts-type-forge';
+import type { NonPositiveFiniteNumber as TtfImported_NonPositiveFiniteNumber } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type NonPositiveFiniteNumber = TtfImported_NonPositiveFiniteNumber;
 type ElementType = NonPositiveFiniteNumber;

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

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

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

@@ -1,4 +1,4 @@
-import { type NonPositiveInt as TtfImported_NonPositiveInt } from 'ts-type-forge';
+import type { NonPositiveInt as TtfImported_NonPositiveInt } from 'ts-type-forge';
 export type NonPositiveInt = TtfImported_NonPositiveInt;
 /**
  * Type guard that checks if a value is a non-positive integer.

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

@@ -1 +1 @@
-{"version":3,"file":"non-positive-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-int.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAGlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AA4BxD;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,gDAAK,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}
+{"version":3,"file":"non-positive-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-positive-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAGlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AA4BxD;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,gDAAK,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type NonPositiveSafeInt as TtfImported_NonPositiveSafeInt } from 'ts-type-forge';
+import type { NonPositiveSafeInt as TtfImported_NonPositiveSafeInt } from 'ts-type-forge';
 export type NonPositiveSafeInt = TtfImported_NonPositiveSafeInt;
 /**
  * Type guard that checks if a value is a non-positive safe integer.

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

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

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

@@ -1,4 +1,4 @@
-import { type NonZeroFiniteNumber as TtfImported_NonZeroFiniteNumber } from 'ts-type-forge';
+import type { NonZeroFiniteNumber as TtfImported_NonZeroFiniteNumber } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type NonZeroFiniteNumber = TtfImported_NonZeroFiniteNumber;
 type ElementType = 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":"AAAA,OAAO,EAIL,KAAK,mBAAmB,IAAI,+BAA+B,EAC5D,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,mBAAmB,GAAG,+BAA+B,CAAC;AAElE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AAyBvC,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAc9E;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,qDAAK,CAAC;AAExC;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;;;;OAWG;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,mBAAmB,IAAI,+BAA+B,EACvD,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,mBAAmB,GAAG,+BAA+B,CAAC;AAElE,KAAK,WAAW,GAAG,mBAAmB,CAAC;AAyBvC,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAE9E,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEiB,CAAC;AAc9E;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,qDAAK,CAAC;AAExC;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;;;MAAW,CAAC;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;;;;;OAWG;;;;;;;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type NonZeroInt as TtfImported_NonZeroInt } from 'ts-type-forge';
+import type { NonZeroInt as TtfImported_NonZeroInt } from 'ts-type-forge';
 export type NonZeroInt = TtfImported_NonZeroInt;
 /**
  * Type guard that checks if a value is a non-zero integer.

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,IAAI,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAI1E,MAAM,MAAM,UAAU,GAAG,sBAAsB,CAAC;AA2BhD;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,4CAAK,CAAC;AAE/B;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU;IACrB;;;;;;OAMG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,IAAI,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAI1E,MAAM,MAAM,UAAU,GAAG,sBAAsB,CAAC;AA2BhD;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,4CAAK,CAAC;AAE/B;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY;;;;;;;MAAW,CAAC;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU;IACrB;;;;;;OAMG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type NonZeroInt16 as TtfImported_NonZeroInt16 } from 'ts-type-forge';
+import type { NonZeroInt16 as TtfImported_NonZeroInt16 } from 'ts-type-forge';
 export type NonZeroInt16 = TtfImported_NonZeroInt16;
 /**
  * Type guard that checks if a value is a non-zero integer in [-2^15, 2^15).

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

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

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

@@ -1,4 +1,4 @@
-import { type NonZeroInt32 as TtfImported_NonZeroInt32 } from 'ts-type-forge';
+import type { NonZeroInt32 as TtfImported_NonZeroInt32 } from 'ts-type-forge';
 export type NonZeroInt32 = TtfImported_NonZeroInt32;
 /**
  * Type guard that checks if a value is a non-zero integer in [-2^31, 2^31).

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

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

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

@@ -1,4 +1,4 @@
-import { type SafeInt, type SafeUint, type NonZeroSafeInt as TtfImported_NonZeroSafeInt } from 'ts-type-forge';
+import type { SafeInt, SafeUint, NonZeroSafeInt as TtfImported_NonZeroSafeInt } from 'ts-type-forge';
 export type NonZeroSafeInt = TtfImported_NonZeroSafeInt;
 /**
  * Type guard that checks if a value is a non-zero safe integer.

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

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

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

@@ -1,4 +1,4 @@
-import { type NonZeroUint16 as TtfImported_NonZeroUint16 } from 'ts-type-forge';
+import type { NonZeroUint16 as TtfImported_NonZeroUint16 } from 'ts-type-forge';
 export type NonZeroUint16 = TtfImported_NonZeroUint16;
 /**
  * Type guard that checks if a value is a non-zero integer in [1, 2^16).

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AA8BtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,4DAAK,CAAC;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint16.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AA8BtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,4DAAK,CAAC;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type NonZeroUint32 as TtfImported_NonZeroUint32 } from 'ts-type-forge';
+import type { NonZeroUint32 as TtfImported_NonZeroUint32 } from 'ts-type-forge';
 export type NonZeroUint32 = TtfImported_NonZeroUint32;
 /**
  * Type guard that checks if a value is a non-zero integer in [1, 2^32).

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AA8BtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,4DAAK,CAAC;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}
+{"version":3,"file":"non-zero-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint32.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AA8BtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,4DAAK,CAAC;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type PositiveFiniteNumber as TtfImported_PositiveFiniteNumber } from 'ts-type-forge';
+import type { PositiveFiniteNumber as TtfImported_PositiveFiniteNumber } from 'ts-type-forge';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type PositiveFiniteNumber = TtfImported_PositiveFiniteNumber;
 type ElementType = PositiveFiniteNumber;

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

@@ -1 +1 @@
-{"version":3,"file":"positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,oBAAoB,IAAI,gCAAgC,EAE9D,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AA2BxC,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAcJ;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-finite-number.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,oBAAoB,IAAI,gCAAgC,EAEzD,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AA2BxC,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAEJ,QAAA,MAAM,IAAI,MACL,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAEgB,CAAC;AAE7E,QAAA,MAAM,KAAK,MACN,WAAW,KACb,oBAAoB,CAAC,kBAAkB,CAAC,qBAAqB,CAC9D,oBAAoB,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,CAAC,CAOzD,CAAC;AAcJ;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,sDAAK,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;MAAW,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;IAC/B;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type PositiveInt as TtfImported_PositiveInt } from 'ts-type-forge';
+import type { PositiveInt as TtfImported_PositiveInt } from 'ts-type-forge';
 export type PositiveInt = TtfImported_PositiveInt;
 /**
  * Type guard that checks if a value is a positive integer.
@@ -166,7 +166,7 @@ export declare const PositiveInt: {
      *
      * assert.isTrue(PositiveInt.is(randomValue));
      *
-     * assert.isTrue(randomValue >= 3 && randomValue <= 6);
+     * assert.isTrue(3 <= randomValue && randomValue <= 6);
      * ```
      *
      * @param min - The minimum value (inclusive)

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,IAAI,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAI5E,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AA8BlD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,6CAAK,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;OAGG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,IAAI,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAI5E,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AA8BlD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,6CAAK,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;MAAW,CAAC;AAEtC;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;IACtB;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;OAGG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type PositiveInt16 as TtfImported_PositiveInt16 } from 'ts-type-forge';
+import type { PositiveInt16 as TtfImported_PositiveInt16 } from 'ts-type-forge';
 export type PositiveInt16 = TtfImported_PositiveInt16;
 /**
  * Type guard that checks if a value is a positive integer in [1, 2^15).

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AA+BtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,+CAAK,CAAC;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-int16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int16.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AA+BtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,+CAAK,CAAC;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type PositiveInt32 as TtfImported_PositiveInt32 } from 'ts-type-forge';
+import type { PositiveInt32 as TtfImported_PositiveInt32 } from 'ts-type-forge';
 export type PositiveInt32 = TtfImported_PositiveInt32;
 /**
  * Type guard that checks if a value is a positive integer in [1, 2^31).

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AA+BtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,+CAAK,CAAC;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-int32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int32.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAIhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AA+BtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,+CAAK,CAAC;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;MAAW,CAAC;AAExC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;IACxB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type SafeUint, type PositiveSafeInt as TtfImported_PositiveSafeInt } from 'ts-type-forge';
+import type { SafeUint, PositiveSafeInt as TtfImported_PositiveSafeInt } from 'ts-type-forge';
 export type PositiveSafeInt = TtfImported_PositiveSafeInt;
 /**
  * Type guard that checks if a value is a positive safe integer.
@@ -175,7 +175,7 @@ export declare const PositiveSafeInt: {
      *
      * assert.isTrue(PositiveSafeInt.is(randomValue));
      *
-     * assert.isTrue(randomValue >= 1 && randomValue <= 6);
+     * assert.isTrue(1 <= randomValue && randomValue <= 6);
      * ```
      *
      * @param min - The minimum value (inclusive)

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

@@ -1 +1 @@
-{"version":3,"file":"positive-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,eAAe,IAAI,2BAA2B,EACpD,MAAM,eAAe,CAAC;AAIvB,MAAM,MAAM,eAAe,GAAG,2BAA2B,CAAC;AAgC1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,iBAAiB,iDAAK,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,eAAe,IAAI,2BAA2B,EAC/C,MAAM,eAAe,CAAC;AAIvB,MAAM,MAAM,eAAe,GAAG,2BAA2B,CAAC;AAgC1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,iBAAiB,iDAAK,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;MAAW,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;;IAGH;;;;;;;;;;;;;;;;;;;;;;OAsBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;;;;OAoBG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type PositiveUint16 as TtfImported_PositiveUint16 } from 'ts-type-forge';
+import type { PositiveUint16 as TtfImported_PositiveUint16 } from 'ts-type-forge';
 export type PositiveUint16 = TtfImported_PositiveUint16;
 /**
  * Type guard that checks if a value is a positive integer in [1, 2^16).

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

@@ -1 +1 @@
-{"version":3,"file":"positive-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint16.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAIlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AA+BxD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,gDAAK,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-uint16.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint16.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAIlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AA+BxD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,gDAAK,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type PositiveUint32 as TtfImported_PositiveUint32 } from 'ts-type-forge';
+import type { PositiveUint32 as TtfImported_PositiveUint32 } from 'ts-type-forge';
 export type PositiveUint32 = TtfImported_PositiveUint32;
 /**
  * Type guard that checks if a value is a positive integer in [1, 2^32).

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

@@ -1 +1 @@
-{"version":3,"file":"positive-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint32.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAIlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AA+BxD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,gDAAK,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"version":3,"file":"positive-uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-uint32.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,IAAI,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAIlF,MAAM,MAAM,cAAc,GAAG,0BAA0B,CAAC;AA+BxD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,gDAAK,CAAC;AAEnC;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;MAAW,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;IACzB;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type SafeUint, type SafeInt as TtfImported_SafeInt } from 'ts-type-forge';
+import type { SafeUint, SafeInt as TtfImported_SafeInt } from 'ts-type-forge';
 export type SafeInt = TtfImported_SafeInt;
 /**
  * Type guard that checks if a value is a safe integer.
@@ -176,7 +176,7 @@ export declare const SafeInt: {
      *
      * assert.isTrue(SafeInt.is(randomValue));
      *
-     * assert.isTrue(randomValue >= -10 && randomValue <= 10);
+     * assert.isTrue(-10 <= randomValue && randomValue <= 10);
      * ```
      *
      * @param min - The minimum value (inclusive)

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/safe-int.mts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,gBAAgB,CAAC;AAE3C,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,aAAa;IACnC,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC,gBAA2B;IAC7C,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,QAAQ,CAAC;AAElC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,UAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM;IAEN;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"safe-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/safe-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,gBAAgB,CAAC;AAE3C,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,QAAQ,EACR,GAAG,EACH,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,aAAa;IACnC,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC,gBAA2B;IAC7C,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,QAAQ,CAAC;AAElC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;OAaG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,UAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM;IAEN;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}

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

@@ -1,4 +1,4 @@
-import { type SafeUint as TtfImported_SafeUint } from 'ts-type-forge';
+import type { SafeUint as TtfImported_SafeUint } from 'ts-type-forge';
 export type SafeUint = TtfImported_SafeUint;
 /**
  * Type guard that checks if a value is a non-negative safe integer.

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

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

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

@@ -1,4 +1,4 @@
-import { type Uint as TtfImported_Uint } from 'ts-type-forge';
+import type { Uint as TtfImported_Uint } from 'ts-type-forge';
 export type Uint = TtfImported_Uint;
 /**
  * Type guard that checks if a value is a non-negative integer.
@@ -156,7 +156,7 @@ export declare const Uint: {
      *
      * assert.isTrue(Uint.is(randomValue));
      *
-     * assert.isTrue(randomValue >= 0 && randomValue <= 3);
+     * assert.isTrue(0 <= randomValue && randomValue <= 3);
      * ```
      *
      * @param min - The minimum value (inclusive)

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,EAAE,KAAK,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;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"}

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

@@ -1,4 +1,4 @@
-import { type Uint16 as TtfImported_Uint16 } from 'ts-type-forge';
+import type { Uint16 as TtfImported_Uint16 } from 'ts-type-forge';
 export type Uint16 = TtfImported_Uint16;
 /**
  * Type guard that checks if a value is a non-negative integer less than 2^16.

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,EAAE,KAAK,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;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"}

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

@@ -1,4 +1,4 @@
-import { type Uint32 as TtfImported_Uint32 } from 'ts-type-forge';
+import type { Uint32 as TtfImported_Uint32 } from 'ts-type-forge';
 export type Uint32 = TtfImported_Uint32;
 /**
  * Type guard that checks if a value is a non-negative integer less than 2^32.

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,EAAE,KAAK,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;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"}

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

@@ -1,4 +1,4 @@
-import { type AbsoluteValue, type StrictExclude, type Int8 as TtfImported_Int8 } from 'ts-type-forge';
+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;

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,EACL,KAAK,aAAa,EAElB,KAAK,aAAa,EAClB,KAAK,IAAI,IAAI,gBAAgB,EAC9B,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;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"}

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

@@ -1,4 +1,4 @@
-import { type StrictExclude, type Uint8 as TtfImported_Uint8 } from 'ts-type-forge';
+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;

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,EACL,KAAK,aAAa,EAClB,KAAK,KAAK,IAAI,iBAAiB,EAEhC,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;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"}

package/dist/number/num-arithmetic-types.d.mts

@@ -1,4 +1,4 @@
-import { type BoolAnd, type BoolOr, type FiniteNumber, type Int, type NegativeFiniteNumber, type NegativeInt, type NegativeNumber, type NegativeSafeInt, type NonNegativeFiniteNumber, type NonNegativeNumber, type NonPositiveFiniteNumber, type NonPositiveInt, type NonPositiveNumber, type NonPositiveSafeInt, type NonZeroFiniteNumber, type NonZeroInt, type NonZeroNumber, type NonZeroSafeInt, type PositiveFiniteNumber, type PositiveInt, type PositiveNumber, type PositiveSafeInt, type SafeInt, type SafeUint, type Uint } from 'ts-type-forge';
+import type { BoolAnd, BoolOr, FiniteNumber, Int, NegativeFiniteNumber, NegativeInt, NegativeNumber, NegativeSafeInt, NonNegativeFiniteNumber, NonNegativeNumber, NonPositiveFiniteNumber, NonPositiveInt, NonPositiveNumber, NonPositiveSafeInt, NonZeroFiniteNumber, NonZeroInt, NonZeroNumber, NonZeroSafeInt, PositiveFiniteNumber, PositiveInt, PositiveNumber, PositiveSafeInt, SafeInt, SafeUint, Uint } from 'ts-type-forge';
 /**
  * Internal type-level arithmetic for {@link Num}'s `add`/`sub`/`mul`/`div`.
  *

package/dist/number/num-arithmetic-types.d.mts.map

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

package/dist/number/num.d.mts

@@ -1,7 +1,7 @@
-import { type Decrement, type FiniteNumber, type Increment, type Index, type Int, type Min, type NaNType, type NegativeIndex, type NonNegativeNumber, type NonZeroNumber, type PositiveNumber, type PositiveSafeIntWithSmallInt, type RelaxedExclude, type SmallInt, type SmallUint } from 'ts-type-forge';
+import type { Decrement, FiniteNumber, Increment, Index, Int, Min, NaNType, NegativeIndex, NonNegativeNumber, NonZeroNumber, PositiveNumber, PositiveSafeIntWithSmallInt, RelaxedExclude, SmallInt, SmallUint } from 'ts-type-forge';
 import { Result } from '../functional/index.mjs';
-import { type SmallPositiveInt } from '../types.mjs';
-import { type AddResult, type DivIntResult, type DivResult, type MulResult, type SubResult } from './num-arithmetic-types.mjs';
+import type { SmallPositiveInt } from '../types.mjs';
+import type { AddResult, DivIntResult, DivResult, MulResult, SubResult } from './num-arithmetic-types.mjs';
 /**
  * Namespace providing utility functions for number manipulation and validation.
  *