ts-data-forge 6.9.2 → 6.9.3

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

@@ -1,10 +1,12 @@
+import { type SafeUint as TtfImported_SafeUint } from 'ts-type-forge';
+export type SafeUint = TtfImported_SafeUint;
 /**
  * Checks if a number is a SafeUint.
  *
  * @param value The value to check.
  * @returns `true` if the value is a SafeUint, `false` otherwise.
  */
-export declare const isSafeUint: (a: number) => a is SafeUint;
+export declare const isSafeUint: (a: number) => a is TtfImported_SafeUint;
 /**
  * Casts a number to a SafeUint type.
  *
@@ -14,13 +16,13 @@ export declare const isSafeUint: (a: number) => a is SafeUint;
  */
 export declare const asSafeUint: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
     readonly "> -2^16": true;
     readonly "> -2^32": true;
     readonly ">= -2^15": true;
     readonly ">= -2^31": true;
     readonly ">=0": true;
-    readonly Finite: true;
-    readonly Int: true;
     readonly SafeInt: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
@@ -42,7 +44,7 @@ export declare const SafeUint: {
      * @returns `true` if the value is a non-negative safe integer, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is SafeUint;
+    readonly is: (a: number) => a is TtfImported_SafeUint;
     /**
      * The minimum value for a safe unsigned integer.
      *
@@ -54,7 +56,7 @@ export declare const SafeUint: {
      *
      * @readonly
      */
-    readonly MAX_VALUE: SafeUint;
+    readonly MAX_VALUE: TtfImported_SafeUint;
     /**
      * Returns the smaller of two SafeUint values.
      *
@@ -62,7 +64,7 @@ export declare const SafeUint: {
      * @param b The second SafeUint.
      * @returns The minimum value as a SafeUint.
      */
-    readonly min: (...values: readonly WithSmallInt<SafeUint, 40>[]) => SafeUint;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>[]) => TtfImported_SafeUint;
     /**
      * Returns the larger of two SafeUint values.
      *
@@ -70,20 +72,20 @@ export declare const SafeUint: {
      * @param b The second SafeUint.
      * @returns The maximum value as a SafeUint.
      */
-    readonly max: (...values: readonly WithSmallInt<SafeUint, 40>[]) => SafeUint;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>[]) => TtfImported_SafeUint;
     /**
      * Clamps a number to the safe unsigned integer range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
      */
-    readonly clamp: (x: number) => SafeUint;
+    readonly clamp: (x: number) => TtfImported_SafeUint;
     /**
      * Generates a random SafeUint value within the valid range.
      *
      * @returns A random SafeUint between 0 and MAX_SAFE_INTEGER.
      */
-    readonly random: (min?: WithSmallInt<SafeUint, 40> | undefined, max?: WithSmallInt<SafeUint, 40> | undefined) => SafeUint;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint> | undefined) => TtfImported_SafeUint;
     /**
      * Raises a SafeUint to the power of another SafeUint.
      *
@@ -91,7 +93,7 @@ export declare const SafeUint: {
      * @param b The exponent SafeUint.
      * @returns `a ** b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
      */
-    readonly pow: (x: WithSmallInt<SafeUint, 40>, y: WithSmallInt<SafeUint, 40>) => SafeUint;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>) => TtfImported_SafeUint;
     /**
      * Adds two SafeUint values.
      *
@@ -99,7 +101,7 @@ export declare const SafeUint: {
      * @param b The second SafeUint.
      * @returns `a + b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
      */
-    readonly add: (x: WithSmallInt<SafeUint, 40>, y: WithSmallInt<SafeUint, 40>) => SafeUint;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>) => TtfImported_SafeUint;
     /**
      * Subtracts one SafeUint from another.
      *
@@ -108,7 +110,7 @@ export declare const SafeUint: {
      * @returns `a - b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint (minimum
      *   0).
      */
-    readonly sub: (x: WithSmallInt<SafeUint, 40>, y: WithSmallInt<SafeUint, 40>) => SafeUint;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>) => TtfImported_SafeUint;
     /**
      * Multiplies two SafeUint values.
      *
@@ -116,7 +118,7 @@ export declare const SafeUint: {
      * @param b The second SafeUint.
      * @returns `a * b` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
      */
-    readonly mul: (x: WithSmallInt<SafeUint, 40>, y: WithSmallInt<SafeUint, 40>) => SafeUint;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>, y: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>) => TtfImported_SafeUint;
     /**
      * Divides one SafeUint by another using floor division.
      *
@@ -124,19 +126,19 @@ export declare const SafeUint: {
      * @param b The divisor SafeUint.
      * @returns `⌊a / b⌋` clamped to [0, MAX_SAFE_INTEGER] as a SafeUint.
      */
