ts-data-forge 9.0.0 → 9.0.1

package/dist/number/enum/int8.mjs

@@ -1,20 +1,29 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
-const typeNameInMessage = 'an integer in [-128, 127]';
-const { MAX_VALUE, MIN_VALUE, castType: castTypeImpl, clamp: clampImpl, is: isImpl, random: randomImpl, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
-    MIN_VALUE: -128,
-    MAX_VALUE: 127,
-    typeNameInMessage,
+const typeNameInMessage = "an integer in [-128, 127]";
+const {
+  MAX_VALUE,
+  MIN_VALUE,
+  castType: castTypeImpl,
+  clamp: clampImpl,
+  is: isImpl,
+  random: randomImpl
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
+  integerOrSafeInteger: "SafeInteger",
+  MIN_VALUE: -128,
+  MAX_VALUE: 127,
+  typeNameInMessage
 });
 const is = (x) => isImpl(x);
-const castType = (x) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-castTypeImpl(x);
+const castType = (x) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  castTypeImpl(x)
+);
 const clamp = (a) => castType(clampImpl(a));
-const abs = (x) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-Math.abs(x);
+const abs = (x) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  Math.abs(x)
+);
 const min_ = (...values) => castType(Math.min(...values));
 const max_ = (...values) => castType(Math.max(...values));
 const pow = (x, y) => clamp(x ** y);
@@ -23,142 +32,107 @@ const sub = (x, y) => clamp(x - y);
 const mul = (x, y) => clamp(x * y);
 const div = (x, y) => clamp(Math.floor(x / y));
 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
- */
 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
- */
 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)
- */
 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
-     */
-    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
-     */
-    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]
-     */
-    random,
-    /**
-     * 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]
-     */
-    pow,
-    /**
-     * Adds two Int8 values, clamped to Int8 range.
-     *
-     * @param x - First operand
-     * @param y - Second operand
-     * @returns `x + y` clamped to [-128, 127]
-     */
-    add,
-    /**
-     * Subtracts two Int8 values, clamped to Int8 range.
-     *
-     * @param x - First operand
-     * @param y - Second operand
-     * @returns `x - y` clamped to [-128, 127]
-     */
-    sub,
-    /**
-     * Multiplies two Int8 values, clamped to Int8 range.
-     *
-     * @param x - First operand
-     * @param y - Second operand
-     * @returns `x * y` clamped to [-128, 127]
-     */
-    mul,
-    /**
-     * 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]
-     */
-    div,
+  /**
+   * 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
+   */
+  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
+   */
+  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]
+   */
+  random,
+  /**
+   * 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]
+   */
+  pow,
+  /**
+   * Adds two Int8 values, clamped to Int8 range.
+   *
+   * @param x - First operand
+   * @param y - Second operand
+   * @returns `x + y` clamped to [-128, 127]
+   */
+  add,
+  /**
+   * Subtracts two Int8 values, clamped to Int8 range.
+   *
+   * @param x - First operand
+   * @param y - Second operand
+   * @returns `x - y` clamped to [-128, 127]
+   */
+  sub,
+  /**
+   * Multiplies two Int8 values, clamped to Int8 range.
+   *
+   * @param x - First operand
+   * @param y - Second operand
+   * @returns `x * y` clamped to [-128, 127]
+   */
+  mul,
+  /**
+   * 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]
+   */
+  div
 };
 
 export { Int8, asInt8, isInt8 };

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

