@brightchain/brightchain-lib 0.1.5 → 0.1.6

package/src/lib/utils/checksumUtils.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Checksum utility functions for working with Checksum class and legacy types.
+ *
+ * This module provides utility functions for converting between different
+ * checksum representations and working with both the new Checksum class
+ * and legacy Uint8Array checksums.
+ *
+ * @module utils/checksumUtils
+ *
+ * @example
+ * ```typescript
+ * import { uint8ArrayToHex, hexToChecksum } from 'brightchain-lib';
+ *
+ * // Convert Checksum to hex
+ * const hex = uint8ArrayToHex(checksum);
+ *
+ * // Convert Uint8Array to hex
+ * const hex2 = uint8ArrayToHex(uint8Array);
+ *
+ * // Convert hex to Checksum
+ * const checksum = hexToChecksum(hex);
+ * ```
+ *
+ * @see Requirements 5.1, 5.2, 5.4
+ */
+import { Checksum } from '../types/checksum';
+/**
+ * Convert Checksum or Uint8Array to hex string.
+ *
+ * This function provides a unified interface for converting both Checksum
+ * instances and Uint8Array to hex strings. It handles the type checking
+ * internally and delegates to the appropriate conversion method.
+ *
+ * @param data - The Checksum or Uint8Array to convert
+ * @returns The hex string representation
+ *
+ * @example
+ * ```typescript
+ * // With Checksum
+ * const checksum = Checksum.fromBuffer(buffer);
+ * const hex = uint8ArrayToHex(checksum); // Uses checksum.toHex()
+ *
+ * // With Uint8Array
+ * const array = new Uint8Array([1, 2, 3]);
+ * const hex2 = uint8ArrayToHex(array); // Uses ecies-lib conversion
+ * ```
+ *
+ * @see Requirement 5.1
+ */
+export declare function uint8ArrayToHex(data: Checksum | Uint8Array): string;
+/**
+ * Convert hex string to Checksum.
+ *
+ * This function creates a Checksum instance from a hex string.
+ * It validates the hex string format and length.
+ *
+ * @param hex - The hex string to convert
+ * @returns A new Checksum instance
+ * @throws ChecksumError if hex string is invalid or wrong length
+ *
+ * @example
+ * ```typescript
+ * const hex = 'a1b2c3d4...'; // 128 hex characters = 64 bytes
+ * const checksum = hexToChecksum(hex);
+ * ```
+ *
+ * @see Requirement 5.2
+ */
+export declare function hexToChecksum(hex: string): Checksum;
+/**
+ * Convert Checksum to Uint8Array.
+ *
+ * This function extracts the underlying Uint8Array from a Checksum instance.
+ * Returns a copy to maintain immutability.
+ *
+ * @param checksum - The Checksum to convert
+ * @returns A new Uint8Array containing the checksum data
+ *
+ * @example
+ * ```typescript
+ * const checksum = Checksum.fromBuffer(buffer);
+ * const array = checksumToUint8Array(checksum);
+ * ```
+ *
+ * @see Requirement 5.4
+ */
+export declare function checksumToUint8Array(checksum: Checksum): Uint8Array;
+/**
+ * Convert Checksum to Buffer.
+ *
+ * This function extracts the underlying data as a Buffer from a Checksum instance.
+ *
+ * @param checksum - The Checksum to convert
+ * @returns A new Buffer containing the checksum data
+ *
+ * @example
+ * ```typescript
+ * const checksum = Checksum.fromUint8Array(array);
+ * const buffer = checksumToBuffer(checksum);
+ * ```
+ *
+ * @see Requirement 5.4
+ */
+export declare function checksumToBuffer(checksum: Checksum): Buffer;
+//# sourceMappingURL=checksumUtils.d.ts.map

package/src/lib/utils/checksumUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checksumUtils.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/utils/checksumUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,CAKnE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAEnD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,UAAU,CAEnE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE3D"}

