ts-data-forge 14.10.2 → 14.11.0

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,GACtB,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,aAAa;IACnC,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,CAAC;AAElC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"non-zero-uint16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,aAAa,IAAI,MAAM,GACxB,MAAM,kCAAkC,CAAC;AAO1C,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAa,EAA0B,EAAE,CACvE,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,KAAQ,EACW,EAAE;IACrB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B;;;;;;OAMG;IACH,EAAE,EAAE,eAAe;IAEnB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}

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

@@ -9,7 +9,7 @@ export type NonZeroUint32 = TtfImported_NonZeroUint32;
  * @param value - The value to check
  * @returns `true` if the value is a non-zero integer in [1, 2^32), `false` otherwise
  */
-export declare const isNonZeroUint32: (a: number) => a is import("ts-type-forge").PositiveUint32;
+export declare const isNonZeroUint32: (value: number) => value is NonZeroUint32;
 /**
  * Casts a `number` to the `NonZeroUint32` branded type.
  *
@@ -20,22 +20,7 @@ export declare const isNonZeroUint32: (a: number) => a is import("ts-type-forge"
  * @returns The value as a `NonZeroUint32`
  * @throws {TypeError} If the value is not a non-zero integer in [1, 2^32)
  */
-export declare const asNonZeroUint32: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly "< 2^32": true;
-    readonly "<=0": false;
-    readonly "> -2^16": true;
-    readonly "> -2^32": true;
-    readonly ">= -2^15": true;
-    readonly ">= -2^31": true;
-    readonly ">=0": true;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-    readonly SafeInt: true;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asNonZeroUint32: <N extends number>(value: N) => NonZeroUint32 & N;
 /**
  * Namespace providing type-safe operations for the `NonZeroUint32` branded
  * type.
@@ -51,7 +36,7 @@ export declare const NonZeroUint32: {
      * @returns `true` if the value is a non-zero integer in [1, 2^32), `false` otherwise
      * @see {@link isNonZeroUint32} for usage examples
      */
-    readonly is: (a: number) => a is import("ts-type-forge").PositiveUint32;
+    readonly is: typeof isNonZeroUint32;
     /**
      * The smallest value representable as `NonZeroUint32` (the lower saturation
      * target of `fromNumber`).

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,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"}
+{"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;AAehF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AAMtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,UAAW,MAAM,KAAG,KAAK,IAAI,aACU,CAAC;AAEpE;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,SACvC,CAAC,KACP,aAAa,GAAG,CAMlB,CAAC;AAEF;;;;;;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.mjs

@@ -1,13 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MAX_VALUE, MIN_VALUE, add, fromNumber, max as max_, min as min_, mul, pow, randomNonZero as random, } from '../operators/non-zero-uint32.mjs';
 const typeNameInMessage = 'a non-zero integer in [1, 2^32)';
-const { MAX_VALUE, MIN_VALUE, add, castType, fromNumber, is, max: max_, min: min_, mul, pow, randomNonZero: random, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    nonZero: true,
-    MIN_VALUE: 1,
-    MAX_VALUE: 2 ** 32 - 1,
-    typeNameInMessage,
-});
 
 
 
@@ -17,7 +10,7 @@ const { MAX_VALUE, MIN_VALUE, add, castType, fromNumber, is, max: max_, min: min
 
 
 
-export const isNonZeroUint32 = is;
+export const isNonZeroUint32 = (value) => Number.isSafeInteger(value) && 1 <= value && value <= 2 ** 32 - 1;
 
 
 
@@ -28,7 +21,12 @@ export const isNonZeroUint32 = is;
 
 
 
-export const asNonZeroUint32 = castType;
+export const asNonZeroUint32 = (value) => {
+    if (!isNonZeroUint32(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -44,7 +42,7 @@ export const NonZeroUint32 = {
 
 
 
-    is,
+    is: isNonZeroUint32,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"non-zero-uint32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,aAAa,EAAE,MAAM,GACtB,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,aAAa;IACnC,OAAO,EAAE,IAAI;IACb,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,CAAC;AAElC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"non-zero-uint32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/non-zero-uint32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,aAAa,IAAI,MAAM,GACxB,MAAM,kCAAkC,CAAC;AAO1C,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAa,EAA0B,EAAE,CACvE,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,KAAQ,EACW,EAAE;IACrB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B;;;;;;OAMG;IACH,EAAE,EAAE,eAAe;IAEnB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAOR,GAAG,CAAC,CAAC;AAEP,UAAU,CAOR,IAAI,CAAC,CAAC"}

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

@@ -1,5 +1,5 @@
 import type { PositiveFiniteNumber as TtfImported_PositiveFiniteNumber } from 'ts-type-forge';
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import type { TsDataForgeInternals } from '../refined-number-utils.mjs';
 export type PositiveFiniteNumber = TtfImported_PositiveFiniteNumber;
 type ElementType = PositiveFiniteNumber;
 declare const floor: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils.RemoveNonZeroBrandKey<TsDataForgeInternals.RefinedNumberUtils.ToInt<ElementType>>;
@@ -14,7 +14,7 @@ declare const round: (x: ElementType) => TsDataForgeInternals.RefinedNumberUtils
  * @param value - The value to check
  * @returns `true` if the value is a positive finite number, `false` otherwise
  */
