ts-data-forge 1.0.0 → 1.0.2

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

@@ -0,0 +1,202 @@
+/**
+ * Type guard that checks if a value is an 8-bit signed integer.
+ *
+ * An Int8 is a signed integer in the range [-128, 127], representing
+ * values that fit in exactly 8 bits of memory.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is an Int8, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isInt8(100);   // true
+ * isInt8(-50);   // true
+ * isInt8(127);   // true (max value)
+ * isInt8(-128);  // true (min value)
+ * isInt8(128);   // false (exceeds max)
+ * isInt8(-129);  // false (below min)
+ * isInt8(5.5);   // false (not integer)
+ * ```
+ */
+export declare const isInt8: (x: number) => x is Int8;
+/**
+ * Casts a number to an Int8 branded type.
+ *
+ * This function validates that the input is within the Int8 range [-128, 127]
+ * and is an integer, then returns it with the Int8 brand.
+ *
+ * @param value - The value to cast
+ * @returns The value as an Int8 branded type
+ * @throws {TypeError} If the value is not a valid 8-bit signed integer
+ *
+ * @example
+ * ```typescript
+ * const byte = asInt8(100);     // Int8
+ * const max = asInt8(127);      // Int8 (maximum value)
+ * const min = asInt8(-128);     // Int8 (minimum value)
+ * const zero = asInt8(0);       // Int8
+ *
+ * // These throw TypeError:
+ * // asInt8(128);               // Exceeds maximum (127)
+ * // asInt8(-129);              // Below minimum (-128)
+ * // asInt8(1.5);               // Not an integer
+ * // asInt8(NaN);               // Not a number
+ * ```
+ */
+export declare const asInt8: (x: number) => Int8;
+/**
+ * Namespace providing type-safe operations for Int8 (8-bit signed integer) branded types.
+ *
+ * Int8 represents signed integers in the range [-128, 127], equivalent to a signed
+ * byte in many programming languages. All operations automatically clamp results
+ * to stay within this range, preventing overflow/underflow issues.
+ *
+ * This type is useful for:
+ * - Binary data processing (signed bytes)
+ * - Small integer values with known bounds
+ * - Embedded systems programming
+ * - Memory-efficient integer storage
+ * - Image processing (signed pixel offsets)
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const a = asInt8(100);
+ * const b = asInt8(50);
+ *
+ * // Arithmetic with automatic clamping
+ * const sum = Int8.add(a, b);        // Int8 (127) - clamped to maximum
+ * const diff = Int8.sub(a, b);       // Int8 (50)
+ * const product = Int8.mul(a, b);    // Int8 (127) - clamped due to overflow
+ * const quotient = Int8.div(a, b);   // Int8 (2)
+ *
+ * // Boundary handling
+ * const overflow = Int8.add(asInt8(127), asInt8(10));  // Int8 (127) - clamped
+ * const underflow = Int8.sub(asInt8(-128), asInt8(10)); // Int8 (-128) - clamped
+ *
+ * // Utility operations
+ * const clamped = Int8.clamp(200);          // Int8 (127)
+ * const absolute = Int8.abs(asInt8(-100));  // Int8 (100)
+ * const minimum = Int8.min(a, b);           // Int8 (50)
+ * const maximum = Int8.max(a, b);           // Int8 (100)
+ *
+ * // Random generation
+ * const die = Int8.random(asInt8(1), asInt8(6));        // Random 1-6
+ * const offset = Int8.random(asInt8(-10), asInt8(10));  // Random ±10
+ * ```
+ */
+export declare const Int8: {
+    /**
+     * Type guard that checks if a value is an 8-bit signed integer.
+     *
+     * @param value - The value to check
+     * @returns `true` if the value is in range [-128, 127] and is an integer
+     *
+     * @see {@link isInt8} for usage examples
+     */
+    readonly is: (x: number) => x is Int8;
+    /**
+     * The minimum value for an 8-bit signed integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: -128;
+    /**
+     * The maximum value for an 8-bit signed integer.
+     * @readonly
+     */
+    readonly MAX_VALUE: 127;
+    /**
+     * Returns the minimum value from a list of Int8 values.
+     *
+     * @param values - The Int8 values to compare (at least one required)
+     * @returns The smallest value as an Int8
+     *
+     * @example
+     * ```typescript
+     * Int8.min(asInt8(50), asInt8(-30), asInt8(100)); // Int8 (-30)
+     * ```
+     */
+    readonly min: (...values: readonly Int8[]) => Int8;
+    /**
+     * Returns the maximum value from a list of Int8 values.
+     *
+     * @param values - The Int8 values to compare (at least one required)
+     * @returns The largest value as an Int8
+     *
+     * @example
+     * ```typescript
+     * Int8.max(asInt8(50), asInt8(-30), asInt8(100)); // Int8 (100)
+     * ```
+     */
+    readonly max: (...values: readonly Int8[]) => Int8;
+    /**
+     * Clamps a number to the Int8 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [-128, 127] as an Int8.
+     */
+    readonly clamp: (a: number) => Int8;
+    /**
+     * Returns the absolute value of an Int8.
+     * @param value The Int8 value.
+     * @returns The absolute value as an Int8, clamped to valid range.
+     */
+    readonly abs: <N extends Int8>(x: N) => AbsoluteValue<N>;
+    /**
+     * Generates a random Int8 value within the specified range (inclusive).
+     *
+     * Both bounds are inclusive. If min > max, they are automatically swapped.
+     *
+     * @param min - The minimum value (inclusive)
+     * @param max - The maximum value (inclusive)
+     * @returns A random Int8 in the range [min, max]
+     *
+     * @example
+     * ```typescript
+     * // Random signed byte
+     * const randomByte = Int8.random(Int8.MIN_VALUE, Int8.MAX_VALUE);
+     *
+     * // Random small range
+     * const dice = Int8.random(asInt8(1), asInt8(6));  // 1-6
+     *
+     * // Random offset
+     * const offset = Int8.random(asInt8(-10), asInt8(10)); // -10 to 10
+     * ```
+     */
+    readonly random: (min: Int8, max: Int8) => Int8;
+    /**
+     * Raises an Int8 to the power of another Int8.
+     * @param a The base Int8.
+     * @param b The exponent Int8.
+     * @returns `a ** b` clamped to [-128, 127] as an Int8.
+     */
+    readonly pow: (x: Int8, y: Int8) => Int8;
+    /**
+     * Adds two Int8 values.
+     * @param a The first Int8.
+     * @param b The second Int8.
+     * @returns `a + b` clamped to [-128, 127] as an Int8.
+     */
+    readonly add: (x: Int8, y: Int8) => Int8;
+    /**
+     * Subtracts one Int8 from another.
+     * @param a The minuend Int8.
+     * @param b The subtrahend Int8.
+     * @returns `a - b` clamped to [-128, 127] as an Int8.
+     */
+    readonly sub: (x: Int8, y: Int8) => Int8;
+    /**
+     * Multiplies two Int8 values.
+     * @param a The first Int8.
+     * @param b The second Int8.
+     * @returns `a * b` clamped to [-128, 127] as an Int8.
+     */
+    readonly mul: (x: Int8, y: Int8) => Int8;
+    /**
+     * Divides one Int8 by another using floor division.
+     * @param a The dividend Int8.
+     * @param b The divisor Int8 (cannot be 0).
+     * @returns `⌊a / b⌋` clamped to [-128, 127] as an Int8.
+     */
+    readonly div: (x: Int8, y: Exclude<Int8, 0>) => Int8;
+};
+//# sourceMappingURL=int8.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"int8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/int8.mts"],"names":[],"mappings":"AAyHA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,MAjHJ,MAAM,KAAG,CAAC,IAAI,IAiHL,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,MAAM,MAnIE,MAAM,KAAG,IAmIA,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,IAAI;IACf;;;;;;;OAOG;qBA9LU,MAAM,KAAG,CAAC,IAAI,IAAI;IAiM/B;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;;;;;OAUG;8BAtLoB,SAAS,IAAI,EAAE,KAAG,IAAI;IAyL7C;;;;;;;;;;OAUG;8BA3LoB,SAAS,IAAI,EAAE,KAAG,IAAI;IA8L7C;;;;OAIG;wBA1Na,MAAM,KAAG,IAAI;IA6N7B;;;;OAIG;mBA1NQ,CAAC,SAAS,IAAI,KAAK,CAAC,KAAG,aAAa,CAAC,CAAC,CAAC;IA6NlD;;;;;;;;;;;;;;;;;;;;OAoBG;2BA/KgB,IAAI,OAAO,IAAI,KAAG,IAAI;IAkLzC;;;;;OAKG;sBA/NW,IAAI,KAAK,IAAI,KAAG,IAAI;IAkOlC;;;;;OAKG;sBA/NW,IAAI,KAAK,IAAI,KAAG,IAAI;IAkOlC;;;;;OAKG;sBA/NW,IAAI,KAAK,IAAI,KAAG,IAAI;IAkOlC;;;;;OAKG;sBA/NW,IAAI,KAAK,IAAI,KAAG,IAAI;IAkOlC;;;;;OAKG;sBA/NW,IAAI,KAAK,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,KAAG,IAAI;CAiOtC,CAAC"}