@@ -1 +1 @@
-{"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;;;;;"}
+{"version":3,"file":"int8.mjs","sources":["../../../src/number/enum/int8.mts"],"sourcesContent":["import {\n  type AbsoluteValue,\n  type Int16,\n  type Int8 as TtfImported_Int8,\n} from 'ts-type-forge';\nimport { expectType } from '../../expect-type.mjs';\nimport { TsDataForgeInternals } from '../refined-number-utils.mjs';\n\nexport type Int8 = TtfImported_Int8;\n\nconst typeNameInMessage = 'an integer in [-128, 127]';\n\nconst {\n  MAX_VALUE,\n  MIN_VALUE,\n  castType: castTypeImpl,\n  clamp: clampImpl,\n  is: isImpl,\n  random: randomImpl,\n} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<\n  Int16,\n  -128,\n  127\n>({\n  integerOrSafeInteger: 'SafeInteger',\n  MIN_VALUE: -128,\n  MAX_VALUE: 127,\n  typeNameInMessage,\n} as const);\n\nconst is = (x: number): x is Int8 => isImpl(x);\n\nconst castType = (x: number): Int8 =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  castTypeImpl(x) as Int8;\n\nconst clamp = (a: number): Int8 => castType(clampImpl(a));\n\nconst abs = <N extends Int8>(x: N): AbsoluteValue<N> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Math.abs(x) as unknown as AbsoluteValue<N>;\n\nconst min_ = (...values: readonly Int8[]): Int8 =>\n  castType(Math.min(...values));\n\nconst max_ = (...values: readonly Int8[]): Int8 =>\n  castType(Math.max(...values));\n\nconst pow = (x: Int8, y: Int8): Int8 => clamp(x ** y);\n\nconst add = (x: Int8, y: Int8): Int8 => clamp(x + y);\n\nconst sub = (x: Int8, y: Int8): Int8 => clamp(x - y);\n\nconst mul = (x: Int8, y: Int8): Int8 => clamp(x * y);\n\nconst div = (x: Int8, y: Exclude<Int8, 0>): Int8 => clamp(Math.floor(x / y));\n\nconst random = (min: Int8, max: Int8): Int8 =>\n  castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));\n\n/**\n * Type guard that checks if a value is an 8-bit signed integer.\n *\n * An Int8 is a signed integer in the range [-128, 127], representing values\n * that fit in exactly 8 bits of memory.\n *\n * @param value - The value to check\n * @returns `true` if the value is an Int8, `false` otherwise\n */\nexport const isInt8 = is;\n\n/**\n * Casts a number to an Int8 branded type.\n *\n * This function validates that the input is within the Int8 range [-128, 127]\n * and is an integer, then returns it with the Int8 brand.\n *\n * @param value - The value to cast\n * @returns The value as an Int8 branded type\n * @throws {TypeError} If the value is not a valid 8-bit signed integer\n */\nexport const asInt8 = castType;\n\n/**\n * Namespace providing type-safe operations for Int8 (8-bit signed integer)\n * branded types.\n *\n * Int8 represents signed integers in the range [-128, 127], equivalent to a\n * signed byte in many programming languages. All operations automatically clamp\n * results to stay within this range, preventing overflow/underflow issues.\n *\n * This type is useful for:\n *\n * - Binary data processing (signed bytes)\n * - Small integer values with known bounds\n * - Embedded systems programming\n * - Memory-efficient integer storage\n * - Image processing (signed pixel offsets)\n */\nexport const Int8 = {\n  /**\n   * Type guard that checks if a value is an 8-bit signed integer.\n   *\n   * @param value - The value to check\n   * @returns `true` if the value is in range [-128, 127] and is an integer\n   * @see {@link isInt8} for usage examples\n   */\n  is,\n\n  /**\n   * The minimum value for an 8-bit signed integer.\n   *\n   * @readonly\n   */\n  MIN_VALUE,\n\n  /**\n   * The maximum value for an 8-bit signed integer.\n   *\n   * @readonly\n   */\n  MAX_VALUE,\n\n  /**\n   * Returns the minimum value from a list of Int8 values.\n   *\n   * @param values - The Int8 values to compare (at least one required)\n   * @returns The smallest value as an Int8\n   */\n  min: min_,\n\n  /**\n   * Returns the maximum value from a list of Int8 values.\n   *\n   * @param values - The Int8 values to compare (at least one required)\n   * @returns The largest value as an Int8\n   */\n  max: max_,\n\n  /**\n   * Clamps a number to the Int8 range.\n   *\n   * @param value The number to clamp.\n   * @returns The value clamped to [-128, 127] as an Int8.\n   */\n  clamp,\n\n  /**\n   * Returns the absolute value of an Int8.\n   *\n   * @param value The Int8 value.\n   * @returns The absolute value as an Int8, clamped to valid range.\n   */\n  abs,\n\n  /**\n   * Generates a random Int8 value within the specified range (inclusive).\n   *\n   * Both bounds are inclusive. If min > max, they are automatically swapped.\n   *\n   * @param min - The minimum value (inclusive)\n   * @param max - The maximum value (inclusive)\n   * @returns A random Int8 in the range [min, max]\n   */\n  random,\n\n  /**\n   * Raises x to the power of y, clamped to Int8 range.\n   *\n   * @param x - The base\n   * @param y - The exponent\n   * @returns `x ** y` clamped to [-128, 127]\n   */\n  pow,\n\n  /**\n   * Adds two Int8 values, clamped to Int8 range.\n   *\n   * @param x - First operand\n   * @param y - Second operand\n   * @returns `x + y` clamped to [-128, 127]\n   */\n  add,\n\n  /**\n   * Subtracts two Int8 values, clamped to Int8 range.\n   *\n   * @param x - First operand\n   * @param y - Second operand\n   * @returns `x - y` clamped to [-128, 127]\n   */\n  sub,\n\n  /**\n   * Multiplies two Int8 values, clamped to Int8 range.\n   *\n   * @param x - First operand\n   * @param y - Second operand\n   * @returns `x * y` clamped to [-128, 127]\n   */\n  mul,\n\n  /**\n   * Divides two Int8 values, clamped to Int8 range.\n   *\n   * @param x - The dividend\n   * @param y - The divisor (cannot be 0)\n   * @returns `⌊x / y⌋` clamped to [-128, 127]\n   */\n  div,\n} as const;\n\nexpectType<\n  keyof typeof Int8,\n  keyof TsDataForgeInternals.RefinedNumberUtils.NumberClass<\n    Int16,\n    'int' | 'range'\n  >\n>('=');\n"],"names":[],"mappings":";;AAUA,MAAM,iBAAA,GAAoB,2BAAA;AAE1B,MAAM;AAAA,EACJ,SAAA;AAAA,EACA,SAAA;AAAA,EACA,QAAA,EAAU,YAAA;AAAA,EACV,KAAA,EAAO,SAAA;AAAA,EACP,EAAA,EAAI,MAAA;AAAA,EACJ,MAAA,EAAQ;AACV,CAAA,GAAI,oBAAA,CAAqB,mBAAmB,mBAAA,CAI1C;AAAA,EACA,oBAAA,EAAsB,aAAA;AAAA,EACtB,SAAA,EAAW,IAAA;AAAA,EACX,SAAA,EAAW,GAAA;AAAA,EACX;AACF,CAAU,CAAA;AAEV,MAAM,EAAA,GAAK,CAAC,CAAA,KAAyB,MAAA,CAAO,CAAC,CAAA;AAE7C,MAAM,WAAW,CAAC,CAAA;AAAA;AAAA,EAEhB,aAAa,CAAC;AAAA,CAAA;AAEhB,MAAM,QAAQ,CAAC,CAAA,KAAoB,QAAA,CAAS,SAAA,CAAU,CAAC,CAAC,CAAA;AAExD,MAAM,MAAM,CAAiB,CAAA;AAAA;AAAA,EAE3B,IAAA,CAAK,IAAI,CAAC;AAAA,CAAA;AAEZ,MAAM,IAAA,GAAO,IAAI,MAAA,KACf,QAAA,CAAS,KAAK,GAAA,CAAI,GAAG,MAAM,CAAC,CAAA;AAE9B,MAAM,IAAA,GAAO,IAAI,MAAA,KACf,QAAA,CAAS,KAAK,GAAA,CAAI,GAAG,MAAM,CAAC,CAAA;AAE9B,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,KAAA,CAAM,KAAK,CAAC,CAAA;AAEpD,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,KAAA,CAAM,IAAI,CAAC,CAAA;AAEnD,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,KAAA,CAAM,IAAI,CAAC,CAAA;AAEnD,MAAM,MAAM,CAAC,CAAA,EAAS,CAAA,KAAkB,KAAA,CAAM,IAAI,CAAC,CAAA;AAEnD,MAAM,GAAA,GAAM,CAAC,CAAA,EAAS,CAAA,KAA8B,MAAM,IAAA,CAAK,KAAA,CAAM,CAAA,GAAI,CAAC,CAAC,CAAA;AAE3E,MAAM,MAAA,GAAS,CAAC,GAAA,EAAW,GAAA,KACzB,QAAA,CAAS,UAAA,CAAW,YAAA,CAAa,GAAG,CAAA,EAAG,YAAA,CAAa,GAAG,CAAC,CAAC,CAAA;AAWpD,MAAM,MAAA,GAAS;AAYf,MAAM,MAAA,GAAS;AAkBf,MAAM,IAAA,GAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQlB,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQL,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQL,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA;AACF;;;;"}