package/src/lib/utils/checksumUtils.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Checksum utility functions for working with Checksum class and legacy types.
+ *
+ * This module provides utility functions for converting between different
+ * checksum representations and working with both the new Checksum class
+ * and legacy Uint8Array checksums.
+ *
+ * @module utils/checksumUtils
+ *
+ * @example
+ * ```typescript
+ * import { uint8ArrayToHex, hexToChecksum } from 'brightchain-lib';
+ *
+ * // Convert Checksum to hex
+ * const hex = uint8ArrayToHex(checksum);
+ *
+ * // Convert Uint8Array to hex
+ * const hex2 = uint8ArrayToHex(uint8Array);
+ *
+ * // Convert hex to Checksum
+ * const checksum = hexToChecksum(hex);
+ * ```
+ *
+ * @see Requirements 5.1, 5.2, 5.4
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint8ArrayToHex = uint8ArrayToHex;
+exports.hexToChecksum = hexToChecksum;
+exports.checksumToUint8Array = checksumToUint8Array;
+exports.checksumToBuffer = checksumToBuffer;
+const ecies_lib_1 = require("@digitaldefiance/ecies-lib");
+const checksum_1 = require("../types/checksum");
+/**
+ * Convert Checksum or Uint8Array to hex string.
+ *
+ * This function provides a unified interface for converting both Checksum
+ * instances and Uint8Array to hex strings. It handles the type checking
+ * internally and delegates to the appropriate conversion method.
+ *
+ * @param data - The Checksum or Uint8Array to convert
+ * @returns The hex string representation
+ *
+ * @example
+ * ```typescript
+ * // With Checksum
+ * const checksum = Checksum.fromBuffer(buffer);
+ * const hex = uint8ArrayToHex(checksum); // Uses checksum.toHex()
+ *
+ * // With Uint8Array
+ * const array = new Uint8Array([1, 2, 3]);
+ * const hex2 = uint8ArrayToHex(array); // Uses ecies-lib conversion
+ * ```
+ *
+ * @see Requirement 5.1
+ */
+function uint8ArrayToHex(data) {
+    if (data instanceof checksum_1.Checksum) {
+        return data.toHex();
+    }
+    return (0, ecies_lib_1.uint8ArrayToHex)(data);
+}
+/**
+ * Convert hex string to Checksum.
+ *
+ * This function creates a Checksum instance from a hex string.
+ * It validates the hex string format and length.
+ *
+ * @param hex - The hex string to convert
+ * @returns A new Checksum instance
+ * @throws ChecksumError if hex string is invalid or wrong length
+ *
+ * @example
+ * ```typescript
+ * const hex = 'a1b2c3d4...'; // 128 hex characters = 64 bytes
+ * const checksum = hexToChecksum(hex);
+ * ```
+ *
+ * @see Requirement 5.2
+ */
+function hexToChecksum(hex) {
+    return checksum_1.Checksum.fromHex(hex);
+}
+/**
+ * Convert Checksum to Uint8Array.
+ *
+ * This function extracts the underlying Uint8Array from a Checksum instance.
+ * Returns a copy to maintain immutability.
+ *
+ * @param checksum - The Checksum to convert
+ * @returns A new Uint8Array containing the checksum data
+ *
+ * @example
+ * ```typescript
+ * const checksum = Checksum.fromBuffer(buffer);
+ * const array = checksumToUint8Array(checksum);
+ * ```
+ *
+ * @see Requirement 5.4
+ */
+function checksumToUint8Array(checksum) {
+    return checksum.toUint8Array();
+}
+/**
+ * Convert Checksum to Buffer.
+ *
+ * This function extracts the underlying data as a Buffer from a Checksum instance.
+ *
+ * @param checksum - The Checksum to convert
+ * @returns A new Buffer containing the checksum data
+ *
+ * @example
+ * ```typescript
+ * const checksum = Checksum.fromUint8Array(array);
+ * const buffer = checksumToBuffer(checksum);
+ * ```
+ *
+ * @see Requirement 5.4
+ */
+function checksumToBuffer(checksum) {
+    return checksum.toBuffer();
+}
+//# sourceMappingURL=checksumUtils.js.map

package/src/lib/utils/checksumUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checksumUtils.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/utils/checksumUtils.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;AA4BH,0CAKC;AAoBD,sCAEC;AAmBD,oDAEC;AAkBD,4CAEC;AA9FD,0DAAqF;AACrF,gDAA6C;AAE7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,eAAe,CAAC,IAA2B;IACzD,IAAI,IAAI,YAAY,mBAAQ,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IACD,OAAO,IAAA,2BAAoB,EAAC,IAAI,CAAC,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,aAAa,CAAC,GAAW;IACvC,OAAO,mBAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,oBAAoB,CAAC,QAAkB;IACrD,OAAO,QAAQ,CAAC,YAAY,EAAE,CAAC;AACjC,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,gBAAgB,CAAC,QAAkB;IACjD,OAAO,QAAQ,CAAC,QAAQ,EAAE,CAAC;AAC7B,CAAC"}

