ts-data-forge 3.2.0 → 3.3.1

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

@@ -1,127 +1,117 @@
 /**
  * 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.
+ * Casts a number to a Uint8 type. This function validates that the input is
+ * within the Uint8 range [0, 255] and is an integer, then returns it with the
+ * Uint8 brand.
+ *
  * @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.
+ * 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)
- * ```
+ * 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.
  */
 export declare const Uint8: {
     /**
-     * Type guard to check if a value is a Uint8.
+     * Type guard that checks if a value is an 8-bit unsigned integer.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is an 8-bit unsigned integer, `false` otherwise.
+     * @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.
+     * Raises x to the power of y, clamped to Uint8 range.
+     *
+     * @param x - The base
+     * @param y - The exponent
+     * @returns `x ** y` clamped to [0, 255]
      */
     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.
+     * Adds two Uint8 values, clamped to Uint8 range.
+     *
+     * @param x - First operand
+     * @param y - Second operand
+     * @returns `x + y` clamped to [0, 255]
      */
     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).
+     * Subtracts two Uint8 values, clamped to Uint8 range.
+     *
+     * @param x - First operand
+     * @param y - Second operand
+     * @returns `x - y` clamped to [0, 255]
      */
     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.
+     * Multiplies two Uint8 values, clamped to Uint8 range.
+     *
+     * @param x - First operand
+     * @param y - Second operand
+     * @returns `x * y` clamped to [0, 255]
      */
     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.
+     * Divides two Uint8 values, clamped to Uint8 range.
+     *
+     * @param x - The dividend
+     * @param y - The divisor (cannot be 0)
+     * @returns `⌊x / y⌋` clamped to [0, 255]
      */
     readonly div: (x: Uint8, y: Exclude<Uint8, 0>) => Uint8;
 };

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

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

package/dist/number/enum/uint8.mjs

@@ -7,242 +7,133 @@ const { MIN_VALUE, MAX_VALUE, random: randomImpl, is: isImpl, castType: castType
     MAX_VALUE: 255,
     typeNameInMessage,
 });
-/**
- * Type guard that checks if a value is an 8-bit unsigned integer.
- *
- * A Uint8 is an unsigned integer in the range [0, 255], representing
- * values that fit in exactly 8 bits of memory (1 byte).
- *
- * @param x - The number to check
- * @returns `true` if x is a valid Uint8, `false` otherwise
- *
- * @example
- * ```typescript
- * is(100);   // true
- * is(0);     // true (minimum value)
- * is(255);   // true (maximum value)
- * is(256);   // false (exceeds max)
- * is(-1);    // false (negative)
- * is(5.5);   // false (not integer)
- * ```
- */
 const is = (x) => isImpl(x);
-/**
- * Casts a number to a Uint8 branded type.
- *
- * This function validates that the input is within the Uint8 range [0, 255]
- * and is an integer, then returns it with the Uint8 brand.
- *
- * @param x - The number to convert
- * @returns The number as a Uint8 branded type
- * @throws {TypeError} If x is not a valid 8-bit unsigned integer
- *
- * @example
- * ```typescript
- * const byte = castType(200);    // Uint8
- * const zero = castType(0);      // Uint8 (minimum)
- * const max = castType(255);     // Uint8 (maximum)
- *
- * // These throw TypeError:
- * // castType(256);              // Exceeds maximum
- * // castType(-1);               // Negative value
- * // castType(1.5);              // Not an integer
- * ```
- */
 const castType = (x) => 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
 castTypeImpl(x);
-/**
- * Clamps a number to the Uint8 range [0, 255].
- * @param a - The number to clamp
- * @returns The clamped value as Uint8
- */
 const clamp = (a) => castType(clampImpl(a));
-/**
- * Returns the minimum value from a list of Uint8 values.
- *
- * @param values - The Uint8 values to compare (at least one required)
- * @returns The smallest value as a Uint8
- *
- * @example
- * ```typescript
- * min_(asUint8(50), asUint8(30), asUint8(100)); // Uint8 (30)
- * min_(asUint8(0), asUint8(255));               // Uint8 (0)
- * ```
- */
 const min_ = (...values) => castType(Math.min(...values));
-/**
- * Returns the maximum of the given Uint8 values.
- * @param values - The Uint8 values to compare
- * @returns The maximum value
- */
 const max_ = (...values) => castType(Math.max(...values));