package/dist/number/enum/uint8.mjs

@@ -1,16 +1,26 @@
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';
 
-const typeNameInMessage = 'an non-negative integer less than 256';
-const { MAX_VALUE, MIN_VALUE, castType: castTypeImpl, clamp: clampImpl, is: isImpl, random: randomImpl, } = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger({
-    integerOrSafeInteger: 'SafeInteger',
+const typeNameInMessage = "an non-negative integer less than 256";
+const {
+  MAX_VALUE,
+  MIN_VALUE,
+  castType: castTypeImpl,
+  clamp: clampImpl,
+  is: isImpl,
+  random: randomImpl
+} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger(
+  {
+    integerOrSafeInteger: "SafeInteger",
     MIN_VALUE: 0,
     MAX_VALUE: 255,
-    typeNameInMessage,
-});
+    typeNameInMessage
+  }
+);
 const is = (x) => isImpl(x);
-const castType = (x) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-castTypeImpl(x);
+const castType = (x) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  castTypeImpl(x)
+);
 const clamp = (a) => castType(clampImpl(a));
 const min_ = (...values) => castType(Math.min(...values));
 const max_ = (...values) => castType(Math.max(...values));
@@ -20,122 +30,98 @@ const sub = (x, y) => clamp(x - y);
 const mul = (x, y) => clamp(x * y);
 const div = (x, y) => clamp(Math.floor(x / y));
 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. 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.