package/src/lib/utils/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Utils Module for BrightChain
+ *
+ * This module exports utility classes and functions for the BrightChain library.
+ *
+ * @module utils
+ *
+ * @example
+ * ```typescript
+ * import { Validator, checksumToBuffer, checksumFromHex } from 'brightchain-lib';
+ *
+ * // Use Validator for input validation
+ * Validator.validateBlockSize(params.blockSize, 'processBlock');
+ * Validator.validateBlockType(params.blockType, 'processBlock');
+ * Validator.validateRequired(params.data, 'data', 'processBlock');
+ *
+ * // Use checksum utilities (deprecated - prefer Checksum class methods)
+ * const buffer = checksumToBuffer(checksum);
+ * const checksum = checksumFromHex(hexString);
+ * ```
+ */
+/**
+ * Input validation utilities for BrightChain services.
+ *
+ * Provides methods for validating:
+ * - Block sizes
+ * - Block types
+ * - Encryption types
+ * - Recipient counts
+ * - Required fields
+ * - Non-empty strings
+ *
+ * @see {@link Validator}
+ */
+export * from './validator';
+/**
+ * Checksum conversion utilities for working with Checksum class.
+ *
+ * Provides functions for converting between:
+ * - Checksum and hex strings
+ * - Checksum and Uint8Array
+ * - Checksum and Buffer
+ *
+ * @see {@link checksumUtils}
+ */
+export * from './checksumUtils';
+//# sourceMappingURL=index.d.ts.map

package/src/lib/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAKH;;;;;;;;;;;;GAYG;AACH,cAAc,aAAa,CAAC;AAK5B;;;;;;;;;GASG;AACH,cAAc,iBAAiB,CAAC"}