-export declare const isPositiveFiniteNumber: (a: number) => a is TtfImported_PositiveFiniteNumber;
+export declare const isPositiveFiniteNumber: (value: number) => value is PositiveFiniteNumber;
 /**
  * Casts a `number` to the `PositiveFiniteNumber` branded type.
  *
@@ -25,19 +25,7 @@ export declare const isPositiveFiniteNumber: (a: number) => a is TtfImported_Pos
  * @returns The value as a `PositiveFiniteNumber`
  * @throws {TypeError} If the value is not a positive finite number
  */
-export declare const asPositiveFiniteNumber: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly "<=0": false;
-    readonly "> -2^16": true;
-    readonly "> -2^32": true;
-    readonly ">= -2^15": true;
-    readonly ">= -2^31": true;
-    readonly ">=0": true;
-    readonly Finite: true;
-    readonly NaNValue: false;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asPositiveFiniteNumber: <N extends number>(value: N) => PositiveFiniteNumber & N;
 /**
  * Namespace providing type-safe operations for the `PositiveFiniteNumber`
  * branded type.
@@ -52,7 +40,7 @@ export declare const PositiveFiniteNumber: {
      * @returns `true` if the value is a positive finite number, `false` otherwise
      * @see {@link isPositiveFiniteNumber} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_PositiveFiniteNumber;
+    readonly is: typeof isPositiveFiniteNumber;
     /**
      * The smallest value representable as `PositiveFiniteNumber` (the lower
      * saturation target of `fromNumber`). The domain is open at `0` (excluded),

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,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"}
+{"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;AAcvB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE,MAAM,MAAM,oBAAoB,GAAG,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,oBAAoB,CAAC;AAIxC,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,UAC1B,MAAM,KACZ,KAAK,IAAI,oBACyC,CAAC;AAEtD;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,SAC9C,CAAC,KACP,oBAAoB,GAAG,CAMzB,CAAC;AAEF;;;;;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-finite-number.mjs

@@ -1,11 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MIN_VALUE, add, div, fromNumber, max as max_, min as min_, mul, pow, random, sub, } from '../operators/positive-finite-number.mjs';
 const typeNameInMessage = 'a positive finite number';
-const { MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForFloat({
-    MIN_VALUE: Number.MIN_VALUE,
-    MAX_VALUE: Number.MAX_VALUE,
-    typeNameInMessage,
-});
 const floor = (x) => 
 
 Math.floor(x);
@@ -26,7 +21,7 @@ Math.round(x);
 
 
 
-export const isPositiveFiniteNumber = is;
+export const isPositiveFiniteNumber = (value) => Number.isFinite(value) && value >= Number.MIN_VALUE;
 
 
 
@@ -37,7 +32,12 @@ export const isPositiveFiniteNumber = is;
 
 
 
-export const asPositiveFiniteNumber = castType;
+export const asPositiveFiniteNumber = (value) => {
+    if (!isPositiveFiniteNumber(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -52,7 +52,7 @@ export const PositiveFiniteNumber = {
 
 
 
-    is,
+    is: isPositiveFiniteNumber,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"positive-finite-number.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,0BAA0B,CAAC;AAErD,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,GAAG,EACH,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,iBAAiB,CAI3D;IACA,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;CACT,CAAC,CAAC;AAEZ,MAAM,KAAK,GAAG,CACZ,CAAc,EAGd,EAAE;AACF,oEAAoE;AACpE,IAAI,CAAC,KAAK,CACR,CAAC,CAGF,CAAC;AAEJ,MAAM,IAAI,GAAG,CACX,CAAc,EAC8C,EAAE;AAC9D,oEAAoE;AACpE,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D,CAAC;AAE7E,MAAM,KAAK,GAAG,CACZ,CAAc,EAGd,EAAE;AACF,oEAAoE;AACpE,IAAI,CAAC,KAAK,CACR,CAAC,CAGF,CAAC;AAEJ,UAAU,CAGR,GAAG,CAAC,CAAC;AAEP,UAAU,CAKR,GAAG,CAAC,CAAC;AAEP;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,CAAC;AAEzC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,QAAQ,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC;;;;;;OAMG;IACH,EAAE;IAEF;;;;;OAKG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;OAMG;IACH,IAAI;IAEJ;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAGR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"positive-finite-number.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-finite-number.mts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,GAAG,EACH,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,yCAAyC,CAAC;AAOjD,MAAM,iBAAiB,GAAG,0BAA0B,CAAC;AAErD,MAAM,KAAK,GAAG,CACZ,CAAc,EAGd,EAAE;AACF,oEAAoE;AACpE,IAAI,CAAC,KAAK,CACR,CAAC,CAGF,CAAC;AAEJ,MAAM,IAAI,GAAG,CACX,CAAc,EAC8C,EAAE;AAC9D,oEAAoE;AACpE,IAAI,CAAC,IAAI,CAAC,CAAC,CAA+D,CAAC;AAE7E,MAAM,KAAK,GAAG,CACZ,CAAc,EAGd,EAAE;AACF,oEAAoE;AACpE,IAAI,CAAC,KAAK,CACR,CAAC,CAGF,CAAC;AAEJ,UAAU,CAGR,GAAG,CAAC,CAAC;AAEP,UAAU,CAKR,GAAG,CAAC,CAAC;AAEP;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,KAAa,EACkB,EAAE,CACjC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,MAAM,CAAC,SAAS,CAAC;AAEtD;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,KAAQ,EACkB,EAAE;IAC5B,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC;;;;;;OAMG;IACH,EAAE,EAAE,sBAAsB;IAE1B;;;;;OAKG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;OAMG;IACH,IAAI;IAEJ;;;;;;OAMG;IACH,KAAK;IAEL;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAGR,IAAI,CAAC,CAAC"}

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

@@ -19,7 +19,7 @@ export type PositiveInt = TtfImported_PositiveInt;
  * @param value - The value to check
  * @returns `true` if the value is a positive integer, `false` otherwise
  */