-    readonly div: (x: WithSmallInt<SafeUint, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | NormalizeBrandUnion<number & {
+    readonly div: (x: import("ts-type-forge").WithSmallInt<TtfImported_SafeUint>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 20 | 30 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 31 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | import("ts-type-forge").NormalizeBrandUnion<number & {
         readonly NaNValue: false;
+        readonly Finite: true;
+        readonly Int: true;
         readonly "!=0": true;
         readonly "> -2^16": true;
         readonly "> -2^32": true;
         readonly ">= -2^15": true;
         readonly ">= -2^31": true;
         readonly ">=0": true;
-        readonly Finite: true;
-        readonly Int: true;
         readonly SafeInt: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => SafeUint;
+    }>>) => TtfImported_SafeUint;
 };
 //# sourceMappingURL=safe-uint.d.mts.map

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":"AAiCA;;;;;GAKG;AACH,eAAO,MAAM,UAAU,8BAAK,CAAC;AAE7B;;;;;;GAMG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;MAAW,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"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;;;;;GAKG;AACH,eAAO,MAAM,UAAU,0CAAK,CAAC;AAE7B;;;;;;GAMG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;MAAW,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"safe-uint.mjs","sources":["../../../src/number/branded-types/safe-uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,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;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;;IAEZ,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;AAKG;AACI,MAAM,UAAU,GAAG;AAE1B;;;;;;AAMG;AACI,MAAM,UAAU,GAAG;AAE1B;;;;;;;;AAQG;AACI,MAAM,QAAQ,GAAG;AACtB;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}
+{"version":3,"file":"safe-uint.mjs","sources":["../../../src/number/branded-types/safe-uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,6BAA6B;AAEvD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,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;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;;IAEZ,SAAS,EAAE,MAAM,CAAC,gBAA4B;IAC9C,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;AAKG;AACI,MAAM,UAAU,GAAG;AAE1B;;;;;;AAMG;AACI,MAAM,UAAU,GAAG;AAE1B;;;;;;;;AAQG;AACI,MAAM,QAAQ,GAAG;AACtB;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,3 +1,5 @@
+import { type Uint as TtfImported_Uint } from 'ts-type-forge';
+export type Uint = TtfImported_Uint;
 /**
  * Checks if a number is a Uint.
  *
@@ -14,7 +16,7 @@
  * @param value The value to check.
  * @returns `true` if the value is a Uint, `false` otherwise.
  */
-export declare const isUint: (a: number) => a is NonNegativeInt;
+export declare const isUint: (a: number) => a is import("ts-type-forge").NonNegativeInt;
 /**
  * Casts a number to a Uint type.
  *
@@ -34,13 +36,13 @@ export declare const isUint: (a: number) => a is NonNegativeInt;
  */
 export declare const asUint: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
     readonly "> -2^16": true;
     readonly "> -2^32": true;
     readonly ">= -2^15": true;
     readonly ">= -2^31": true;
     readonly ">=0": true;
-    readonly Finite: true;
-    readonly Int: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
 }> & N;
@@ -69,7 +71,7 @@ export declare const Uint: {
      * @returns `true` if the value is a non-negative integer, `false` otherwise.
      * @see {@link isUint} for usage examples
      */
-    readonly is: (a: number) => a is NonNegativeInt;
+    readonly is: (a: number) => a is import("ts-type-forge").NonNegativeInt;
     /**
      * The minimum value for an unsigned integer.
      *
@@ -91,7 +93,7 @@ export declare const Uint: {
      * @param b The second Uint.
      * @returns The minimum value as a Uint.
      */
-    readonly min: (...values: readonly WithSmallInt<NonNegativeInt, 40>[]) => NonNegativeInt;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>[]) => import("ts-type-forge").NonNegativeInt;
     /**
      * Returns the larger of two Uint values.
      *
@@ -107,7 +109,7 @@ export declare const Uint: {
      * @param b The second Uint.
      * @returns The maximum value as a Uint.
      */
-    readonly max: (...values: readonly WithSmallInt<NonNegativeInt, 40>[]) => NonNegativeInt;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>[]) => import("ts-type-forge").NonNegativeInt;
     /**
      * Clamps a number to the Uint range (non-negative).
      *
@@ -126,7 +128,7 @@ export declare const Uint: {
      * @param value The number to clamp.
      * @returns The value clamped to [0, +∞) as a Uint.
      */
-    readonly clamp: (x: number) => NonNegativeInt;
+    readonly clamp: (x: number) => import("ts-type-forge").NonNegativeInt;
     /**
      * Generates a random Uint value.
      *
@@ -146,7 +148,7 @@ export declare const Uint: {
      *
      * @returns A random non-negative integer as a Uint.
      */
