ts-data-forge 1.0.0 → 1.0.1

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

@@ -0,0 +1,137 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a non-negative integer less than 2^16';
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'SafeInteger',
+    MIN_VALUE: 0,
+    MAX_VALUE: 2 ** 16 - 1,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a Uint16 (16-bit unsigned integer in the range [0, 2^16)).
+ * @param value The value to check.
+ * @returns `true` if the value is a Uint16, `false` otherwise.
+ */
+const isUint16 = is;
+/**
+ * Casts a number to a Uint16 type.
+ * @param value The value to cast.
+ * @returns The value as a Uint16 type.
+ * @throws {TypeError} If the value is not a non-negative integer less than 2^16.
+ * @example
+ * ```typescript
+ * const x = asUint16(1000); // Uint16
+ * const y = asUint16(0); // Uint16
+ * // asUint16(-1); // throws TypeError
+ * // asUint16(70000); // throws TypeError
+ * ```
+ */
+const asUint16 = castType;
+/**
+ * Namespace providing type-safe arithmetic operations for 16-bit unsigned integers.
+ *
+ * All operations automatically clamp results to the valid Uint16 range [0, 65535].
+ * This ensures that all arithmetic maintains the 16-bit unsigned integer constraint,
+ * with negative results clamped to 0 and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asUint16(60000);
+ * const b = asUint16(10000);
+ *
+ * // Arithmetic operations with automatic clamping
+ * const sum = Uint16.add(a, b);       // Uint16 (65535 - clamped to MAX_VALUE)
+ * const diff = Uint16.sub(b, a);      // Uint16 (0 - clamped to MIN_VALUE)
+ * const product = Uint16.mul(a, b);   // Uint16 (65535 - clamped due to overflow)
+ *
+ * // Range operations
+ * const clamped = Uint16.clamp(-100);     // Uint16 (0)
+ * const minimum = Uint16.min(a, b);       // Uint16 (10000)
+ * const maximum = Uint16.max(a, b);       // Uint16 (60000)
+ *
+ * // Utility operations
+ * const random = Uint16.random();         // Uint16 (random value in [0, 65535])
+ * const power = Uint16.pow(asUint16(2), asUint16(10)); // Uint16 (1024)
+ * ```
+ */
+const Uint16 = {
+    /**
+     * Type guard to check if a value is a Uint16.
+     * @param value The value to check.
+     * @returns `true` if the value is a 16-bit unsigned integer, `false` otherwise.
+     */
+    is,
+    /**
+     * The minimum value for a 16-bit unsigned integer.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum value for a 16-bit unsigned integer.
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the smaller of two Uint16 values.
+     * @param a The first Uint16.
+     * @param b The second Uint16.
+     * @returns The minimum value as a Uint16.
+     */
+    min: min_,
+    /**
+     * Returns the larger of two Uint16 values.
+     * @param a The first Uint16.
+     * @param b The second Uint16.
+     * @returns The maximum value as a Uint16.
+     */
+    max: max_,
+    /**
+     * Clamps a number to the Uint16 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [0, 65535] as a Uint16.
+     */
+    clamp,
+    /**
+     * Generates a random Uint16 value within the valid range.
+     * @returns A random Uint16 between 0 and 65535.
+     */
+    random,
+    /**
+     * Raises a Uint16 to the power of another Uint16.
+     * @param a The base Uint16.
+     * @param b The exponent Uint16.
+     * @returns `a ** b` clamped to [0, 65535] as a Uint16.
+     */
+    pow,
+    /**
+     * Adds two Uint16 values.
+     * @param a The first Uint16.
+     * @param b The second Uint16.
+     * @returns `a + b` clamped to [0, 65535] as a Uint16.
+     */
+    add,
+    /**
+     * Subtracts one Uint16 from another.
+     * @param a The minuend Uint16.
+     * @param b The subtrahend Uint16.
+     * @returns `a - b` clamped to [0, 65535] as a Uint16 (minimum 0).
+     */
+    sub,
+    /**
+     * Multiplies two Uint16 values.
+     * @param a The first Uint16.
+     * @param b The second Uint16.
+     * @returns `a * b` clamped to [0, 65535] as a Uint16.
+     */
+    mul,
+    /**
+     * Divides one Uint16 by another using floor division.
+     * @param a The dividend Uint16.
+     * @param b The divisor Uint16.
+     * @returns `⌊a / b⌋` clamped to [0, 65535] as a Uint16.
+     */
+    div,
+};
+
+export { Uint16, asUint16, isUint16 };
+//# sourceMappingURL=uint16.mjs.map

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

@@ -0,0 +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,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;;;;;AAYG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,MAAM,GAAG;AACpB;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;AAKG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}

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