- */
 const asUint8 = castType;
-/**
- * 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.
- */
 const 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.
-     */
-    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 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, clamped to Uint8 range.
-     *
-     * @param x - First operand
-     * @param y - Second operand
-     * @returns `x + y` clamped to [0, 255]
-     */
-    add,
-    /**
-     * 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, clamped to Uint8 range.
-     *
-     * @param x - First operand
-     * @param y - Second operand
-     * @returns `x * y` clamped to [0, 255]
-     */
-    mul,
-    /**
-     * 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,
+  /**
+   * 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.
+   */
+  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 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, clamped to Uint8 range.
+   *
+   * @param x - First operand
+   * @param y - Second operand
+   * @returns `x + y` clamped to [0, 255]
+   */
+  add,
+  /**
+   * 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, clamped to Uint8 range.
+   *
+   * @param x - First operand
+   * @param y - Second operand
+   * @returns `x * y` clamped to [0, 255]
+   */
+  mul,
+  /**
+   * 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
 };
 
 export { Uint8, asUint8, isUint8 };

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

@@ -1 +1 @@
-{"version":3,"file":"uint8.mjs","sources":["../../../src/number/enum/uint8.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAMA,MAAM,iBAAiB,GAAG,uCAAuC;AAEjE,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,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;;;;;"}
+{"version":3,"file":"uint8.mjs","sources":["../../../src/number/enum/uint8.mts"],"sourcesContent":["import { type Uint8 as TtfImported_Uint8, type Uint16 } from 'ts-type-forge';\nimport { expectType } from '../../expect-type.mjs';\nimport { TsDataForgeInternals } from '../refined-number-utils.mjs';\n\nexport type Uint8 = TtfImported_Uint8;\n\nconst typeNameInMessage = 'an non-negative integer less than 256';\n\nconst {\n  MAX_VALUE,\n  MIN_VALUE,\n  castType: castTypeImpl,\n  clamp: clampImpl,\n  is: isImpl,\n  random: randomImpl,\n} = TsDataForgeInternals.RefinedNumberUtils.operatorsForInteger<Uint16, 0, 255>(\n  {\n    integerOrSafeInteger: 'SafeInteger',\n    MIN_VALUE: 0,\n    MAX_VALUE: 255,\n    typeNameInMessage,\n  } as const,\n);\n\nconst is = (x: number): x is Uint8 => isImpl(x);\n\nconst castType = (x: number): Uint8 =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  castTypeImpl(x) as Uint8;\n\nconst clamp = (a: number): Uint8 => castType(clampImpl(a));\n\nconst min_ = (...values: readonly Uint8[]): Uint8 =>\n  castType(Math.min(...values));\n\nconst max_ = (...values: readonly Uint8[]): Uint8 =>\n  castType(Math.max(...values));\n\nconst pow = (x: Uint8, y: Uint8): Uint8 => clamp(x ** y);\n\nconst add = (x: Uint8, y: Uint8): Uint8 => clamp(x + y);\n\nconst sub = (x: Uint8, y: Uint8): Uint8 => clamp(x - y);\n\nconst mul = (x: Uint8, y: Uint8): Uint8 => clamp(x * y);\n\nconst div = (x: Uint8, y: Exclude<Uint8, 0>): Uint8 => clamp(Math.floor(x / y));\n\nconst random = (min: Uint8, max: Uint8): Uint8 =>\n  castType(randomImpl(castTypeImpl(min), castTypeImpl(max)));\n\n/**\n * Checks if a number is a Uint8 (8-bit unsigned integer in the range [0, 255]).\n *\n * @param value The value to check.\n * @returns `true` if the value is a Uint8, `false` otherwise.\n */\nexport const isUint8 = is;\n\n/**\n * Casts a number to a Uint8 type. This function validates that the input is\n * within the Uint8 range [0, 255] and is an integer, then returns it with the\n * Uint8 brand.\n *\n * @param value The value to cast.\n * @returns The value as a Uint8 type.\n * @throws {TypeError} If the value is not a valid 8-bit unsigned integer.\n */\nexport const asUint8 = castType;\n\n/**\n * Namespace providing type-safe arithmetic operations for 8-bit unsigned\n * integers.\n *\n * All operations automatically clamp results to the valid Uint8 range [0, 255].\n * This ensures that all arithmetic maintains the 8-bit unsigned integer\n * constraint, with negative results clamped to 0 and overflow results clamped\n * to MAX_VALUE.\n */\nexport const Uint8 = {\n  /**\n   * Type guard that checks if a value is an 8-bit unsigned integer.\n   *\n   * @param value The value to check.\n   * @returns `true` if the value is an 8-bit unsigned integer, `false`\n   *   otherwise.\n   */\n  is,\n\n  /**\n   * The minimum value for an 8-bit unsigned integer.\n   *\n   * @readonly\n   */\n  MIN_VALUE,\n\n  /**\n   * The maximum value for an 8-bit unsigned integer.\n   *\n   * @readonly\n   */\n  MAX_VALUE,\n\n  /**\n   * Returns the larger of the given Uint8 values.\n   *\n   * @param values The Uint8 values to compare.\n   * @returns The maximum value as a Uint8.\n   */\n  max: max_,\n\n  /**\n   * Returns the smaller of the given Uint8 values.\n   *\n   * @param values The Uint8 values to compare.\n   * @returns The minimum value as a Uint8.\n   */\n  min: min_,\n\n  /**\n   * Clamps a number to the Uint8 range.\n   *\n   * @param value The number to clamp.\n   * @returns The value clamped to [0, 255] as a Uint8.\n   */\n  clamp,\n\n  /**\n   * Generates a random Uint8 value within the specified range.\n   *\n   * @param min The minimum value (inclusive).\n   * @param max The maximum value (inclusive).\n   * @returns A random Uint8 between min and max.\n   */\n  random,\n\n  /**\n   * Raises x to the power of y, clamped to Uint8 range.\n   *\n   * @param x - The base\n   * @param y - The exponent\n   * @returns `x ** y` clamped to [0, 255]\n   */\n  pow,\n\n  /**\n   * Adds two Uint8 values, clamped to Uint8 range.\n   *\n   * @param x - First operand\n   * @param y - Second operand\n   * @returns `x + y` clamped to [0, 255]\n   */\n  add,\n\n  /**\n   * Subtracts two Uint8 values, clamped to Uint8 range.\n   *\n   * @param x - First operand\n   * @param y - Second operand\n   * @returns `x - y` clamped to [0, 255]\n   */\n  sub,\n\n  /**\n   * Multiplies two Uint8 values, clamped to Uint8 range.\n   *\n   * @param x - First operand\n   * @param y - Second operand\n   * @returns `x * y` clamped to [0, 255]\n   */\n  mul,\n\n  /**\n   * Divides two Uint8 values, clamped to Uint8 range.\n   *\n   * @param x - The dividend\n   * @param y - The divisor (cannot be 0)\n   * @returns `⌊x / y⌋` clamped to [0, 255]\n   */\n  div,\n} as const;\n\nexpectType<\n  keyof typeof Uint8,\n  keyof TsDataForgeInternals.RefinedNumberUtils.NumberClass<\n    Uint16,\n    'int' | 'non-negative' | 'range'\n  >\n>('=');\n"],"names":[],"mappings":";;AAMA,MAAM,iBAAA,GAAoB,uCAAA;AAE1B,MAAM;AAAA,EACJ,SAAA;AAAA,EACA,SAAA;AAAA,EACA,QAAA,EAAU,YAAA;AAAA,EACV,KAAA,EAAO,SAAA;AAAA,EACP,EAAA,EAAI,MAAA;AAAA,EACJ,MAAA,EAAQ;AACV,CAAA,GAAI,qBAAqB,kBAAA,CAAmB,mBAAA;AAAA,EAC1C;AAAA,IACE,oBAAA,EAAsB,aAAA;AAAA,IACtB,SAAA,EAAW,CAAA;AAAA,IACX,SAAA,EAAW,GAAA;AAAA,IACX;AAAA;AAEJ,CAAA;AAEA,MAAM,EAAA,GAAK,CAAC,CAAA,KAA0B,MAAA,CAAO,CAAC,CAAA;AAE9C,MAAM,WAAW,CAAC,CAAA;AAAA;AAAA,EAEhB,aAAa,CAAC;AAAA,CAAA;AAEhB,MAAM,QAAQ,CAAC,CAAA,KAAqB,QAAA,CAAS,SAAA,CAAU,CAAC,CAAC,CAAA;AAEzD,MAAM,IAAA,GAAO,IAAI,MAAA,KACf,QAAA,CAAS,KAAK,GAAA,CAAI,GAAG,MAAM,CAAC,CAAA;AAE9B,MAAM,IAAA,GAAO,IAAI,MAAA,KACf,QAAA,CAAS,KAAK,GAAA,CAAI,GAAG,MAAM,CAAC,CAAA;AAE9B,MAAM,MAAM,CAAC,CAAA,EAAU,CAAA,KAAoB,KAAA,CAAM,KAAK,CAAC,CAAA;AAEvD,MAAM,MAAM,CAAC,CAAA,EAAU,CAAA,KAAoB,KAAA,CAAM,IAAI,CAAC,CAAA;AAEtD,MAAM,MAAM,CAAC,CAAA,EAAU,CAAA,KAAoB,KAAA,CAAM,IAAI,CAAC,CAAA;AAEtD,MAAM,MAAM,CAAC,CAAA,EAAU,CAAA,KAAoB,KAAA,CAAM,IAAI,CAAC,CAAA;AAEtD,MAAM,GAAA,GAAM,CAAC,CAAA,EAAU,CAAA,KAAgC,MAAM,IAAA,CAAK,KAAA,CAAM,CAAA,GAAI,CAAC,CAAC,CAAA;AAE9E,MAAM,MAAA,GAAS,CAAC,GAAA,EAAY,GAAA,KAC1B,QAAA,CAAS,UAAA,CAAW,YAAA,CAAa,GAAG,CAAA,EAAG,YAAA,CAAa,GAAG,CAAC,CAAC,CAAA;AAQpD,MAAM,OAAA,GAAU;AAWhB,MAAM,OAAA,GAAU;AAWhB,MAAM,KAAA,GAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQnB,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQL,GAAA,EAAK,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQL,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA;AACF;;;;"}