-/**
- * Raises x to the power of y, clamped to Uint8 range.
- * @param x - The base
- * @param y - The exponent
- * @returns x^y clamped to [0, 255]
- */
 const pow = (x, y) => clamp(x ** y);
-/**
- * Adds two Uint8 values, clamped to Uint8 range.
- * @param x - First operand
- * @param y - Second operand
- * @returns x + y clamped to [0, 255]
- */
 const add = (x, y) => clamp(x + y);
-/**
- * Subtracts two Uint8 values, clamped to Uint8 range.
- * @param x - First operand
- * @param y - Second operand
- * @returns x - y clamped to [0, 255]
- */
 const sub = (x, y) => clamp(x - y);
-/**
- * Multiplies two Uint8 values, clamped to Uint8 range.
- * @param x - First operand
- * @param y - Second operand
- * @returns x * y clamped to [0, 255]
- */
 const mul = (x, y) => clamp(x * y);
-/**
- * Divides two Uint8 values, clamped to Uint8 range.
- * @param x - The dividend
- * @param y - The divisor (cannot be 0)
- * @returns ⌊x / y⌋ clamped to [0, 255]
- */
 const div = (x, y) => clamp(Math.floor(x / y));
-/**
- * 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
- */
 const random = (min, max) => castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));
 /**
  * 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.
  */
 const isUint8 = is;
 /**
- * Casts a number to a Uint8 type.
+ * Casts a number to a Uint8 type. This function validates that the input is
+ * within the Uint8 range [0, 255] and is an integer, then returns it with the
+ * Uint8 brand.
+ *
  * @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
- * ```
  */
 const asUint8 = castType;
 /**
- * Namespace providing type-safe arithmetic operations for 8-bit unsigned integers.
+ * 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)
- * ```
+ * 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.
  */
 const Uint8 = {
     /**
-     * Type guard to check if a value is a Uint8.
+     * Type guard that checks if a value is an 8-bit unsigned integer.
+     *
      * @param value The value to check.
-     * @returns `true` if the value is an 8-bit unsigned integer, `false` otherwise.
+     * @returns `true` if the value is an 8-bit unsigned integer, `false`
+     *   otherwise.
      */
     is,
     /**
      * The minimum value for an 8-bit unsigned integer.
+     *
      * @readonly
      */
     MIN_VALUE,
     /**
      * The maximum value for an 8-bit unsigned integer.
+     *
      * @readonly
      */
     MAX_VALUE,
     /**
      * Returns the larger of the given Uint8 values.
+     *
      * @param values The Uint8 values to compare.
      * @returns The maximum value as a Uint8.
      */
     max: max_,
     /**
      * Returns the smaller of the given Uint8 values.
+     *
      * @param values The Uint8 values to compare.
      * @returns The minimum value as a Uint8.
      */
     min: min_,
     /**
      * Clamps a number to the Uint8 range.
+     *
      * @param value The number to clamp.
      * @returns The value clamped to [0, 255] as a Uint8.
      */
     clamp,
     /**
      * 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.
      */
     random,
     /**
-     * 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.
+     * Raises x to the power of y, clamped to Uint8 range.
+     *
+     * @param x - The base
+     * @param y - The exponent
+     * @returns `x ** y` clamped to [0, 255]
      */
     pow,
     /**
-     * Adds two Uint8 values.
-     * @param a The first Uint8.
-     * @param b The second Uint8.
-     * @returns `a + b` clamped to [0, 255] as a Uint8.
+     * Adds two Uint8 values, clamped to Uint8 range.
+     *
+     * @param x - First operand
+     * @param y - Second operand
+     * @returns `x + y` clamped to [0, 255]
      */
     add,
     /**
-     * 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).
+     * Subtracts two Uint8 values, clamped to Uint8 range.
+     *
+     * @param x - First operand
+     * @param y - Second operand
+     * @returns `x - y` clamped to [0, 255]
      */
     sub,
     /**
-     * Multiplies two Uint8 values.
-     * @param a The first Uint8.
-     * @param b The second Uint8.
-     * @returns `a * b` clamped to [0, 255] as a Uint8.
+     * Multiplies two Uint8 values, clamped to Uint8 range.
+     *
+     * @param x - First operand
+     * @param y - Second operand
+     * @returns `x * y` clamped to [0, 255]
      */
     mul,
     /**
-     * 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.
+     * Divides two Uint8 values, clamped to Uint8 range.
+     *
+     * @param x - The dividend
+     * @param y - The divisor (cannot be 0)
+     * @returns `⌊x / y⌋` clamped to [0, 255]
      */
     div,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"uint8.mjs","sources":["../../../src/number/enum/uint8.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,MAAM,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EAAE,UAAU,EAClB,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,SAAS,GACjB,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAC7D;AACE,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,GAAG;IACd,iBAAiB;AACT,CAAA,CACX;AAED;;;;;;;;;;;;;;;;;;AAkBG;AACH,MAAM,EAAE,GAAG,CAAC,CAAS,KAAiB,MAAM,CAAC,CAAC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;AAqBG;AACH,MAAM,QAAQ,GAAG,CAAC,CAAS;AACzB;AACA,YAAY,CAAC,CAAC,CAAU;AAE1B;;;;AAIG;AACH,MAAM,KAAK,GAAG,CAAC,CAAS,KAAY,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAE1D;;;;;;;;;;;AAWG;AACH,MAAM,IAAI,GAAG,CAAC,GAAG,MAAwB,KACvC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAE/B;;;;AAIG;AACH,MAAM,IAAI,GAAG,CAAC,GAAG,MAAwB,KACvC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAE/B;;;;;AAKG;AACH,MAAM,GAAG,GAAG,CAAC,CAAQ,EAAE,CAAQ,KAAY,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;AAExD;;;;;AAKG;AACH,MAAM,GAAG,GAAG,CAAC,CAAQ,EAAE,CAAQ,KAAY,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEvD;;;;;AAKG;AACH,MAAM,GAAG,GAAG,CAAC,CAAQ,EAAE,CAAQ,KAAY,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEvD;;;;;AAKG;AACH,MAAM,GAAG,GAAG,CAAC,CAAQ,EAAE,CAAQ,KAAY,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEvD;;;;;AAKG;AACH,MAAM,GAAG,GAAG,CAAC,CAAQ,EAAE,CAAoB,KAAY,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAE/E;;;;;AAKG;AACH,MAAM,MAAM,GAAG,CAAC,GAAU,EAAE,GAAU,KACpC,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC;AAE5D;;;;AAIG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;;AAaG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,KAAK,GAAG;AACnB;;;;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;;;;AAIG;IACH,KAAK;AAEL;;;;;AAKG;IACH,MAAM;AAEN;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;AAEH;;;;;AAKG;IACH,GAAG;;;;;"}
+{"version":3,"file":"uint8.mjs","sources":["../../../src/number/enum/uint8.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,MAAM,EACJ,SAAS,EACT,SAAS,EACT,MAAM,EAAE,UAAU,EAClB,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,SAAS,GACjB,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,mBAAmB,CAC7D;AACE,IAAA,oBAAoB,EAAE,aAAa;AACnC,IAAA,SAAS,EAAE,CAAC;AACZ,IAAA,SAAS,EAAE,GAAG;IACd,iBAAiB;AACT,CAAA,CACX;AAED,MAAM,EAAE,GAAG,CAAC,CAAS,KAAiB,MAAM,CAAC,CAAC,CAAC;AAE/C,MAAM,QAAQ,GAAG,CAAC,CAAS;AACzB;AACA,YAAY,CAAC,CAAC,CAAU;AAE1B,MAAM,KAAK,GAAG,CAAC,CAAS,KAAY,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAE1D,MAAM,IAAI,GAAG,CAAC,GAAG,MAAwB,KACvC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAE/B,MAAM,IAAI,GAAG,CAAC,GAAG,MAAwB,KACvC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAE/B,MAAM,GAAG,GAAG,CAAC,CAAQ,EAAE,CAAQ,KAAY,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;AAExD,MAAM,GAAG,GAAG,CAAC,CAAQ,EAAE,CAAQ,KAAY,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEvD,MAAM,GAAG,GAAG,CAAC,CAAQ,EAAE,CAAQ,KAAY,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEvD,MAAM,GAAG,GAAG,CAAC,CAAQ,EAAE,CAAQ,KAAY,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;AAEvD,MAAM,GAAG,GAAG,CAAC,CAAQ,EAAE,CAAoB,KAAY,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAE/E,MAAM,MAAM,GAAG,CAAC,GAAU,EAAE,GAAU,KACpC,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC;AAE5D;;;;;AAKG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;AAQG;AACI,MAAM,OAAO,GAAG;AAEvB;;;;;;;;AAQG;AACI,MAAM,KAAK,GAAG;AACnB;;;;;;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;;;;;;AAMG;IACH,MAAM;AAEN;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;AAEH;;;;;;AAMG;IACH,GAAG;;;;;"}