-    readonly random: (min?: WithSmallInt<NonNegativeInt, 40> | undefined, max?: WithSmallInt<NonNegativeInt, 40> | undefined) => NonNegativeInt;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt> | undefined, max?: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt> | undefined) => import("ts-type-forge").NonNegativeInt;
     /**
      * Raises a Uint to the power of another Uint.
      *
@@ -166,7 +168,7 @@ export declare const Uint: {
      * @param b The exponent Uint.
      * @returns `a ** b` clamped to [0, +∞) as a Uint.
      */
-    readonly pow: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>) => import("ts-type-forge").NonNegativeInt;
     /**
      * Adds two Uint values.
      *
@@ -182,7 +184,7 @@ export declare const Uint: {
      * @param b The second Uint.
      * @returns `a + b` clamped to [0, +∞) as a Uint.
      */
-    readonly add: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>) => import("ts-type-forge").NonNegativeInt;
     /**
      * Subtracts one Uint from another.
      *
@@ -198,7 +200,7 @@ export declare const Uint: {
      * @param b The subtrahend Uint.
      * @returns `a - b` clamped to [0, +∞) as a Uint (minimum 0).
      */
-    readonly sub: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>) => import("ts-type-forge").NonNegativeInt;
     /**
      * Multiplies two Uint values.
      *
@@ -214,7 +216,7 @@ export declare const Uint: {
      * @param b The second Uint.
      * @returns `a * b` clamped to [0, +∞) as a Uint.
      */
-    readonly mul: (x: WithSmallInt<NonNegativeInt, 40>, y: WithSmallInt<NonNegativeInt, 40>) => NonNegativeInt;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>, y: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>) => import("ts-type-forge").NonNegativeInt;
     /**
      * Divides one Uint by another using floor division.
      *
@@ -230,18 +232,18 @@ export declare const Uint: {
      * @param b The divisor Uint.
      * @returns `⌊a / b⌋` clamped to [0, +∞) as a Uint.
      */