-export declare const isPositiveInt: (a: number) => a is TtfImported_PositiveInt;
+export declare const isPositiveInt: (value: number) => value is PositiveInt;
 /**
  * Casts a `number` to the `PositiveInt` branded type.
  *
@@ -40,20 +40,7 @@ export declare const isPositiveInt: (a: number) => a is TtfImported_PositiveInt;
  * @returns The value as a `PositiveInt`
  * @throws {TypeError} If the value is not a positive integer
  */
-export declare const asPositiveInt: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly "<=0": false;
-    readonly "> -2^16": true;
-    readonly "> -2^32": true;
-    readonly ">= -2^15": true;
-    readonly ">= -2^31": true;
-    readonly ">=0": true;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asPositiveInt: <N extends number>(value: N) => PositiveInt & N;
 /**
  * Namespace providing type-safe operations for the `PositiveInt` branded type.
  *
@@ -82,7 +69,7 @@ export declare const PositiveInt: {
      * @returns `true` if the value is a positive integer, `false` otherwise
      * @see {@link isPositiveInt} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_PositiveInt;
+    readonly is: typeof isPositiveInt;
     /**
      * The smallest value representable as `PositiveInt` (the lower saturation
      * target of `fromNumber`).

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,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"}
+{"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;AAgB5E,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AAMlD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,KAAK,IAAI,WAChB,CAAC;AAExC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,MAAM,SAAS,CAAC,KAAG,WAAW,GAAG,CAMxE,CAAC;AAEF;;;;;;;;;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-int.mjs

@@ -1,12 +1,6 @@
 
-import { TsDataForgeInternals } from '../refined-number-utils.mjs';
+import { MIN_VALUE, add, div, fromNumber, max as max_, min as min_, mul, pow, random, sub, } from '../operators/positive-int.mjs';
 const typeNameInMessage = 'a positive integer';
-const { MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min: min_, mul, pow, random, sub, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'Integer',
-    MIN_VALUE: 1,
-    MAX_VALUE: Number.MAX_VALUE,
-    typeNameInMessage,
-});
 
 
 
@@ -26,7 +20,7 @@ const { MIN_VALUE, add, castType, div, fromNumber, is, max: max_, min: min_, mul
 
 
 
-export const isPositiveInt = is;
+export const isPositiveInt = (value) => Number.isInteger(value) && value >= 1;
 
 
 
@@ -47,7 +41,12 @@ export const isPositiveInt = is;
 
 
 
-export const asPositiveInt = castType;
+export const asPositiveInt = (value) => {
+    if (!isPositiveInt(value)) {
+        throw new TypeError(`Expected ${typeNameInMessage}, got: ${value}`);
+    }
+    return value;
+};
 
 
 
@@ -76,7 +75,7 @@ export const PositiveInt = {
 
 
 
-    is,
+    is: isPositiveInt,
 
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AAE/C,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,GAAG,EACH,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,SAAS;IAC/B,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,QAAQ,CAAC;AAEtC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,UAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM;IAEN;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"positive-int.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,GAAG,EACH,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,+BAA+B,CAAC;AAOvC,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAa,EAAwB,EAAE,CACnE,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AAExC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAmB,KAAQ,EAAmB,EAAE;IAC3E,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE,EAAE,aAAa;IAEjB;;;OAGG;IACH,SAAS;IAET;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,UAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM;IAEN;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;OAcG;IACH,GAAG;IAEH;;;;;;;;;;;;;;;;;;;OAmBG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}

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

@@ -9,7 +9,7 @@ export type PositiveInt16 = TtfImported_PositiveInt16;
  * @param value - The value to check
  * @returns `true` if the value is a positive integer in [1, 2^15), `false` otherwise
  */