package/dist/number/enum/int8.mjs

@@ -0,0 +1,296 @@
+import { TsVerifiedInternals } from '../refined-number-utils.mjs';
+
+const typeNameInMessage = 'an integer in [-128, 127]';
+const { MIN_VALUE, MAX_VALUE, random: randomImpl, is: isImpl, castType: castTypeImpl, clamp: clampImpl, } = TsVerifiedInternals.RefinedNumberUtils.operatorsForInteger({
+    integerOrSafeInteger: 'SafeInteger',
+    MIN_VALUE: -128,
+    MAX_VALUE: 127,
+    typeNameInMessage,
+});
+/**
+ * Checks if a number is a valid Int8 (integer in [-128, 127]).
+ * @param x - The number to check
+ * @returns True if x is a valid Int8
+ */
+const is = (x) => isImpl(x);
+/**
+ * Converts a number to Int8, throwing an error if invalid.
+ * @param x - The number to convert
+ * @returns The number as Int8
+ * @throws TypeError if x is not a valid Int8
+ */
+const castType = (x) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+castTypeImpl(x);
+/**
+ * Clamps a number to the Int8 range [-128, 127].
+ * @param a - The number to clamp
+ * @returns The clamped value as Int8
+ */
+const clamp = (a) => castType(clampImpl(a));
+/**
+ * Returns the absolute value of an Int8.
+ * @param x - The Int8 value
+ * @returns The absolute value
+ */
+const abs = (x) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+Math.abs(x);
+/**
+ * Returns the minimum of the given Int8 values.
+ * @param values - The Int8 values to compare
+ * @returns The minimum value
+ */
+const min_ = (...values) => castType(Math.min(...values));
+/**
+ * Returns the maximum of the given Int8 values.
+ * @param values - The Int8 values to compare
+ * @returns The maximum value
+ */
+const max_ = (...values) => castType(Math.max(...values));
+/**
+ * Raises x to the power of y, clamped to Int8 range.
+ * @param x - The base
+ * @param y - The exponent
+ * @returns x^y clamped to [-128, 127]
+ */
+const pow = (x, y) => clamp(x ** y);
+/**
+ * Adds two Int8 values, clamped to Int8 range.
+ * @param x - First operand
+ * @param y - Second operand
+ * @returns x + y clamped to [-128, 127]
+ */
+const add = (x, y) => clamp(x + y);
+/**
+ * Subtracts two Int8 values, clamped to Int8 range.
+ * @param x - First operand
+ * @param y - Second operand
+ * @returns x - y clamped to [-128, 127]
+ */
+const sub = (x, y) => clamp(x - y);
+/**
+ * Multiplies two Int8 values, clamped to Int8 range.
+ * @param x - First operand
+ * @param y - Second operand
+ * @returns x * y clamped to [-128, 127]
+ */
+const mul = (x, y) => clamp(x * y);
+/**
+ * Divides two Int8 values, clamped to Int8 range.
+ * @param x - The dividend
+ * @param y - The divisor (cannot be 0)
+ * @returns ⌊x / y⌋ clamped to [-128, 127]
+ */
+const div = (x, y) => clamp(Math.floor(x / y));
+/**
+ * Generates a random Int8 value within the specified range.
+ * @param min - The minimum value (inclusive)
+ * @param max - The maximum value (inclusive)
+ * @returns A random Int8 between min and max
+ */
+const random = (min, max) => castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));
+/**
+ * Type guard that checks if a value is an 8-bit signed integer.
+ *
+ * An Int8 is a signed integer in the range [-128, 127], representing
+ * values that fit in exactly 8 bits of memory.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is an Int8, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isInt8(100);   // true
+ * isInt8(-50);   // true
+ * isInt8(127);   // true (max value)
+ * isInt8(-128);  // true (min value)
+ * isInt8(128);   // false (exceeds max)
+ * isInt8(-129);  // false (below min)
+ * isInt8(5.5);   // false (not integer)
+ * ```
+ */
+const isInt8 = is;
+/**
+ * Casts a number to an Int8 branded type.
+ *
+ * This function validates that the input is within the Int8 range [-128, 127]
+ * and is an integer, then returns it with the Int8 brand.
+ *
+ * @param value - The value to cast
+ * @returns The value as an Int8 branded type
+ * @throws {TypeError} If the value is not a valid 8-bit signed integer
+ *
+ * @example
+ * ```typescript
+ * const byte = asInt8(100);     // Int8
+ * const max = asInt8(127);      // Int8 (maximum value)
+ * const min = asInt8(-128);     // Int8 (minimum value)
+ * const zero = asInt8(0);       // Int8
+ *
+ * // These throw TypeError:
+ * // asInt8(128);               // Exceeds maximum (127)
+ * // asInt8(-129);              // Below minimum (-128)
+ * // asInt8(1.5);               // Not an integer
+ * // asInt8(NaN);               // Not a number
+ * ```
+ */
+const asInt8 = castType;
+/**
+ * Namespace providing type-safe operations for Int8 (8-bit signed integer) branded types.
+ *
+ * Int8 represents signed integers in the range [-128, 127], equivalent to a signed
+ * byte in many programming languages. All operations automatically clamp results
+ * to stay within this range, preventing overflow/underflow issues.
+ *
+ * This type is useful for:
+ * - Binary data processing (signed bytes)
+ * - Small integer values with known bounds
+ * - Embedded systems programming
+ * - Memory-efficient integer storage
+ * - Image processing (signed pixel offsets)
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const a = asInt8(100);
+ * const b = asInt8(50);
+ *
+ * // Arithmetic with automatic clamping
+ * const sum = Int8.add(a, b);        // Int8 (127) - clamped to maximum
+ * const diff = Int8.sub(a, b);       // Int8 (50)
+ * const product = Int8.mul(a, b);    // Int8 (127) - clamped due to overflow
+ * const quotient = Int8.div(a, b);   // Int8 (2)
+ *
+ * // Boundary handling
+ * const overflow = Int8.add(asInt8(127), asInt8(10));  // Int8 (127) - clamped
+ * const underflow = Int8.sub(asInt8(-128), asInt8(10)); // Int8 (-128) - clamped
+ *
+ * // Utility operations
+ * const clamped = Int8.clamp(200);          // Int8 (127)
+ * const absolute = Int8.abs(asInt8(-100));  // Int8 (100)
+ * const minimum = Int8.min(a, b);           // Int8 (50)
+ * const maximum = Int8.max(a, b);           // Int8 (100)
+ *
+ * // Random generation
+ * const die = Int8.random(asInt8(1), asInt8(6));        // Random 1-6
+ * const offset = Int8.random(asInt8(-10), asInt8(10));  // Random ±10
+ * ```
+ */
+const Int8 = {
+    /**
+     * Type guard that checks if a value is an 8-bit signed integer.
+     *
+     * @param value - The value to check
+     * @returns `true` if the value is in range [-128, 127] and is an integer
+     *
+     * @see {@link isInt8} for usage examples
+     */
+    is,
+    /**
+     * The minimum value for an 8-bit signed integer.
+     * @readonly
+     */
+    MIN_VALUE,
+    /**
+     * The maximum value for an 8-bit signed integer.
+     * @readonly
+     */
+    MAX_VALUE,
+    /**
+     * Returns the minimum value from a list of Int8 values.
+     *
+     * @param values - The Int8 values to compare (at least one required)
+     * @returns The smallest value as an Int8
+     *
+     * @example
+     * ```typescript
+     * Int8.min(asInt8(50), asInt8(-30), asInt8(100)); // Int8 (-30)
+     * ```
+     */
+    min: min_,
+    /**
+     * Returns the maximum value from a list of Int8 values.
+     *
+     * @param values - The Int8 values to compare (at least one required)
+     * @returns The largest value as an Int8
+     *
+     * @example
+     * ```typescript
+     * Int8.max(asInt8(50), asInt8(-30), asInt8(100)); // Int8 (100)
+     * ```
+     */
+    max: max_,
+    /**
+     * Clamps a number to the Int8 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [-128, 127] as an Int8.
+     */
+    clamp,
+    /**
+     * Returns the absolute value of an Int8.
+     * @param value The Int8 value.
+     * @returns The absolute value as an Int8, clamped to valid range.
+     */
+    abs,
+    /**
+     * Generates a random Int8 value within the specified range (inclusive).
+     *
+     * Both bounds are inclusive. If min > max, they are automatically swapped.
+     *
+     * @param min - The minimum value (inclusive)
+     * @param max - The maximum value (inclusive)
+     * @returns A random Int8 in the range [min, max]
+     *
+     * @example
+     * ```typescript
+     * // Random signed byte
+     * const randomByte = Int8.random(Int8.MIN_VALUE, Int8.MAX_VALUE);
+     *
+     * // Random small range
+     * const dice = Int8.random(asInt8(1), asInt8(6));  // 1-6
+     *
+     * // Random offset
+     * const offset = Int8.random(asInt8(-10), asInt8(10)); // -10 to 10
+     * ```
+     */
+    random,
+    /**
+     * Raises an Int8 to the power of another Int8.
+     * @param a The base Int8.
+     * @param b The exponent Int8.
+     * @returns `a ** b` clamped to [-128, 127] as an Int8.
+     */
+    pow,
+    /**
+     * Adds two Int8 values.
+     * @param a The first Int8.
+     * @param b The second Int8.
+     * @returns `a + b` clamped to [-128, 127] as an Int8.
+     */
+    add,
+    /**
+     * Subtracts one Int8 from another.
+     * @param a The minuend Int8.
+     * @param b The subtrahend Int8.
+     * @returns `a - b` clamped to [-128, 127] as an Int8.
+     */
+    sub,
+    /**
+     * Multiplies two Int8 values.
+     * @param a The first Int8.
+     * @param b The second Int8.
+     * @returns `a * b` clamped to [-128, 127] as an Int8.
+     */
+    mul,
+    /**
+     * Divides one Int8 by another using floor division.
+     * @param a The dividend Int8.
+     * @param b The divisor Int8 (cannot be 0).
+     * @returns `⌊a / b⌋` clamped to [-128, 127] as an Int8.
+     */
+    div,
+};
+
+export { Int8, asInt8, isInt8 };
+//# sourceMappingURL=int8.mjs.map

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