-    readonly div: (x: WithSmallInt<NonNegativeInt, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | NormalizeBrandUnion<number & {
+    readonly div: (x: import("ts-type-forge").WithSmallInt<import("ts-type-forge").NonNegativeInt>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 20 | 30 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 31 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | import("ts-type-forge").NormalizeBrandUnion<number & {
         readonly NaNValue: false;
+        readonly Finite: true;
+        readonly Int: true;
         readonly "!=0": true;
         readonly "> -2^16": true;
         readonly "> -2^32": true;
         readonly ">= -2^15": true;
         readonly ">= -2^31": true;
         readonly ">=0": true;
-        readonly Finite: true;
-        readonly Int: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => NonNegativeInt;
+    }>>) => import("ts-type-forge").NonNegativeInt;
 };
 //# sourceMappingURL=uint.d.mts.map

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":"AA+BA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,oCAAK,CAAC;AAEzB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;MAAW,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;;;;;;;;;;;;;CAEK,CAAC"}
+{"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;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,4DAAK,CAAC;AAEzB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;MAAW,CAAC;AAE/B;;;;;;GAMG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;;;;;;;;;;OAgBG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;IAGH;;;;;;;;;;;;;;OAcG;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"uint.mjs","sources":["../../../src/number/branded-types/uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,wBAAwB;AAElD,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,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;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;AAeG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;AAMG;AACI,MAAM,IAAI,GAAG;AAClB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;AAkBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;;;;;"}
+{"version":3,"file":"uint.mjs","sources":["../../../src/number/branded-types/uint.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,wBAAwB;AAElD,MAAM,EACJ,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,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;AACA,IAAA,oBAAoB,EAAE,SAAS;AAC/B,IAAA,SAAS,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC,SAAS;IAC3B,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;;;;;;;;;;AAeG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;AAMG;AACI,MAAM,IAAI,GAAG;AAClB;;;;;;;;;;;;;;;;AAgBG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;AAcG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;;;;;;;;AAiBG;IACH,KAAK;AAEL;;;;;;;;;;;;;;;;;;AAkBG;IACH,MAAM;AAEN;;;;;;;;;;;;;;;;;;AAkBG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;AAEH;;;;;;;;;;;;;;AAcG;IACH,GAAG;;;;;"}

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

@@ -1,3 +1,5 @@
+import { type Uint16 as TtfImported_Uint16 } from 'ts-type-forge';
+export type Uint16 = TtfImported_Uint16;
 /**
  * Checks if a number is a Uint16 (16-bit unsigned integer in the range [0,
  * 2^16)).
@@ -5,7 +7,7 @@
  * @param value The value to check.
  * @returns `true` if the value is a Uint16, `false` otherwise.
  */
-export declare const isUint16: (a: number) => a is Uint16;
+export declare const isUint16: (a: number) => a is TtfImported_Uint16;
 /**
  * Casts a number to a Uint16 type.
  *
@@ -16,6 +18,8 @@ export declare const isUint16: (a: number) => a is Uint16;
  */
 export declare const asUint16: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
     readonly "> -2^16": true;
     readonly "> -2^32": true;
     readonly ">= -2^15": true;
@@ -24,8 +28,6 @@ export declare const asUint16: <N extends number>(x: N) => number & {
     readonly "< 2^16": true;
     readonly "< 2^31": true;
     readonly "< 2^32": true;
-    readonly Finite: true;
-    readonly Int: true;
     readonly SafeInt: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
@@ -47,7 +49,7 @@ export declare const Uint16: {
      * @returns `true` if the value is a 16-bit unsigned integer, `false`
      *   otherwise.
      */
-    readonly is: (a: number) => a is Uint16;
+    readonly is: (a: number) => a is TtfImported_Uint16;
     /**
      * The minimum value for a 16-bit unsigned integer.
      *
@@ -67,7 +69,7 @@ export declare const Uint16: {
      * @param b The second Uint16.
      * @returns The minimum value as a Uint16.
      */
-    readonly min: (...values: readonly WithSmallInt<Uint16, 40>[]) => Uint16;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_Uint16>[]) => TtfImported_Uint16;
     /**
      * Returns the larger of two Uint16 values.
      *
@@ -75,20 +77,20 @@ export declare const Uint16: {
      * @param b The second Uint16.
      * @returns The maximum value as a Uint16.
      */
-    readonly max: (...values: readonly WithSmallInt<Uint16, 40>[]) => Uint16;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_Uint16>[]) => TtfImported_Uint16;
     /**
      * Clamps a number to the Uint16 range.
      *
      * @param value The number to clamp.
      * @returns The value clamped to [0, 65535] as a Uint16.
      */
-    readonly clamp: (x: number) => Uint16;
+    readonly clamp: (x: number) => TtfImported_Uint16;
     /**
      * Generates a random Uint16 value within the valid range.
      *
      * @returns A random Uint16 between 0 and 65535.
      */
-    readonly random: (min?: WithSmallInt<Uint16, 40> | undefined, max?: WithSmallInt<Uint16, 40> | undefined) => Uint16;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_Uint16> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_Uint16> | undefined) => TtfImported_Uint16;
     /**
      * Raises a Uint16 to the power of another Uint16.
      *
@@ -96,7 +98,7 @@ export declare const Uint16: {
      * @param b The exponent Uint16.
      * @returns `a ** b` clamped to [0, 65535] as a Uint16.
      */
-    readonly pow: (x: WithSmallInt<Uint16, 40>, y: WithSmallInt<Uint16, 40>) => Uint16;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_Uint16>, y: import("ts-type-forge").WithSmallInt<TtfImported_Uint16>) => TtfImported_Uint16;
     /**
      * Adds two Uint16 values.
      *
@@ -104,7 +106,7 @@ export declare const Uint16: {
      * @param b The second Uint16.
      * @returns `a + b` clamped to [0, 65535] as a Uint16.
      */
-    readonly add: (x: WithSmallInt<Uint16, 40>, y: WithSmallInt<Uint16, 40>) => Uint16;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_Uint16>, y: import("ts-type-forge").WithSmallInt<TtfImported_Uint16>) => TtfImported_Uint16;
     /**
      * Subtracts one Uint16 from another.
      *
@@ -112,7 +114,7 @@ export declare const Uint16: {
      * @param b The subtrahend Uint16.
      * @returns `a - b` clamped to [0, 65535] as a Uint16 (minimum 0).
      */
-    readonly sub: (x: WithSmallInt<Uint16, 40>, y: WithSmallInt<Uint16, 40>) => Uint16;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_Uint16>, y: import("ts-type-forge").WithSmallInt<TtfImported_Uint16>) => TtfImported_Uint16;
     /**
      * Multiplies two Uint16 values.
      *
@@ -120,7 +122,7 @@ export declare const Uint16: {
      * @param b The second Uint16.
      * @returns `a * b` clamped to [0, 65535] as a Uint16.
      */
-    readonly mul: (x: WithSmallInt<Uint16, 40>, y: WithSmallInt<Uint16, 40>) => Uint16;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_Uint16>, y: import("ts-type-forge").WithSmallInt<TtfImported_Uint16>) => TtfImported_Uint16;
     /**
      * Divides one Uint16 by another using floor division.
      *
@@ -128,8 +130,10 @@ export declare const Uint16: {
      * @param b The divisor Uint16.
      * @returns `⌊a / b⌋` clamped to [0, 65535] as a Uint16.
      */