-export declare const isPositiveInt16: (a: number) => a is TtfImported_PositiveInt16;
+export declare const isPositiveInt16: (value: number) => value is PositiveInt16;
 /**
  * Casts a `number` to the `PositiveInt16` branded type.
  *
@@ -20,25 +20,7 @@ export declare const isPositiveInt16: (a: number) => a is TtfImported_PositiveIn
  * @returns The value as a `PositiveInt16`
  * @throws {TypeError} If the value is not a positive integer in [1, 2^15)
  */
-export declare const asPositiveInt16: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly "< 2^15": true;
-    readonly "< 2^16": true;
-    readonly "< 2^31": true;
-    readonly "< 2^32": true;
-    readonly "<=0": false;
-    readonly "> -2^16": true;
-    readonly "> -2^32": true;
-    readonly ">= -2^15": true;
-    readonly ">= -2^31": true;
-    readonly ">=0": true;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-    readonly SafeInt: true;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asPositiveInt16: <N extends number>(value: N) => PositiveInt16 & N;
 /**
  * Namespace providing type-safe operations for the `PositiveInt16` branded
  * type.
@@ -54,7 +36,7 @@ export declare const PositiveInt16: {
      * @returns `true` if the value is a positive integer in [1, 2^15), `false` otherwise
      * @see {@link isPositiveInt16} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_PositiveInt16;
+    readonly is: typeof isPositiveInt16;
     /**
      * The smallest value representable as `PositiveInt16` (the lower saturation
      * target of `fromNumber`).

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,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"}
+{"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;AAiBhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AAMtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,UAAW,MAAM,KAAG,KAAK,IAAI,aACU,CAAC;AAEpE;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,SACvC,CAAC,KACP,aAAa,GAAG,CAMlB,CAAC;AAEF;;;;;;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-int16.mjs

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

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,GAAG,EACH,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,aAAa;IACnC,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,CAAC;AAElC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"positive-int16.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int16.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,iCAAiC,CAAC;AAOzC,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAa,EAA0B,EAAE,CACvE,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,KAAQ,EACW,EAAE;IACrB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B;;;;;;OAMG;IACH,EAAE,EAAE,eAAe;IAEnB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}

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

@@ -9,7 +9,7 @@ export type PositiveInt32 = TtfImported_PositiveInt32;
  * @param value - The value to check
  * @returns `true` if the value is a positive integer in [1, 2^31), `false` otherwise
  */