package/dist/number/num.d.mts

@@ -449,7 +449,7 @@ export declare namespace Num {
      * @returns `a / b`, typed as the tightest branded type guaranteed to contain
      *   it.
      */
-    export const div: <A extends number, B extends NonZeroNumber | SmallInt<"!=0">>(a: A, b: B) => DivResult<A, B>;
+    export const div: <A extends number, B extends NonZeroNumber | SmallInt<'!=0'>>(a: A, b: B) => DivResult<A, B>;
     /**
      * Performs integer division using floor division.
      *
@@ -463,7 +463,7 @@ export declare namespace Num {
      * @param b - The divisor
      * @returns The integer quotient, or `NaN` if b is zero
      */
-    export const divInt: <A extends number, B extends NonZeroNumber | SmallInt<"!=0">>(a: A, b: B) => DivIntResult<A, B>;
+    export const divInt: <A extends number, B extends NonZeroNumber | SmallInt<'!=0'>>(a: A, b: B) => DivIntResult<A, B>;
     /**
      * Rounds a number to a specified number of decimal places.
      *

package/dist/number/num.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"num.d.mts","sourceRoot":"","sources":["../../src/number/num.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"num.d.mts","sourceRoot":"","sources":["../../src/number/num.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,GAAG,EACR,KAAK,GAAG,EACR,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,2BAA2B,EAChC,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,SAAS,EAEf,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EACL,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;;;;;GAcG;AACH,yBAAiB,GAAG,CAAC;IACnB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAe,CAAC;IAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8DG;IACH,MAAM,CAAC,MAAM,YAAY,MAAO,MAAM,KAAG,MAAM,CAAC,GAAG,EAAE,KAAK,CAYzD,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8DG;IACH,MAAM,CAAC,MAAM,cAAc,MAAO,MAAM,KAAG,MAAM,CAAC,YAAY,EAAE,KAAK,CAepE,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,MAAM,SAAS,GAAI,CAAC,SAAS,MAAM,OACnC,CAAC,KACL,GAAG,IAAI,aAAa,GAAG,cAAc,CAAC,CAAC,EAAE,CAAC,CAAc,CAAC;IAI5D;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,MAAM,CAAC,MAAM,aAAa,GAAI,CAAC,SAAS,MAAM,OACvC,CAAC,KACL,GAAG,IAAI,iBAAiB,GAAG,cAAc,CAAC,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CACzD,CAAC;IAEX;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,MAAM,UAAU,GAAI,CAAC,SAAS,MAAM,OACpC,CAAC,KACL,GAAG,IAAI,cAAc,GAAG,cAAc,CAAC,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAC3D,CAAC;IAEV;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,MAAM,SAAS,eACP,MAAM,cAAc,MAAM,SACnC,MAAM,KAAG,OACsB,CAAC;IAEtC;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,MAAM,kBAAkB,eAChB,MAAM,cAAc,MAAM,SACnC,MAAM,KAAG,OACuB,CAAC;IAEvC;;;;;;;;;OASG;IACH,KAAK,EAAE,GAAG,QAAQ,CAAC;SAAG,CAAC,IAAI,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC;KAAE,CAAC,CAAC;IAEnD;;;;;;;;;OASG;IACH,KAAK,GAAG,GAAG,QAAQ,CAAC;SAAG,CAAC,IAAI,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;KAAE,CAAC,CAAC;IAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,MAAM,CAAC,MAAM,aAAa,GACvB,CAAC,SAAS,SAAS,EAAE,CAAC,SAAS,SAAS,cAAc,CAAC,cAAc,CAAC,SACnE,MAAM,KAAG,CAAC,IAAI,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CACY,CAAC;IAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,MAAM,CAAC,MAAM,sBAAsB,GAChC,CAAC,SAAS,SAAS,EAAE,CAAC,SAAS,SAAS,cAAc,CAAC,cAAc,CAAC,SACnE,MAAM,KAAG,CAAC,IAAI,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CACY,CAAC;IAElE;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,UAAU,KAAK,CACnB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC;IAGV,MAAM,UAAU,KAAK,CACnB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;IAyB9B;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,MAAM,GAAG,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,KACjD,CAAC,KACD,CAAC,KACH,SAAS,CAAC,CAAC,EAAE,CAAC,CAEW,CAAC;IAE7B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,MAAM,GAAG,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,KACjD,CAAC,KACD,CAAC,KACH,SAAS,CAAC,CAAC,EAAE,CAAC,CAEW,CAAC;IAE7B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,MAAM,GAAG,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,KACjD,CAAC,KACD,CAAC,KACH,SAAS,CAAC,CAAC,EAAE,CAAC,CAEW,CAAC;IAE7B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,MAAM,GAAG,GACd,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,aAAa,GAAG,QAAQ,CAAC,KAAK,CAAC,KAEtC,CAAC,KACD,CAAC,KACH,SAAS,CAAC,CAAC,EAAE,CAAC,CAEW,CAAC;IAE7B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,MAAM,MAAM,GACjB,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,aAAa,GAAG,QAAQ,CAAC,KAAK,CAAC,KAEtC,CAAC,KACD,CAAC,KACH,YAAY,CAAC,CAAC,EAAE,CAAC,CAMnB,CAAC;IAEF;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,OAAO,QACb,MAAM,aACA,2BAA2B,KACrC,MAKF,CAAC;IAEF;;;;;;;;;OASG;IAEH,MAAM,CAAC,MAAM,UAAU,QAAS,MAAM,KAAG,GAAmC,CAAC;IAE7E;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,KAAK,UACT,2BAA2B,KACjC,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAM1B,CAAC;IAEF;;;;;;;;;;OAUG;IACH,MAAM,CAAC,MAAM,gBAAgB,GAAI,CAAC,SAAS,MAAM,OAC1C,CAAC,KACL,cAAc,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,SAIS,CAAC;IAE1C;;;;;;;;;;OAUG;IACH,MAAM,CAAC,MAAM,SAAS,GAAI,CAAC,SAAS,SAAS,KAAK,CAAC,KAAG,SAAS,CAAC,CAAC,CAExC,CAAC;IAE1B;;;;;;;;;;OAUG;IACH,MAAM,CAAC,MAAM,SAAS,GAAI,CAAC,SAAS,gBAAgB,KAAK,CAAC,KAAG,SAAS,CAAC,CAAC,CAE/C,CAAC;;CAC3B"}