@@ -0,0 +1,185 @@
+/**
+ * Checks if a number is a Uint32 (32-bit unsigned integer in the range [0, 2^32)).
+ * @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;
+/**
+ * Casts a number to a Uint32 type.
+ * @param value The value to cast.
+ * @returns The value as a Uint32 type.
+ * @throws {TypeError} If the value is not a non-negative integer less than 2^32.
+ * @example
+ * ```typescript
+ * const x = asUint32(1000000); // Uint32
+ * const y = asUint32(0); // Uint32
+ * // asUint32(-1); // throws TypeError
+ * // asUint32(5000000000); // throws TypeError
+ * ```
+ */
+export declare const asUint32: <N extends number>(x: N) => number & {
+    readonly NaNValue: false;
+    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;
+}> & N;
+/**
+ * Utility functions for working with Uint32 (32-bit unsigned integer) branded types.
+ * Provides type-safe operations that ensure results remain within the valid range [0, 2^32).
+ * All arithmetic operations are clamped to maintain the Uint32 constraint.
+ *
+ * @example
+ * ```typescript
+ * // Type checking
+ * Uint32.is(1000000); // true
+ * Uint32.is(-1); // false
+ * Uint32.is(5000000000); // false (exceeds 2^32)
+ *
+ * // Constants
+ * console.log(Uint32.MIN_VALUE); // 0
+ * console.log(Uint32.MAX_VALUE); // 4294967295 (2^32 - 1)
+ *
+ * // Arithmetic operations (all results clamped to [0, 2^32))
+ * const a = asUint32(1000000);
+ * const b = asUint32(500000);
+ *
+ * Uint32.add(a, b); // Uint32 (1500000)
+ * Uint32.sub(a, b); // Uint32 (500000)
+ * Uint32.mul(a, b); // Uint32 (clamped if overflow)
+ * Uint32.div(a, b); // Uint32 (2)
+ * Uint32.pow(asUint32(2), asUint32(10)); // Uint32 (1024)
+ *
+ * // Utility functions
+ * Uint32.min(a, b); // Uint32 (500000)
+ * Uint32.max(a, b); // Uint32 (1000000)
+ * Uint32.clamp(asUint32(5000000000), Uint32.MIN_VALUE, Uint32.MAX_VALUE); // Uint32 (MAX_VALUE)
+ * Uint32.random(); // Random Uint32
+ * ```
+ */
+export declare const Uint32: {
+    /**
+     * Type guard that checks if a value is a 32-bit unsigned integer.
+     * @param value - The value to check
+     * @returns `true` if the value is within the range [0, 2^32), `false` otherwise
+     */
+    readonly is: (a: number) => a is Uint32;
+    /**
+     * The minimum value for a Uint32.
+     * @readonly
+     */
+    readonly MIN_VALUE: 0;
+    /**
+     * The maximum value for a Uint32.
+     * @readonly
+     */
+    readonly MAX_VALUE: number;
+    /**
+     * Returns the minimum of multiple Uint32 values.
+     * @param values - The Uint32 values to compare
+     * @returns The smallest value as a Uint32
+     */
+    readonly min: (...values: readonly WithSmallInt<Uint32, 40>[]) => 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;
+    /**
+     * Clamps a Uint32 to be within the specified range.
+     * @param value - The value to clamp
+     * @param min - The minimum value
+     * @param max - The maximum value
+     * @returns The clamped value as a Uint32
+     * @example
+     * ```typescript
+     * Uint32.clamp(asUint32(5000000000), Uint32.MIN_VALUE, asUint32(1000)); // Uint32 (1000)
+     * ```
+     */
+    readonly clamp: (x: number) => Uint32;
+    /**
+     * Generates a random Uint32 value.
+     * @returns A random Uint32 value within [0, 2^32)
+     */
+    readonly random: (min: WithSmallInt<Uint32, 40>, max: WithSmallInt<Uint32, 40>) => Uint32;
+    /**
+     * Raises a Uint32 to a power, with result clamped to [0, 2^32).
+     * @param a - The base Uint32
+     * @param b - The exponent Uint32
+     * @returns `a ** b` as a Uint32, clamped to valid range
+     * @example
+     * ```typescript
+     * Uint32.pow(asUint32(2), asUint32(10)); // Uint32 (1024)
+     * ```
+     */
+    readonly pow: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
+    /**
+     * Adds two Uint32 values, with result clamped to [0, 2^32).
+     * @param a - First Uint32
+     * @param b - Second Uint32
+     * @returns `a + b` as a Uint32, clamped to valid range
+     * @example
+     * ```typescript
+     * Uint32.add(asUint32(1000000), asUint32(500000)); // Uint32 (1500000)
+     * ```
+     */
+    readonly add: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
+    /**
+     * Subtracts two Uint32 values, with result clamped to [0, 2^32).
+     * @param a - First Uint32
+     * @param b - Second Uint32
+     * @returns `a - b` as a Uint32, clamped to valid range (minimum 0)
+     * @example
+     * ```typescript
+     * Uint32.sub(asUint32(1000000), asUint32(500000)); // Uint32 (500000)
+     * Uint32.sub(asUint32(100), asUint32(500)); // Uint32 (0) - clamped
+     * ```
+     */
+    readonly sub: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
+    /**
+     * Multiplies two Uint32 values, with result clamped to [0, 2^32).
+     * @param a - First Uint32
+     * @param b - Second Uint32
+     * @returns `a * b` as a Uint32, clamped to valid range
+     * @example
+     * ```typescript
+     * Uint32.mul(asUint32(1000), asUint32(500)); // Uint32 (500000)
+     * ```
+     */
+    readonly mul: (x: WithSmallInt<Uint32, 40>, y: WithSmallInt<Uint32, 40>) => Uint32;
+    /**
+     * Divides two Uint32 values using floor division, with result clamped to [0, 2^32).
+     * @param a - The dividend Uint32
+     * @param b - The divisor Uint32
+     * @returns `⌊a / b⌋` as a Uint32, clamped to valid range
+     * @example
+     * ```typescript
+     * Uint32.div(asUint32(1000000), asUint32(500000)); // Uint32 (2)
+     * Uint32.div(asUint32(7), asUint32(3)); // Uint32 (2) - floor division
+     * ```
+     */
+    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 NaNValue: false;
+        readonly "!=0": 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;
+    }>>) => Uint32;
+};
+//# sourceMappingURL=uint32.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uint32.d.mts","sourceRoot":"","sources":["../../../src/number/branded-types/uint32.mts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,QAAQ,4BAAK,CAAC;AAE3B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;MAAW,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,MAAM;IACjB;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;OAGG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;OAUG;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;;;;;OAUG;;;;;;;;;;;;;;;;CAEK,CAAC"}

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