-export declare const isPositiveInt32: (a: number) => a is TtfImported_PositiveInt32;
+export declare const isPositiveInt32: (value: number) => value is PositiveInt32;
 /**
  * Casts a `number` to the `PositiveInt32` branded type.
  *
@@ -20,23 +20,7 @@ export declare const isPositiveInt32: (a: number) => a is TtfImported_PositiveIn
  * @returns The value as a `PositiveInt32`
  * @throws {TypeError} If the value is not a positive integer in [1, 2^31)
  */
-export declare const asPositiveInt32: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly "< 2^31": true;
-    readonly "< 2^32": true;
-    readonly "<=0": false;
-    readonly "> -2^16": true;
-    readonly "> -2^32": true;
-    readonly ">= -2^15": true;
-    readonly ">= -2^31": true;
-    readonly ">=0": true;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-    readonly SafeInt: true;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asPositiveInt32: <N extends number>(value: N) => PositiveInt32 & N;
 /**
  * Namespace providing type-safe operations for the `PositiveInt32` branded
  * type.
@@ -52,7 +36,7 @@ export declare const PositiveInt32: {
      * @returns `true` if the value is a positive integer in [1, 2^31), `false` otherwise
      * @see {@link isPositiveInt32} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_PositiveInt32;
+    readonly is: typeof isPositiveInt32;
     /**
      * The smallest value representable as `PositiveInt32` (the lower saturation
      * target of `fromNumber`).

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,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"}
+{"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;AAiBhF,MAAM,MAAM,aAAa,GAAG,yBAAyB,CAAC;AAMtD;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,UAAW,MAAM,KAAG,KAAK,IAAI,aACU,CAAC;AAEpE;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,SACvC,CAAC,KACP,aAAa,GAAG,CAMlB,CAAC;AAEF;;;;;;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.mjs

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

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

@@ -1 +1 @@
-{"version":3,"file":"positive-int32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAMnE,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,GAAG,EACH,UAAU,EACV,EAAE,EACF,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;IACA,oBAAoB,EAAE,aAAa;IACnC,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;CACT,CAAC,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,CAAC;AAElC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B;;;;;;OAMG;IACH,EAAE;IAEF;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}
+{"version":3,"file":"positive-int32.mjs","sourceRoot":"","sources":["../../../src/number/branded-types/positive-int32.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EACL,SAAS,EACT,SAAS,EACT,GAAG,EACH,GAAG,EACH,UAAU,EACV,GAAG,IAAI,IAAI,EACX,GAAG,IAAI,IAAI,EACX,GAAG,EACH,GAAG,EACH,MAAM,EACN,GAAG,GACJ,MAAM,iCAAiC,CAAC;AAOzC,MAAM,iBAAiB,GAAG,iCAAiC,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAa,EAA0B,EAAE,CACvE,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,KAAQ,EACW,EAAE;IACrB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,SAAS,CAAC,YAAY,iBAAiB,UAAU,KAAK,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B;;;;;;OAMG;IACH,EAAE,EAAE,eAAe;IAEnB;;;OAGG;IACH,SAAS;IAET;;;OAGG;IACH,SAAS;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;OAKG;IACH,GAAG,EAAE,IAAI;IAET;;;;;;;;;;OAUG;IACH,UAAU;IAEV;;;;;;;;OAQG;IACH,MAAM;IAEN;;;;;;;OAOG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;OAMG;IACH,GAAG;IAEH;;;;;;;OAOG;IACH,GAAG;CACK,CAAC;AAEX,UAAU,CAMR,GAAG,CAAC,CAAC;AAEP,UAAU,CAMR,IAAI,CAAC,CAAC"}

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

@@ -1,4 +1,4 @@
-import type { SafeUint, PositiveSafeInt as TtfImported_PositiveSafeInt } from 'ts-type-forge';
+import type { 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.
@@ -21,7 +21,7 @@ export type PositiveSafeInt = TtfImported_PositiveSafeInt;
  * @param value - The value to check
  * @returns `true` if the value is a positive safe integer, `false` otherwise
  */