@@ -0,0 +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,MAAM,EAAE,UAAU,EAClB,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,SAAS,GACjB,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,mBAAmB,CAI5D;AACA,IAAA,oBAAoB,EAAE,aAAa;IACnC,SAAS,EAAE,IAAI;AACf,IAAA,SAAS,EAAE,GAAG;IACd,iBAAiB;AACT,CAAA,CAAC;AAEX;;;;AAIG;AACH,MAAM,EAAE,GAAG,CAAC,CAAS,KAAgB,MAAM,CAAC,CAAC,CAAC;AAE9C;;;;;AAKG;AACH,MAAM,QAAQ,GAAG,CAAC,CAAS;AACzB;AACA,YAAY,CAAC,CAAC,CAAS;AAEzB;;;;AAIG;AACH,MAAM,KAAK,GAAG,CAAC,CAAS,KAAW,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAEzD;;;;AAIG;AACH,MAAM,GAAG,GAAG,CAAiB,CAAI;AAC/B;AACA,IAAI,CAAC,GAAG,CAAC,CAAC,CAAgC;AAE5C;;;;AAIG;AACH,MAAM,IAAI,GAAG,CAAC,GAAG,MAAuB,KACtC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAE/B;;;;AAIG;AACH,MAAM,IAAI,GAAG,CAAC,GAAG,MAAuB,KACtC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAE/B;;;;;AAKG;AACH,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;AAErD;;;;;AAKG;AACH,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEpD;;;;;AAKG;AACH,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEpD;;;;;AAKG;AACH,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAO,KAAW,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEpD;;;;;AAKG;AACH,MAAM,GAAG,GAAG,CAAC,CAAO,EAAE,CAAmB,KAAW,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAE5E;;;;;AAKG;AACH,MAAM,MAAM,GAAG,CAAC,GAAS,EAAE,GAAS,KAClC,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,MAAM,GAAG;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCG;AACI,MAAM,IAAI,GAAG;AAClB;;;;;;;AAOG;IACH,EAAE;AAEF;;;AAGG;IACH,SAAS;AAET;;;AAGG;IACH,SAAS;AAET;;;;;;;;;;AAUG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;;;;;;;AAUG;AACH,IAAA,GAAG,EAAE,IAAI;AAET;;;;AAIG;IACH,KAAK;AAEL;;;;AAIG;IACH,GAAG;AAEH;;;;;;;;;;;;;;;;;;;;AAoBG;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/enum/uint8.d.mts