package/src/lib/utils/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Utils Module for BrightChain
+ *
+ * This module exports utility classes and functions for the BrightChain library.
+ *
+ * @module utils
+ *
+ * @example
+ * ```typescript
+ * import { Validator, checksumToBuffer, checksumFromHex } from 'brightchain-lib';
+ *
+ * // Use Validator for input validation
+ * Validator.validateBlockSize(params.blockSize, 'processBlock');
+ * Validator.validateBlockType(params.blockType, 'processBlock');
+ * Validator.validateRequired(params.data, 'data', 'processBlock');
+ *
+ * // Use checksum utilities (deprecated - prefer Checksum class methods)
+ * const buffer = checksumToBuffer(checksum);
+ * const checksum = checksumFromHex(hexString);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// ============================================================================
+// Validation Utilities
+// ============================================================================
+/**
+ * Input validation utilities for BrightChain services.
+ *
+ * Provides methods for validating:
+ * - Block sizes
+ * - Block types
+ * - Encryption types
+ * - Recipient counts
+ * - Required fields
+ * - Non-empty strings
+ *
+ * @see {@link Validator}
+ */
+tslib_1.__exportStar(require("./validator"), exports);
+// ============================================================================
+// Checksum Utilities
+// ============================================================================
+/**
+ * Checksum conversion utilities for working with Checksum class.
+ *
+ * Provides functions for converting between:
+ * - Checksum and hex strings
+ * - Checksum and Uint8Array
+ * - Checksum and Buffer
+ *
+ * @see {@link checksumUtils}
+ */
+tslib_1.__exportStar(require("./checksumUtils"), exports);
+//# sourceMappingURL=index.js.map

package/src/lib/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/utils/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,+EAA+E;AAC/E,uBAAuB;AACvB,+EAA+E;AAC/E;;;;;;;;;;;;GAYG;AACH,sDAA4B;AAE5B,+EAA+E;AAC/E,qBAAqB;AACrB,+EAA+E;AAC/E;;;;;;;;;GASG;AACH,0DAAgC"}

package/src/lib/utils/validator.d.ts

@@ -0,0 +1,216 @@
+/**
+ * Validator Utility Class
+ *
+ * Provides comprehensive input validation utilities for BrightChain services.
+ * All validation methods throw EnhancedValidationError with descriptive messages
+ * when validation fails.
+ *
+ * @remarks
+ * - Use these validators at service boundaries to catch invalid inputs early
+ * - All validators include optional context for better error messages
+ * - Validators are designed to be composable and reusable
+ *
+ * @example
+ * ```typescript
+ * // Validate block parameters
+ * Validator.validateBlockSize(params.blockSize, 'calculateCapacity');
+ * Validator.validateBlockType(params.blockType, 'calculateCapacity');
+ * Validator.validateEncryptionType(params.encryptionType, 'calculateCapacity');
+ *
+ * // Validate required fields
+ * Validator.validateRequired(params.cbl, 'cbl', 'ExtendedCBL');
+ * Validator.validateNotEmpty(params.cbl.fileName, 'fileName', 'ExtendedCBL');
+ * ```
+ *
+ * @see Requirements 5.1, 5.2, 5.3, 5.5, 5.6, 12.1, 12.2, 12.3, 12.4, 12.5, 12.6, 12.7
+ * @module utils/validator
+ */
+import { BlockEncryptionType } from '../enumerations/blockEncryptionType';
+import { BlockSize } from '../enumerations/blockSize';
+import { BlockType } from '../enumerations/blockType';
+/**
+ * Validation utilities for common patterns across BrightChain services.
+ *
+ * This class provides static methods for validating:
+ * - Block sizes (enum validation)
+ * - Block types (enum validation)
+ * - Encryption types (enum validation)
+ * - Recipient counts (range validation with encryption type context)
+ * - Required fields (null/undefined checks)
+ * - Non-empty strings (whitespace-only checks)
+ *
+ * @remarks
+ * All validation methods follow a consistent pattern:
+ * 1. Check the value against valid options
+ * 2. Throw EnhancedValidationError with field name and context if invalid
+ * 3. Return void if valid (or use type assertion for validateRequired)
+ *
+ * @example
+ * ```typescript
+ * // In a service method
+ * public processBlock(params: IBlockParams): void {
+ *   // Validate all inputs at the start
+ *   Validator.validateBlockSize(params.blockSize, 'processBlock');
+ *   Validator.validateBlockType(params.blockType, 'processBlock');
+ *
+ *   // Now safe to proceed with validated inputs
+ *   // ...
+ * }
+ * ```
+ *
+ * @see Requirements 5.1, 5.2, 5.3, 5.5, 5.6
+ */
+export declare class Validator {
+    /**
+     * Validate that a block size is a valid BlockSize enum value.
+     *
+     * @param blockSize - The block size to validate
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If the block size is not a valid BlockSize enum value
+     *
+     * @remarks
+     * - BlockSize.Unknown (0) is considered invalid for actual use
+     * - Only values in validBlockSizes array are accepted
+     *
+     * @example
+     * ```typescript
+     * // Valid usage
+     * Validator.validateBlockSize(BlockSize.Medium, 'calculateCapacity');
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateBlockSize(999 as BlockSize, 'calculateCapacity');
+     * Validator.validateBlockSize(BlockSize.Unknown, 'calculateCapacity');
+     * ```
+     *
+     * @see Requirements 5.1, 12.3
+     */
+    static validateBlockSize(blockSize: BlockSize, context?: string): void;
+    /**
+     * Validate that a block type is a valid BlockType enum value.
+     *
+     * @param blockType - The block type to validate
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If the block type is not a valid BlockType enum value
+     *
+     * @remarks
+     * - BlockType.Unknown (-1) is considered invalid for actual use
+     * - All other BlockType enum values are valid
+     *
+     * @example
+     * ```typescript
+     * // Valid usage
+     * Validator.validateBlockType(BlockType.RawData, 'processBlock');
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateBlockType(999 as BlockType, 'processBlock');
+     * Validator.validateBlockType(BlockType.Unknown, 'processBlock');
+     * ```
+     *
+     * @see Requirements 5.1, 12.4
+     */
+    static validateBlockType(blockType: BlockType, context?: string): void;
+    /**
+     * Validate that an encryption type is a valid BlockEncryptionType enum value.
+     *
+     * @param encryptionType - The encryption type to validate
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If the encryption type is not a valid BlockEncryptionType enum value
+     *
+     * @example
+     * ```typescript
+     * // Valid usage
+     * Validator.validateEncryptionType(BlockEncryptionType.SingleRecipient, 'encrypt');
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateEncryptionType(999 as BlockEncryptionType, 'encrypt');
+     * ```
+     *
+     * @see Requirements 5.1, 12.5
+     */
+    static validateEncryptionType(encryptionType: BlockEncryptionType, context?: string): void;
+    /**
+     * Validate recipient count for multi-recipient encryption.
+     *
+     * @param recipientCount - The number of recipients (may be undefined for non-multi-recipient)
+     * @param encryptionType - The encryption type being used
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If recipient count is invalid for the encryption type
+     *
+     * @remarks
+     * - For MultiRecipient encryption, recipientCount must be at least 1
+     * - For MultiRecipient encryption, recipientCount cannot exceed ECIES.MULTIPLE.MAX_RECIPIENTS
+     * - For other encryption types, recipientCount is ignored
+     *
+     * @example
+     * ```typescript
+     * // Valid usage
+     * Validator.validateRecipientCount(5, BlockEncryptionType.MultiRecipient, 'encrypt');
+     * Validator.validateRecipientCount(undefined, BlockEncryptionType.SingleRecipient, 'encrypt');
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateRecipientCount(0, BlockEncryptionType.MultiRecipient, 'encrypt');
+     * Validator.validateRecipientCount(undefined, BlockEncryptionType.MultiRecipient, 'encrypt');
+     * Validator.validateRecipientCount(1000, BlockEncryptionType.MultiRecipient, 'encrypt');
+     * ```
+     *
+     * @see Requirements 5.3, 12.6
+     */
+    static validateRecipientCount(recipientCount: number | undefined, encryptionType: BlockEncryptionType, context?: string): void;
+    /**
+     * Validate that a required field is present (not null or undefined).
+     *
+     * @param value - The value to check
+     * @param fieldName - The name of the field being validated
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If the value is null or undefined
+     *
+     * @remarks
+     * This method uses TypeScript's assertion signature to narrow the type
+     * after validation, allowing safe access to the value.
+     *
+     * @example
+     * ```typescript
+     * // Type narrowing example
+     * function processData(data: string | undefined): void {
+     *   Validator.validateRequired(data, 'data', 'processData');
+     *   // TypeScript now knows data is string, not undefined
+     *   console.log(data.length);
+     * }
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateRequired(undefined, 'config', 'initialize');
+     * Validator.validateRequired(null, 'user', 'authenticate');
+     * ```
+     *
+     * @see Requirements 5.2, 5.6
+     */
+    static validateRequired<T>(value: T | undefined | null, fieldName: string, context?: string): asserts value is T;
+    /**
+     * Validate that a string is not empty or whitespace-only.
+     *
+     * @param value - The string value to check
+     * @param fieldName - The name of the field being validated
+     * @param context - Optional context string for error messages (e.g., method name)
+     * @throws {EnhancedValidationError} If the value is empty or contains only whitespace
+     *
+     * @remarks
+     * - Empty strings ('') are invalid
+     * - Whitespace-only strings ('   ') are invalid
+     * - Strings with leading/trailing whitespace but content are valid
+     *
+     * @example
+     * ```typescript
+     * // Valid usage
+     * Validator.validateNotEmpty('hello', 'name', 'createUser');
+     * Validator.validateNotEmpty('  hello  ', 'name', 'createUser'); // Valid - has content
+     *
+     * // Throws EnhancedValidationError
+     * Validator.validateNotEmpty('', 'name', 'createUser');
+     * Validator.validateNotEmpty('   ', 'name', 'createUser');
+     * ```
+     *
+     * @see Requirements 5.2, 5.6, 12.7
+     */
+    static validateNotEmpty(value: string, fieldName: string, context?: string): void;
+}
+//# sourceMappingURL=validator.d.ts.map

package/src/lib/utils/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/utils/validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAmB,MAAM,2BAA2B,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,SAAS;IACpB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAUtE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IActE;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,sBAAsB,CAC3B,cAAc,EAAE,mBAAmB,EACnC,OAAO,CAAC,EAAE,MAAM,GACf,IAAI;IAcP;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,sBAAsB,CAC3B,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,cAAc,EAAE,mBAAmB,EACnC,OAAO,CAAC,EAAE,MAAM,GACf,IAAI;IAqBP;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,MAAM,CAAC,gBAAgB,CAAC,CAAC,EACvB,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,IAAI,EAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,KAAK,IAAI,CAAC;IAQrB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,MAAM,CAAC,gBAAgB,CACrB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,IAAI;CASR"}