-export declare const isPositiveSafeInt: (a: number) => a is TtfImported_PositiveSafeInt;
+export declare const isPositiveSafeInt: (value: number) => value is PositiveSafeInt;
 /**
  * Casts a `number` to the `PositiveSafeInt` branded type.
  *
@@ -42,21 +42,7 @@ export declare const isPositiveSafeInt: (a: number) => a is TtfImported_Positive
  * @returns The value as a `PositiveSafeInt`
  * @throws {TypeError} If the value is not a positive safe integer
  */
-export declare const asPositiveSafeInt: <N extends number>(x: N) => number & {
-    readonly "!=0": true;
-    readonly "<=0": false;
-    readonly "> -2^16": true;
-    readonly "> -2^32": true;
-    readonly ">= -2^15": true;
-    readonly ">= -2^31": true;
-    readonly ">=0": true;
-    readonly Finite: true;
-    readonly Int: true;
-    readonly NaNValue: false;
-    readonly SafeInt: true;
-} & Readonly<{
-    'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-}> & N;
+export declare const asPositiveSafeInt: <N extends number>(value: N) => PositiveSafeInt & N;
 /**
  * Namespace providing type-safe operations for the `PositiveSafeInt` branded
  * type.
@@ -84,7 +70,7 @@ export declare const PositiveSafeInt: {
      * @returns `true` if the value is a positive safe integer, `false` otherwise
      * @see {@link isPositiveSafeInt} for usage examples
      */
-    readonly is: (a: number) => a is TtfImported_PositiveSafeInt;
+    readonly is: typeof isPositiveSafeInt;
     /**
      * The smallest value representable as `PositiveSafeInt` (the lower saturation
      * target of `fromNumber`).
@@ -94,7 +80,7 @@ export declare const PositiveSafeInt: {
      * The largest value representable as `PositiveSafeInt` (the upper saturation
      * target of `fromNumber`).
      */
-    readonly MAX_VALUE: SafeUint;
+    readonly MAX_VALUE: import("ts-type-forge").SafeUint;
     /**
      * Returns the smallest of the given positive safe integers.
      *

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,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"}
+{"version":3,"file":"positive-safe-int.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/positive-safe-int.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,IAAI,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAiBpF,MAAM,MAAM,eAAe,GAAG,2BAA2B,CAAC;AAM1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,iBAAiB,UAAW,MAAM,KAAG,KAAK,IAAI,eAChB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,MAAM,SACzC,CAAC,KACP,eAAe,GAAG,CAMpB,CAAC;AAEF;;;;;;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"}