@@ -0,0 +1,128 @@
+/**
+ * Checks if a number is a Uint8 (8-bit unsigned integer in the range [0, 255]).
+ * @param value The value to check.
+ * @returns `true` if the value is a Uint8, `false` otherwise.
+ */
+export declare const isUint8: (x: number) => x is Uint8;
+/**
+ * Casts a number to a Uint8 type.
+ * @param value The value to cast.
+ * @returns The value as a Uint8 type.
+ * @throws {TypeError} If the value is not a valid 8-bit unsigned integer.
+ * @example
+ * ```typescript
+ * const x = asUint8(255); // Uint8
+ * const y = asUint8(0); // Uint8
+ * // asUint8(-1); // throws TypeError
+ * // asUint8(256); // throws TypeError
+ * // asUint8(1.5); // throws TypeError
+ * ```
+ */
+export declare const asUint8: (x: number) => Uint8;
+/**
+ * Namespace providing type-safe arithmetic operations for 8-bit unsigned integers.
+ *
+ * All operations automatically clamp results to the valid Uint8 range [0, 255].
+ * This ensures that all arithmetic maintains the 8-bit unsigned integer constraint,
+ * with negative results clamped to 0 and overflow results clamped to MAX_VALUE.
+ *
+ * @example
+ * ```typescript
+ * const a = asUint8(200);
+ * const b = asUint8(100);
+ *
+ * // Arithmetic operations with automatic clamping
+ * const sum = Uint8.add(a, b);       // Uint8 (255 - clamped to MAX_VALUE)
+ * const diff = Uint8.sub(a, b);      // Uint8 (100)
+ * const reverseDiff = Uint8.sub(b, a); // Uint8 (0 - clamped to MIN_VALUE)
+ * const product = Uint8.mul(a, b);   // Uint8 (255 - clamped due to overflow)
+ *
+ * // Range operations
+ * const clamped = Uint8.clamp(-10);     // Uint8 (0)
+ * const minimum = Uint8.min(a, b);      // Uint8 (100)
+ * const maximum = Uint8.max(a, b);      // Uint8 (200)
+ *
+ * // Utility operations
+ * const random = Uint8.random(asUint8(50), asUint8(150)); // Uint8 (random value in [50, 150])
+ * const power = Uint8.pow(asUint8(2), asUint8(7)); // Uint8 (128)
+ * ```
+ */
+export declare const Uint8: {
+    /**
+     * Type guard to check if a value is a Uint8.
+     * @param value The value to check.
+     * @returns `true` if the value is an 8-bit unsigned integer, `false` otherwise.
+     */
+    readonly is: (x: number) => x is Uint8;
+    /**
+     * The minimum value for an 8-bit unsigned integer.
+     * @readonly
+     */
+    readonly MIN_VALUE: 0;
+    /**
+     * The maximum value for an 8-bit unsigned integer.
+     * @readonly
+     */
+    readonly MAX_VALUE: 255;
+    /**
+     * Returns the larger of the given Uint8 values.
+     * @param values The Uint8 values to compare.
+     * @returns The maximum value as a Uint8.
+     */
+    readonly max: (...values: readonly Uint8[]) => Uint8;
+    /**
+     * Returns the smaller of the given Uint8 values.
+     * @param values The Uint8 values to compare.
+     * @returns The minimum value as a Uint8.
+     */
+    readonly min: (...values: readonly Uint8[]) => Uint8;
+    /**
+     * Clamps a number to the Uint8 range.
+     * @param value The number to clamp.
+     * @returns The value clamped to [0, 255] as a Uint8.
+     */
+    readonly clamp: (a: number) => Uint8;
+    /**
+     * Generates a random Uint8 value within the specified range.
+     * @param min The minimum value (inclusive).
+     * @param max The maximum value (inclusive).
+     * @returns A random Uint8 between min and max.
+     */
+    readonly random: (min: Uint8, max: Uint8) => Uint8;
+    /**
+     * Raises a Uint8 to the power of another Uint8.
+     * @param a The base Uint8.
+     * @param b The exponent Uint8.
+     * @returns `a ** b` clamped to [0, 255] as a Uint8.
+     */
+    readonly pow: (x: Uint8, y: Uint8) => Uint8;
+    /**
+     * Adds two Uint8 values.
+     * @param a The first Uint8.
+     * @param b The second Uint8.
+     * @returns `a + b` clamped to [0, 255] as a Uint8.
+     */
+    readonly add: (x: Uint8, y: Uint8) => Uint8;
+    /**
+     * Subtracts one Uint8 from another.
+     * @param a The minuend Uint8.
+     * @param b The subtrahend Uint8.
+     * @returns `a - b` clamped to [0, 255] as a Uint8 (minimum 0).
+     */
+    readonly sub: (x: Uint8, y: Uint8) => Uint8;
+    /**
+     * Multiplies two Uint8 values.
+     * @param a The first Uint8.
+     * @param b The second Uint8.
+     * @returns `a * b` clamped to [0, 255] as a Uint8.
+     */
+    readonly mul: (x: Uint8, y: Uint8) => Uint8;
+    /**
+     * Divides one Uint8 by another using floor division.
+     * @param a The dividend Uint8.
+     * @param b The divisor Uint8 (cannot be 0).
+     * @returns `⌊a / b⌋` clamped to [0, 255] as a Uint8.
+     */
+    readonly div: (x: Uint8, y: Exclude<Uint8, 0>) => Uint8;
+};
+//# sourceMappingURL=uint8.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uint8.d.mts","sourceRoot":"","sources":["../../../src/number/enum/uint8.mts"],"names":[],"mappings":"AAiJA;;;;GAIG;AACH,eAAO,MAAM,OAAO,MAhHL,MAAM,KAAG,CAAC,IAAI,KAgHJ,CAAC;AAE1B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,MAxGC,MAAM,KAAG,KAwGC,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,KAAK;IAChB;;;;OAIG;qBAnKU,MAAM,KAAG,CAAC,IAAI,KAAK;IAsKhC;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;8BA/HoB,SAAS,KAAK,EAAE,KAAG,KAAK;IAkI/C;;;;OAIG;8BA9IoB,SAAS,KAAK,EAAE,KAAG,KAAK;IAiJ/C;;;;OAIG;wBAnKa,MAAM,KAAG,KAAK;IAsK9B;;;;;OAKG;2BApGgB,KAAK,OAAO,KAAK,KAAG,KAAK;IAuG5C;;;;;OAKG;sBApJW,KAAK,KAAK,KAAK,KAAG,KAAK;IAuJrC;;;;;OAKG;sBApJW,KAAK,KAAK,KAAK,KAAG,KAAK;IAuJrC;;;;;OAKG;sBApJW,KAAK,KAAK,KAAK,KAAG,KAAK;IAuJrC;;;;;OAKG;sBApJW,KAAK,KAAK,KAAK,KAAG,KAAK;IAuJrC;;;;;OAKG;sBApJW,KAAK,KAAK,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,KAAG,KAAK;CAsJzC,CAAC"}