-    readonly div: (x: WithSmallInt<Uint16, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | NormalizeBrandUnion<number & {
+    readonly div: (x: import("ts-type-forge").WithSmallInt<TtfImported_Uint16>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 20 | 30 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 31 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | import("ts-type-forge").NormalizeBrandUnion<number & {
         readonly NaNValue: false;
+        readonly Finite: true;
+        readonly Int: true;
         readonly "!=0": true;
         readonly "> -2^16": true;
         readonly "> -2^32": true;
@@ -139,11 +143,9 @@ export declare const Uint16: {
         readonly "< 2^16": true;
         readonly "< 2^31": true;
         readonly "< 2^32": true;
-        readonly Finite: true;
-        readonly Int: true;
         readonly SafeInt: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => Uint16;
+    }>>) => TtfImported_Uint16;
 };
 //# sourceMappingURL=uint16.d.mts.map

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":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,4BAAK,CAAC;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}
+{"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;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,wCAAK,CAAC;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"uint16.mjs","sources":["../../../src/number/branded-types/uint16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,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;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;AAOG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;AAQG;AACI,MAAM,MAAM,GAAG;AACpB;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}
+{"version":3,"file":"uint16.mjs","sources":["../../../src/number/branded-types/uint16.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,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;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;AAOG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;AAQG;AACI,MAAM,MAAM,GAAG;AACpB;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;AAMG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,3 +1,5 @@
+import { type Uint32 as TtfImported_Uint32 } from 'ts-type-forge';
+export type Uint32 = TtfImported_Uint32;
 /**
  * Checks if a number is a Uint32 (32-bit unsigned integer in the range [0,
  * 2^32)).
@@ -5,7 +7,7 @@
  * @param value The value to check.
  * @returns `true` if the value is a Uint32, `false` otherwise.
  */
-export declare const isUint32: (a: number) => a is Uint32;
+export declare const isUint32: (a: number) => a is TtfImported_Uint32;
 /**
  * Casts a number to a Uint32 type.
  *
@@ -16,14 +18,14 @@ export declare const isUint32: (a: number) => a is Uint32;
  */
 export declare const asUint32: <N extends number>(x: N) => number & {
     readonly NaNValue: false;
+    readonly Finite: true;
+    readonly Int: true;
     readonly "> -2^16": true;
     readonly "> -2^32": true;
     readonly ">= -2^15": true;
     readonly ">= -2^31": true;
     readonly ">=0": true;
     readonly "< 2^32": true;
-    readonly Finite: true;
-    readonly Int: true;
     readonly SafeInt: true;
 } & Readonly<{
     'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
@@ -42,7 +44,7 @@ export declare const Uint32: {
      * @returns `true` if the value is within the range [0, 2^32), `false`
      *   otherwise
      */
-    readonly is: (a: number) => a is Uint32;
+    readonly is: (a: number) => a is TtfImported_Uint32;
     /**
      * The minimum value for a Uint32.
      *
@@ -61,14 +63,14 @@ export declare const Uint32: {
      * @param values - The Uint32 values to compare
      * @returns The smallest value as a Uint32
      */
-    readonly min: (...values: readonly WithSmallInt<Uint32, 40>[]) => Uint32;
+    readonly min: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_Uint32>[]) => TtfImported_Uint32;
     /**
      * Returns the maximum of multiple Uint32 values.
      *
      * @param values - The Uint32 values to compare
      * @returns The largest value as a Uint32
      */
-    readonly max: (...values: readonly WithSmallInt<Uint32, 40>[]) => Uint32;
+    readonly max: (...values: readonly import("ts-type-forge").WithSmallInt<TtfImported_Uint32>[]) => TtfImported_Uint32;
     /**
      * Clamps a Uint32 to be within the specified range.
      *
@@ -77,13 +79,13 @@ export declare const Uint32: {
      * @param max - The maximum value
      * @returns The clamped value as a Uint32
      */
-    readonly clamp: (x: number) => Uint32;
+    readonly clamp: (x: number) => TtfImported_Uint32;
     /**
      * Generates a random Uint32 value.
      *
      * @returns A random Uint32 value within [0, 2^32)
      */
-    readonly random: (min?: WithSmallInt<Uint32, 40> | undefined, max?: WithSmallInt<Uint32, 40> | undefined) => Uint32;
+    readonly random: (min?: import("ts-type-forge").WithSmallInt<TtfImported_Uint32> | undefined, max?: import("ts-type-forge").WithSmallInt<TtfImported_Uint32> | undefined) => TtfImported_Uint32;
     /**
      * Raises a Uint32 to a power, with result clamped to [0, 2^32).
      *
@@ -91,7 +93,7 @@ export declare const Uint32: {
      * @param b - The exponent Uint32
      * @returns `a ** b` as a Uint32, clamped to valid range
      */
-    readonly pow: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
+    readonly pow: (x: import("ts-type-forge").WithSmallInt<TtfImported_Uint32>, y: import("ts-type-forge").WithSmallInt<TtfImported_Uint32>) => TtfImported_Uint32;
     /**
      * Adds two Uint32 values, with result clamped to [0, 2^32).
      *
@@ -99,7 +101,7 @@ export declare const Uint32: {
      * @param b - Second Uint32
      * @returns `a + b` as a Uint32, clamped to valid range
      */
-    readonly add: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
+    readonly add: (x: import("ts-type-forge").WithSmallInt<TtfImported_Uint32>, y: import("ts-type-forge").WithSmallInt<TtfImported_Uint32>) => TtfImported_Uint32;
     /**
      * Subtracts two Uint32 values, with result clamped to [0, 2^32).
      *
@@ -107,7 +109,7 @@ export declare const Uint32: {
      * @param b - Second Uint32
      * @returns `a - b` as a Uint32, clamped to valid range (minimum 0)
      */
-    readonly sub: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
+    readonly sub: (x: import("ts-type-forge").WithSmallInt<TtfImported_Uint32>, y: import("ts-type-forge").WithSmallInt<TtfImported_Uint32>) => TtfImported_Uint32;
     /**
      * Multiplies two Uint32 values, with result clamped to [0, 2^32).
      *
@@ -115,7 +117,7 @@ export declare const Uint32: {
      * @param b - Second Uint32
      * @returns `a * b` as a Uint32, clamped to valid range
      */
-    readonly mul: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
+    readonly mul: (x: import("ts-type-forge").WithSmallInt<TtfImported_Uint32>, y: import("ts-type-forge").WithSmallInt<TtfImported_Uint32>) => TtfImported_Uint32;
     /**
      * Divides two Uint32 values using floor division, with result clamped to [0,
      * 2^32).
@@ -124,8 +126,10 @@ export declare const Uint32: {
      * @param b - The divisor Uint32
      * @returns `⌊a / b⌋` as a Uint32, clamped to valid range
      */
-    readonly div: (x: WithSmallInt<Uint32, 40>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 24 | 14 | 34 | 12 | 13 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 35 | 36 | 37 | 38 | 39 | NormalizeBrandUnion<number & {
+    readonly div: (x: import("ts-type-forge").WithSmallInt<TtfImported_Uint32>, y: 1 | 2 | 3 | 32 | 4 | 5 | 6 | 7 | 8 | 9 | 11 | 10 | 20 | 30 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 31 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | import("ts-type-forge").NormalizeBrandUnion<number & {
         readonly NaNValue: false;
+        readonly Finite: true;
+        readonly Int: true;
         readonly "!=0": true;
         readonly "> -2^16": true;
         readonly "> -2^32": true;
@@ -133,11 +137,9 @@ export declare const Uint32: {
         readonly ">= -2^31": true;
         readonly ">=0": true;
         readonly "< 2^32": true;
-        readonly Finite: true;
-        readonly Int: true;
         readonly SafeInt: true;
     } & Readonly<{
         'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3': unknown;
-    }>>) => Uint32;
+    }>>) => TtfImported_Uint32;
 };
 //# sourceMappingURL=uint32.d.mts.map

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":"AAgCA;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,4BAAK,CAAC;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;OAOG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;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,EAAE,KAAK,MAAM,IAAI,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAIlE,MAAM,MAAM,MAAM,GAAG,kBAAkB,CAAC;AA+BxC;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,wCAAK,CAAC;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;IACjB;;;;;;OAMG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;OAOG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;OAMG;;IAGH;;;;;;;OAOG;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"uint32.mjs","sources":["../../../src/number/branded-types/uint32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,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;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;AAOG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;AAKG;AACI,MAAM,MAAM,GAAG;AACpB;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;AAOG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;;;;;"}
+{"version":3,"file":"uint32.mjs","sources":["../../../src/number/branded-types/uint32.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,MAAM,EACJ,SAAS,EACT,SAAS,EACT,GAAG,EACH,QAAQ,EACR,KAAK,EACL,GAAG,EACH,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;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;;;AAMG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;AAOG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;AAKG;AACI,MAAM,MAAM,GAAG;AACpB;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;AAOG;IACH,KAAK;AAEL;;;;AAIG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;;AAOG;IACH,GAAG;;;;;"}

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

@@ -1,3 +1,5 @@
+import { type AbsoluteValue, type Int8 as TtfImported_Int8 } from 'ts-type-forge';
+export type Int8 = TtfImported_Int8;
 /**
  * Type guard that checks if a value is an 8-bit signed integer.
  *

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":"AAsDA;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,MAxCJ,MAAM,KAAG,CAAC,IAAI,IAwCL,CAAC;AAEzB;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,MAlDE,MAAM,KAAG,IAkDA,CAAC;AAE/B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;OAMG;qBA7EU,MAAM,KAAG,CAAC,IAAI,IAAI;IAgF/B;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;8BAvFoB,SAAS,IAAI,EAAE,KAAG,IAAI;IA0F7C;;;;;OAKG;8BA5FoB,SAAS,IAAI,EAAE,KAAG,IAAI;IA+F7C;;;;;OAKG;wBA7Ga,MAAM,KAAG,IAAI;IAgH7B;;;;;OAKG;mBAnHQ,CAAC,SAAS,IAAI,KAAK,CAAC,KAAG,aAAa,CAAC,CAAC,CAAC;IAsHlD;;;;;;;;OAQG;2BA1GgB,IAAI,OAAO,IAAI,KAAG,IAAI;IA6GzC;;;;;;OAMG;sBA7HW,IAAI,KAAK,IAAI,KAAG,IAAI;IAgIlC;;;;;;OAMG;sBApIW,IAAI,KAAK,IAAI,KAAG,IAAI;IAuIlC;;;;;;OAMG;sBA3IW,IAAI,KAAK,IAAI,KAAG,IAAI;IA8IlC;;;;;;OAMG;sBAlJW,IAAI,KAAK,IAAI,KAAG,IAAI;IAqJlC;;;;;;OAMG;sBAzJW,IAAI,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,KAAG,IAAI;CA2JtC,CAAC"}
+{"version":3,"file":"int8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/int8.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,IAAI,IAAI,gBAAgB,EAC9B,MAAM,eAAe,CAAC;AAIvB,MAAM,MAAM,IAAI,GAAG,gBAAgB,CAAC;AAqDpC;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,MAxCJ,MAAM,KAAG,CAAC,IAAI,IAwCL,CAAC;AAEzB;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,MAlDE,MAAM,KAAG,IAkDA,CAAC;AAE/B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;OAMG;qBA7EU,MAAM,KAAG,CAAC,IAAI,IAAI;IAgF/B;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;8BAvFoB,SAAS,IAAI,EAAE,KAAG,IAAI;IA0F7C;;;;;OAKG;8BA5FoB,SAAS,IAAI,EAAE,KAAG,IAAI;IA+F7C;;;;;OAKG;wBA7Ga,MAAM,KAAG,IAAI;IAgH7B;;;;;OAKG;mBAnHQ,CAAC,SAAS,IAAI,KAAK,CAAC,KAAG,aAAa,CAAC,CAAC,CAAC;IAsHlD;;;;;;;;OAQG;2BA1GgB,IAAI,OAAO,IAAI,KAAG,IAAI;IA6GzC;;;;;;OAMG;sBA7HW,IAAI,KAAK,IAAI,KAAG,IAAI;IAgIlC;;;;;;OAMG;sBApIW,IAAI,KAAK,IAAI,KAAG,IAAI;IAuIlC;;;;;;OAMG;sBA3IW,IAAI,KAAK,IAAI,KAAG,IAAI;IA8IlC;;;;;;OAMG;sBAlJW,IAAI,KAAK,IAAI,KAAG,IAAI;IAqJlC;;;;;;OAMG;sBAzJW,IAAI,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,KAAG,IAAI;CA2JtC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"int8.mjs","sources":["../../../src/number/enum/int8.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA,MAAM,iBAAiB,GAAG,2BAA2B;AAErD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,SAAS,EAChB,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,UAAU,GACnB,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;IACnC,SAAS,EAAE,IAAI;AACf,IAAA,SAAS,EAAE,GAAG;IACd,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,EAAE,GAAG,CAAC,CAAS,KAAgB,MAAM,CAAC,CAAC,CAAC;AAE9C,MAAM,QAAQ,GAAG,CAAC,CAAS;AACzB;AACA,YAAY,CAAC,CAAC,CAAS;AAEzB,MAAM,KAAK,GAAG,CAAC,CAAS,KAAW,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAEzD,MAAM,GAAG,GAAG,CAAiB,CAAI;AAC/B;AACA,IAAI,CAAC,GAAG,CAAC,CAAC,CAAgC;AAE5C,MAAM,IAAI,GAAG,CAAC,GAAG,MAAuB,KACtC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAE/B,MAAM,IAAI,GAAG,CAAC,GAAG,MAAuB,KACtC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAE/B,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;AAErD,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEpD,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEpD,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEpD,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAmB,KAAW,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAE5E,MAAM,MAAM,GAAG,CAAC,GAAS,EAAE,GAAS,KAClC,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC;AAE5D;;;;;;;;AAQG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;AASG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;AAeG;AACI,MAAM,IAAI,GAAG;AAClB;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,GAAG;AAEH;;;;;;;;AAQG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}
+{"version":3,"file":"int8.mjs","sources":["../../../src/number/enum/int8.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAUA,MAAM,iBAAiB,GAAG,2BAA2B;AAErD,MAAM,EACJ,SAAS,EACT,SAAS,EACT,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,SAAS,EAChB,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,UAAU,GACnB,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAI7D;AACA,IAAA,oBAAoB,EAAE,aAAa;IACnC,SAAS,EAAE,IAAI;AACf,IAAA,SAAS,EAAE,GAAG;IACd,iBAAiB;AACT,CAAA,CAAC;AAEX,MAAM,EAAE,GAAG,CAAC,CAAS,KAAgB,MAAM,CAAC,CAAC,CAAC;AAE9C,MAAM,QAAQ,GAAG,CAAC,CAAS;AACzB;AACA,YAAY,CAAC,CAAC,CAAS;AAEzB,MAAM,KAAK,GAAG,CAAC,CAAS,KAAW,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAEzD,MAAM,GAAG,GAAG,CAAiB,CAAI;AAC/B;AACA,IAAI,CAAC,GAAG,CAAC,CAAC,CAAgC;AAE5C,MAAM,IAAI,GAAG,CAAC,GAAG,MAAuB,KACtC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAE/B,MAAM,IAAI,GAAG,CAAC,GAAG,MAAuB,KACtC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAE/B,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;AAErD,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEpD,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEpD,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEpD,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAmB,KAAW,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAE5E,MAAM,MAAM,GAAG,CAAC,GAAS,EAAE,GAAS,KAClC,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC;AAE5D;;;;;;;;AAQG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;AASG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;AAeG;AACI,MAAM,IAAI,GAAG;AAClB;;;;;;AAMG;IACH,EAAE;AAEF;;;;AAIG;IACH,SAAS;AAET;;;;AAIG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;IACH,KAAK;AAEL;;;;;AAKG;IACH,GAAG;AAEH;;;;;;;;AAQG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}

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

@@ -1,3 +1,5 @@
+import { type Uint8 as TtfImported_Uint8 } from 'ts-type-forge';
+export type Uint8 = TtfImported_Uint8;
 /**
  * Checks if a number is a Uint8 (8-bit unsigned integer in the range [0, 255]).
  *

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":"AAgDA;;;;;GAKG;AACH,eAAO,MAAM,OAAO,MAjCL,MAAM,KAAG,CAAC,IAAI,KAiCJ,CAAC;AAE1B;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,MA1CC,MAAM,KAAG,KA0CC,CAAC;AAEhC;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;;OAMG;qBA9DU,MAAM,KAAG,CAAC,IAAI,KAAK;IAiEhC;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;8BAzEoB,SAAS,KAAK,EAAE,KAAG,KAAK;IA4E/C;;;;;OAKG;8BApFoB,SAAS,KAAK,EAAE,KAAG,KAAK;IAuF/C;;;;;OAKG;wBA9Fa,MAAM,KAAG,KAAK;IAiG9B;;;;;;OAMG;2BArFgB,KAAK,OAAO,KAAK,KAAG,KAAK;IAwF5C;;;;;;OAMG;sBAxGW,KAAK,KAAK,KAAK,KAAG,KAAK;IA2GrC;;;;;;OAMG;sBA/GW,KAAK,KAAK,KAAK,KAAG,KAAK;IAkHrC;;;;;;OAMG;sBAtHW,KAAK,KAAK,KAAK,KAAG,KAAK;IAyHrC;;;;;;OAMG;sBA7HW,KAAK,KAAK,KAAK,KAAG,KAAK;IAgIrC;;;;;;OAMG;sBApIW,KAAK,KAAK,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,KAAG,KAAK;CAsIzC,CAAC"}
+{"version":3,"file":"uint8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/uint8.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,IAAI,iBAAiB,EAAe,MAAM,eAAe,CAAC;AAI7E,MAAM,MAAM,KAAK,GAAG,iBAAiB,CAAC;AA+CtC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,MAjCL,MAAM,KAAG,CAAC,IAAI,KAiCJ,CAAC;AAE1B;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,MA1CC,MAAM,KAAG,KA0CC,CAAC;AAEhC;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK;IAChB;;;;;;OAMG;qBA9DU,MAAM,KAAG,CAAC,IAAI,KAAK;IAiEhC;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;OAKG;8BAzEoB,SAAS,KAAK,EAAE,KAAG,KAAK;IA4E/C;;;;;OAKG;8BApFoB,SAAS,KAAK,EAAE,KAAG,KAAK;IAuF/C;;;;;OAKG;wBA9Fa,MAAM,KAAG,KAAK;IAiG9B;;;;;;OAMG;2BArFgB,KAAK,OAAO,KAAK,KAAG,KAAK;IAwF5C;;;;;;OAMG;sBAxGW,KAAK,KAAK,KAAK,KAAG,KAAK;IA2GrC;;;;;;OAMG;sBA/GW,KAAK,KAAK,KAAK,KAAG,KAAK;IAkHrC;;;;;;OAMG;sBAtHW,KAAK,KAAK,KAAK,KAAG,KAAK;IAyHrC;;;;;;OAMG;sBA7HW,KAAK,KAAK,KAAK,KAAG,KAAK;IAgIrC;;;;;;OAMG;sBApIW,KAAK,KAAK,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,KAAG,KAAK;CAsIzC,CAAC"}