@@ -0,0 +1,169 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'a non-negative integer less than 2^32';
+const { MIN_VALUE, MAX_VALUE, min: min_, max: max_, pow, add, sub, mul, div, random, is, castType, clamp, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'SafeInteger',
+    MIN_VALUE: 0,
+    MAX_VALUE: 2 ** 32 - 1,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a Uint32 (32-bit unsigned integer in the range [0, 2^32)).
+ * @param value The value to check.
+ * @returns `true` if the value is a Uint32, `false` otherwise.
+ */
+const isUint32 = is;
+/**
+ * Casts a number to a Uint32 type.
+ * @param value The value to cast.
+ * @returns The value as a Uint32 type.
+ * @throws {TypeError} If the value is not a non-negative integer less than 2^32.
+ * @example
+ * ```typescript
+ * const x = asUint32(1000000); // Uint32
+ * const y = asUint32(0); // Uint32
+ * // asUint32(-1); // throws TypeError
+ * // asUint32(5000000000); // throws TypeError
+ * ```
+ */
+const asUint32 = castType;
+/**
+ * Utility functions for working with Uint32 (32-bit unsigned integer) branded types.
+ * Provides type-safe operations that ensure results remain within the valid range [0, 2^32).
+ * All arithmetic operations are clamped to maintain the Uint32 constraint.
+ *
+ * @example
+ * ```typescript
+ * // Type checking
+ * Uint32.is(1000000); // true
+ * Uint32.is(-1); // false
+ * Uint32.is(5000000000); // false (exceeds 2^32)
+ *
+ * // Constants
+ * console.log(Uint32.MIN_VALUE); // 0
+ * console.log(Uint32.MAX_VALUE); // 4294967295 (2^32 - 1)
+ *
+ * // Arithmetic operations (all results clamped to [0, 2^32))
+ * const a = asUint32(1000000);
+ * const b = asUint32(500000);
+ *
+ * Uint32.add(a, b); // Uint32 (1500000)
+ * Uint32.sub(a, b); // Uint32 (500000)
+ * Uint32.mul(a, b); // Uint32 (clamped if overflow)
+ * Uint32.div(a, b); // Uint32 (2)
+ * Uint32.pow(asUint32(2), asUint32(10)); // Uint32 (1024)
+ *
+ * // Utility functions
+ * Uint32.min(a, b); // Uint32 (500000)
+ * Uint32.max(a, b); // Uint32 (1000000)
+ * Uint32.clamp(asUint32(5000000000), Uint32.MIN_VALUE, Uint32.MAX_VALUE); // Uint32 (MAX_VALUE)
+ * Uint32.random(); // Random Uint32
+ * ```
+ */
+const Uint32 = {
+    /**
+     * Type guard that checks if a value is a 32-bit unsigned integer.
+     * @param value - The value to check
+     * @returns `true` if the value is within the range [0, 2^32), `false` otherwise
+     */
+    is,
+    /**
+     * The minimum value for a Uint32.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum value for a Uint32.
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the minimum of multiple Uint32 values.
+     * @param values - The Uint32 values to compare
+     * @returns The smallest value as a Uint32
+     */
+    min: min_,
+    /**
+     * Returns the maximum of multiple Uint32 values.
+     * @param values - The Uint32 values to compare
+     * @returns The largest value as a Uint32
+     */
+    max: max_,
+    /**
+     * Clamps a Uint32 to be within the specified range.
+     * @param value - The value to clamp
+     * @param min - The minimum value
+     * @param max - The maximum value
+     * @returns The clamped value as a Uint32
+     * @example
+     * ```typescript
+     * Uint32.clamp(asUint32(5000000000), Uint32.MIN_VALUE, asUint32(1000)); // Uint32 (1000)
+     * ```
+     */
+    clamp,
+    /**
+     * Generates a random Uint32 value.
+     * @returns A random Uint32 value within [0, 2^32)
+     */
+    random,
+    /**
+     * Raises a Uint32 to a power, with result clamped to [0, 2^32).
+     * @param a - The base Uint32
+     * @param b - The exponent Uint32
+     * @returns `a ** b` as a Uint32, clamped to valid range
+     * @example
+     * ```typescript
+     * Uint32.pow(asUint32(2), asUint32(10)); // Uint32 (1024)
+     * ```
+     */
+    pow,
+    /**
+     * Adds two Uint32 values, with result clamped to [0, 2^32).
+     * @param a - First Uint32
+     * @param b - Second Uint32
+     * @returns `a + b` as a Uint32, clamped to valid range
+     * @example
+     * ```typescript
+     * Uint32.add(asUint32(1000000), asUint32(500000)); // Uint32 (1500000)
+     * ```
+     */
+    add,
+    /**
+     * Subtracts two Uint32 values, with result clamped to [0, 2^32).
+     * @param a - First Uint32
+     * @param b - Second Uint32
+     * @returns `a - b` as a Uint32, clamped to valid range (minimum 0)
+     * @example
+     * ```typescript
+     * Uint32.sub(asUint32(1000000), asUint32(500000)); // Uint32 (500000)
+     * Uint32.sub(asUint32(100), asUint32(500)); // Uint32 (0) - clamped
+     * ```
+     */
+    sub,
+    /**
+     * Multiplies two Uint32 values, with result clamped to [0, 2^32).
+     * @param a - First Uint32
+     * @param b - Second Uint32
+     * @returns `a * b` as a Uint32, clamped to valid range
+     * @example
+     * ```typescript
+     * Uint32.mul(asUint32(1000), asUint32(500)); // Uint32 (500000)
+     * ```
+     */
+    mul,
+    /**
+     * Divides two Uint32 values using floor division, with result clamped to [0, 2^32).
+     * @param a - The dividend Uint32
+     * @param b - The divisor Uint32
+     * @returns `⌊a / b⌋` as a Uint32, clamped to valid range
+     * @example
+     * ```typescript
+     * Uint32.div(asUint32(1000000), asUint32(500000)); // Uint32 (2)
+     * Uint32.div(asUint32(7), asUint32(3)); // Uint32 (2) - floor division
+     * ```
+     */
+    div,
+};
+
+export { Uint32, asUint32, isUint32 };
+//# sourceMappingURL=uint32.mjs.map

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

@@ -0,0 +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,EAAE,IAAI,EACT,GAAG,EAAE,IAAI,EACT,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,EAAE,EACF,QAAQ,EACR,KAAK,GACN,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;IACtB,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;;;;;AAYG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACI,MAAM,MAAM,GAAG;AACpB;;;;AAIG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;AAIG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;AAUG;IACH,KAAK;AAEL;;;AAGG;IACH,MAAM;AAEN;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;AAUG;IACH,GAAG;AAEH;;;;;;;;;AASG;IACH,GAAG;AAEH;;;;;;;;;;AAUG;IACH,GAAG;;;;;"}

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

@@ -0,0 +1,3 @@
+export * from './int8.mjs';
+export * from './uint8.mjs';
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/number/enum/index.mts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/dist/number/enum/index.mjs

@@ -0,0 +1,3 @@
+export { Int8, asInt8, isInt8 } from './int8.mjs';
+export { Uint8, asUint8, isUint8 } from './uint8.mjs';
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}