@gala-chain/launchpad-sdk 5.0.4-beta.6 → 5.0.4-beta.60

package/dist/utils/error-factories.d.ts

@@ -0,0 +1,701 @@
+/**
+ * Error Factories
+ *
+ * Standardized error message generators for common validation failures.
+ * Eliminates duplicate error messages across services.
+ *
+ * @category Utilities
+ * @since 3.6.1
+ */
+import { ConfigurationError, NetworkError, TransactionError, ValidationError } from './errors';
+import type { Logger } from './Logger';
+/**
+ * Creates a standardized "token not found" validation error
+ *
+ * This factory eliminates duplicate token error messages found across
+ * multiple service files. It provides a single source of truth for
+ * token resolution failures.
+ *
+ * ## Replaces Patterns
+ *
+ * This function replaces 8+ instances of duplicate error creation:
+ *
+ * ### Before (Duplicate Pattern Across Services):
+ * ```typescript
+ * // TradeService.ts (×2)
+ * throw new ValidationError(
+ *   `Token "${tokenName}" not found. Please verify the token name is correct.`,
+ *   'tokenName',
+ *   'TOKEN_NOT_FOUND'
+ * );
+ *
+ * // BundleService.ts (×2)
+ * throw new ValidationError(
+ *   `Token "${tokenName}" not found. Please verify the token name is correct.`,
+ *   'tokenName',
+ *   'TOKEN_NOT_FOUND'
+ * );
+ *
+ * // GalaChainService.ts
+ * throw new ValidationError(
+ *   `Token '${tokenName}' not found or not available for transfer`,
+ *   'tokenName',
+ *   'TOKEN_NOT_FOUND'
+ * );
+ *
+ * // TokenResolverService.ts
+ * throw new ValidationError(
+ *   `Token "${tokenName}" not found. Please verify the token name is correct.`,
+ *   'tokenName',
+ *   'TOKEN_NOT_FOUND'
+ * );
+ * ```
+ *
+ * ### After (Single Source of Truth):
+ * ```typescript
+ * // TradeService.ts
+ * throw createTokenNotFoundError(tokenName);
+ *
+ * // BundleService.ts
+ * throw createTokenNotFoundError(tokenName);
+ *
+ * // GalaChainService.ts
+ * throw createTokenNotFoundError(tokenName, 'transfer');
+ *
+ * // TokenResolverService.ts
+ * throw createTokenNotFoundError(tokenName);
+ * ```
+ *
+ * @param tokenName The token name that was not found
+ * @param context Optional context for error message customization
+ * @returns ValidationError with standardized message
+ *
+ * @example Basic usage
+ * ```typescript
+ * const tokenName = 'mytoken';
+ * const vaultAddress = await resolveTokenName(tokenName);
+ * if (!vaultAddress) {
+ *   throw createTokenNotFoundError(tokenName);
+ * }
+ * // Throws: ValidationError with message:
+ * // "Token "mytoken" not found. Please verify the token name is correct."
+ * ```
+ *
+ * @example With transfer context
+ * ```typescript
+ * const tokenName = 'mytoken';
+ * const tokenInfo = await getTokenForTransfer(tokenName);
+ * if (!tokenInfo) {
+ *   throw createTokenNotFoundError(tokenName, 'transfer');
+ * }
+ * // Throws: ValidationError with message:
+ * // "Token 'mytoken' not found or not available for transfer"
+ * ```
+ */
+export declare function createTokenNotFoundError(tokenName: string, context?: 'transfer'): ValidationError;
+/**
+ * Creates a standardized "required field" validation error
+ *
+ * This factory eliminates duplicate required field error messages found across
+ * services and type guards. It provides consistent messaging for missing required fields.
+ *
+ * ## Replaces Patterns
+ *
+ * This function replaces 20+ instances of duplicate error creation:
+ *
+ * ### Before (Duplicate Pattern Across Services):
+ * ```typescript
+ * // Various services
+ * throw new ValidationError(
+ *   'Token name is required',
+ *   'tokenName',
+ *   'REQUIRED_FIELD'
+ * );
+ *
+ * throw new ValidationError(
+ *   'Wallet address is required',
+ *   'address',
+ *   'REQUIRED_FIELD'
+ * );
+ *
+ * throw new ValidationError(
+ *   'Amount is required',
+ *   'amount',
+ *   'REQUIRED_FIELD'
+ * );
+ * ```
+ *
+ * ### After (Single Source of Truth):
+ * ```typescript
+ * throw createRequiredFieldError('tokenName');
+ * throw createRequiredFieldError('address', 'Wallet address');
+ * throw createRequiredFieldError('amount');
+ * ```
+ *
+ * @param fieldName The field name that is required
+ * @param displayName Optional human-readable field name (defaults to capitalized fieldName)
+ * @returns ValidationError with standardized message
+ *
+ * @example Basic usage (auto-capitalized)
+ * ```typescript
+ * if (!tokenName) {
+ *   throw createRequiredFieldError('tokenName');
+ * }
+ * // Throws: ValidationError with message: "TokenName is required"
+ * ```
+ *
+ * @example With custom display name
+ * ```typescript
+ * if (!address) {
+ *   throw createRequiredFieldError('address', 'Wallet address');
+ * }
+ * // Throws: ValidationError with message: "Wallet address is required"
+ * ```
+ *
+ * @since 3.6.6
+ */
+export declare function createRequiredFieldError(fieldName: string, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "invalid format" validation error
+ *
+ * This factory eliminates duplicate format validation error messages found across
+ * services and type guards. It provides consistent messaging for format validation failures.
+ *
+ * ## Replaces Patterns
+ *
+ * This function replaces 15+ instances of duplicate error creation:
+ *
+ * ### Before (Duplicate Pattern Across Services):
+ * ```typescript
+ * // Various services
+ * throw new ValidationError(
+ *   'Token name must be a string between 2-20 characters',
+ *   'tokenName',
+ *   'INVALID_FORMAT'
+ * );
+ *
+ * throw new ValidationError(
+ *   'Wallet address must be a valid Ethereum address',
+ *   'address',
+ *   'INVALID_FORMAT'
+ * );
+ *
+ * throw new ValidationError(
+ *   'Amount must be a positive number',
+ *   'amount',
+ *   'INVALID_FORMAT'
+ * );
+ * ```
+ *
+ * ### After (Single Source of Truth):
+ * ```typescript
+ * throw createInvalidFormatError('tokenName', 'a string between 2-20 characters');
+ * throw createInvalidFormatError('address', 'a valid Ethereum address');
+ * throw createInvalidFormatError('amount', 'a positive number');
+ * ```
+ *
+ * @param fieldName The field name with invalid format
+ * @param expectedFormat Human-readable description of the expected format
+ * @param displayName Optional human-readable field name (defaults to capitalized fieldName)
+ * @returns ValidationError with standardized message
+ *
+ * @example Basic usage (auto-capitalized)
+ * ```typescript
+ * if (!isValidTokenName(tokenName)) {
+ *   throw createInvalidFormatError('tokenName', 'a string between 2-20 characters');
+ * }
+ * // Throws: ValidationError with message:
+ * // "TokenName must be a string between 2-20 characters"
+ * ```
+ *
+ * @example With custom display name
+ * ```typescript
+ * if (!isValidAddress(address)) {
+ *   throw createInvalidFormatError('address', 'a valid Ethereum address', 'Wallet address');
+ * }
+ * // Throws: ValidationError with message:
+ * // "Wallet address must be a valid Ethereum address"
+ * ```
+ *
+ * @since 3.6.6
+ */
+export declare function createInvalidFormatError(fieldName: string, expectedFormat: string, displayName?: string): ValidationError;
+/**
+ * Creates a standardized network error
+ *
+ * This factory eliminates duplicate network error messages found across
+ * HTTP clients and service layers. It provides consistent messaging for
+ * API communication failures.
+ *
+ * @param message Human-readable error message
+ * @param statusCode Optional HTTP status code
+ * @param originalError Optional original error that caused this failure
+ * @returns NetworkError with structured data
+ *
+ * @example HTTP request failure
+ * ```typescript
+ * try {
+ *   const response = await fetch('/api/pools');
+ * } catch (error) {
+ *   throw createNetworkError(
+ *     'Failed to fetch pool data',
+ *     response.status,
+ *     error
+ *   );
+ * }
+ * ```
+ *
+ * @since 3.7.3
+ */
+export declare function createNetworkError(message: string, statusCode?: number, originalError?: Error): NetworkError;
+/**
+ * Creates a standardized configuration error
+ *
+ * This factory eliminates duplicate configuration error messages found
+ * during SDK initialization. It provides consistent messaging for
+ * invalid or missing configuration parameters.
+ *
+ * @param message Human-readable error message
+ * @param field Optional configuration field name
+ * @returns ConfigurationError with structured data
+ *
+ * @example Invalid timeout
+ * ```typescript
+ * if (config.timeout < 1000 || config.timeout > 300000) {
+ *   throw createConfigurationError(
+ *     'Invalid timeout value: must be between 1000 and 300000',
+ *     'timeout'
+ *   );
+ * }
+ * ```
+ *
+ * @since 3.7.3
+ */
+export declare function createConfigurationError(message: string, field?: string): ConfigurationError;
+/**
+ * Creates a standardized transaction error
+ *
+ * This factory eliminates duplicate transaction error messages found
+ * across blockchain interaction layers. It provides consistent messaging
+ * for transaction failures with tracking information.
+ *
+ * @param message Human-readable error message
+ * @param transactionId Optional transaction identifier
+ * @param code Optional error code for programmatic handling
+ * @returns TransactionError with structured data
+ *
+ * @example Transaction reverted
+ * ```typescript
+ * if (receipt.status === 'reverted') {
+ *   throw createTransactionError(
+ *     'Transaction reverted: insufficient balance',
+ *     transactionId,
+ *     'INSUFFICIENT_BALANCE'
+ *   );
+ * }
+ * ```
+ *
+ * @since 3.7.3
+ */
+export declare function createTransactionError(message: string, transactionId?: string, code?: string): TransactionError;
+/**
+ * Handles network errors with consistent logging and error creation
+ *
+ * This utility eliminates the duplicated pattern of:
+ * 1. Logging the error
+ * 2. Creating and throwing a NetworkError with getErrorMessage
+ *
+ * ## Replaces Pattern
+ *
+ * ### Before (Duplicate across services):
+ * ```typescript
+ * } catch (error) {
+ *   this.logger.error('Failed to fetch tokens:', error);
+ *   throw createNetworkError(
+ *     `Failed to fetch tokens: ${getErrorMessage(error)}`,
+ *     undefined,
+ *     isError(error) ? error : undefined
+ *   );
+ * }
+ * ```
+ *
+ * ### After (Single line):
+ * ```typescript
+ * } catch (error) {
+ *   throw handleNetworkError(error, 'Failed to fetch tokens', this.logger);
+ * }
+ * ```
+ *
+ * @param error The caught error
+ * @param operation Human-readable description of the failed operation
+ * @param logger Optional logger instance for error logging
+ * @param statusCode Optional HTTP status code
+ * @returns NetworkError (always throws, return type for type inference)
+ *
+ * @example Basic usage
+ * ```typescript
+ * try {
+ *   const data = await fetchData();
+ * } catch (error) {
+ *   throw handleNetworkError(error, 'Failed to fetch data', this.logger);
+ * }
+ * ```
+ *
+ * @example With status code
+ * ```typescript
+ * try {
+ *   const response = await http.get('/api/data');
+ * } catch (error) {
+ *   throw handleNetworkError(error, 'API request failed', this.logger, 500);
+ * }
+ * ```
+ *
+ * @since 5.0.2
+ */
+export declare function handleNetworkError(error: unknown, operation: string, logger?: Logger, statusCode?: number): NetworkError;
+/**
+ * Creates a standardized "value out of range" validation error
+ *
+ * Consolidates duplicate range validation error patterns.
+ *
+ * @param fieldName The field name that is out of range
+ * @param min Minimum allowed value
+ * @param max Maximum allowed value
+ * @param actualValue The actual value that was out of range
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (page < 1 || page > 1000) {
+ *   throw createRangeError('page', 1, 1000, page);
+ * }
+ * // Throws: "Page must be between 1 and 1000, received: 0"
+ * ```
+ *
+ * @since 6.13.0
+ */
+export declare function createRangeError(fieldName: string, min: number | string, max: number | string, actualValue?: number | string, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "value too small" validation error
+ *
+ * @param fieldName The field name
+ * @param min Minimum allowed value
+ * @param actualValue The actual value
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (amount.isLessThan(minAmount)) {
+ *   throw createTooSmallError('amount', minAmount, amount.toString());
+ * }
+ * ```
+ *
+ * @since 6.13.0
+ */
+export declare function createTooSmallError(fieldName: string, min: number | string, actualValue?: number | string, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "value too large" validation error
+ *
+ * @param fieldName The field name
+ * @param max Maximum allowed value
+ * @param actualValue The actual value
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (limit > MAX_LIMIT) {
+ *   throw createTooLargeError('limit', MAX_LIMIT, limit);
+ * }
+ * ```
+ *
+ * @since 6.13.0
+ */
+export declare function createTooLargeError(fieldName: string, max: number | string, actualValue?: number | string, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "invalid type" validation error
+ *
+ * @param fieldName The field name
+ * @param expectedType Expected type description
+ * @param actualValue Optional actual value received
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (typeof value !== 'string') {
+ *   throw createInvalidTypeError('tokenName', 'string', typeof value);
+ * }
+ * ```
+ *
+ * @since 6.13.0
+ */
+export declare function createInvalidTypeError(fieldName: string, expectedType: string, actualValue?: unknown, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "invalid number" validation error
+ *
+ * Specialized error for numeric parsing failures.
+ *
+ * @param fieldName The field name
+ * @param actualValue The invalid value
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (isNaN(parsedValue)) {
+ *   throw createInvalidNumberError('amount', rawValue);
+ * }
+ * ```
+ *
+ * @since 6.13.0
+ */
+export declare function createInvalidNumberError(fieldName: string, actualValue?: string | number, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "parse error" validation error
+ *
+ * Used when parsing operations fail (JSON, token formats, etc.)
+ *
+ * @param fieldName The field being parsed
+ * @param format Expected format description
+ * @param actualValue The value that failed to parse
+ * @param parseError Optional underlying parse error message
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const data = JSON.parse(jsonString);
+ * } catch (e) {
+ *   throw createParseError('config', 'valid JSON', jsonString, e.message);
+ * }
+ * ```
+ *
+ * @since 6.13.0
+ */
+export declare function createParseError(fieldName: string, format: string, actualValue?: string, parseError?: string): ValidationError;
+/**
+ * Creates a standardized "pool not found" validation error
+ *
+ * Consolidates duplicate pool error messages.
+ *
+ * @param token0 First token identifier
+ * @param token1 Second token identifier
+ * @param fee Optional fee tier
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (!pool) {
+ *   throw createPoolNotFoundError('GALA', 'GUSDC', 3000);
+ * }
+ * ```
+ *
+ * @since 6.13.0
+ */
+export declare function createPoolNotFoundError(token0: string, token1: string, fee?: number): ValidationError;
+/**
+ * Creates a standardized "position not found" validation error
+ *
+ * @param positionId The position identifier
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (!position) {
+ *   throw createPositionNotFoundError(positionId);
+ * }
+ * ```
+ *
+ * @since 6.13.0
+ */
+export declare function createPositionNotFoundError(positionId: string | number): ValidationError;
+/**
+ * Creates a standardized "operation failed" validation error
+ *
+ * Generic factory for operation failures with context.
+ *
+ * @param operation Description of the operation that failed
+ * @param reason Reason for failure
+ * @param fieldName Optional field related to the failure
+ * @param code Optional error code (defaults to 'OPERATION_FAILED')
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * throw createOperationError('Token swap', 'insufficient liquidity', 'amount');
+ * ```
+ *
+ * @since 6.13.0
+ */
+export declare function createOperationError(operation: string, reason: string, fieldName?: string, code?: string): ValidationError;
+/**
+ * Creates a standardized "insufficient balance" validation error
+ *
+ * @param tokenName Token with insufficient balance
+ * @param required Required amount
+ * @param available Available amount
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (balance.isLessThan(required)) {
+ *   throw createInsufficientBalanceError('GALA', required.toString(), balance.toString());
+ * }
+ * ```
+ *
+ * @since 6.13.0
+ */
+export declare function createInsufficientBalanceError(tokenName: string, required: string, available: string): ValidationError;
+/**
+ * Creates a standardized "invalid enum value" validation error
+ *
+ * Consolidates duplicate enum validation error patterns.
+ *
+ * @param fieldName The field name with invalid enum value
+ * @param actualValue The actual value that was invalid
+ * @param validValues Array of valid enum values
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * const validStatuses = ['PENDING', 'CLAIMED', 'REVOKED'];
+ * if (!validStatuses.includes(status)) {
+ *   throw createInvalidEnumError('status', status, validStatuses);
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function createInvalidEnumError(fieldName: string, actualValue: unknown, validValues: readonly string[], displayName?: string): ValidationError;
+/**
+ * Creates a standardized "mutual exclusivity" validation error
+ *
+ * Used when at least one of multiple fields must be provided.
+ *
+ * @param fieldNames Names of the mutually inclusive fields
+ * @param code Optional error code (defaults to 'MUTUAL_REQUIREMENT')
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (!options.tokenName && !options.userAddress) {
+ *   throw createMutualRequirementError(['tokenName', 'userAddress']);
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function createMutualRequirementError(fieldNames: string[], code?: string): ValidationError;
+/**
+ * Creates a standardized "string too long" validation error
+ *
+ * @param fieldName The field name
+ * @param maxLength Maximum allowed length
+ * @param actualLength The actual length received
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (description.length > 255) {
+ *   throw createStringTooLongError('description', 255, description.length);
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function createStringTooLongError(fieldName: string, maxLength: number, actualLength?: number, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "empty string" validation error
+ *
+ * @param fieldName The field name
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (code.trim().length === 0) {
+ *   throw createEmptyStringError('code');
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function createEmptyStringError(fieldName: string, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "invalid array" validation error
+ *
+ * @param fieldName The field name
+ * @param expectedElementType Expected element type description (e.g., 'strings', 'numbers')
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (!Array.isArray(tokens) || !tokens.every((t) => typeof t === 'string')) {
+ *   throw createInvalidArrayError('tokens', 'strings');
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function createInvalidArrayError(fieldName: string, expectedElementType?: string, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "empty array" validation error
+ *
+ * @param fieldName The field name
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (tokens.length === 0) {
+ *   throw createEmptyArrayError('tokens');
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function createEmptyArrayError(fieldName: string, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "invalid date" validation error
+ *
+ * @param fieldName The field name
+ * @param format Expected date format description
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (isNaN(new Date(expiresAt).getTime())) {
+ *   throw createInvalidDateError('expiresAt', 'ISO 8601 format');
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function createInvalidDateError(fieldName: string, format?: string, displayName?: string): ValidationError;
+/**
+ * Creates a standardized "date in past" validation error
+ *
+ * Used for expiration dates, deadlines, or future-date requirements.
+ *
+ * @param fieldName The field name
+ * @param displayName Optional human-readable field name
+ * @returns ValidationError with standardized message
+ *
+ * @example
+ * ```typescript
+ * if (expiryDate <= new Date()) {
+ *   throw createDateInPastError('expiresAt');
+ * }
+ * ```
+ *
+ * @since 6.14.0
+ */
+export declare function createDateInPastError(fieldName: string, displayName?: string): ValidationError;
+//# sourceMappingURL=error-factories.d.ts.map

package/dist/utils/error-factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-factories.d.ts","sourceRoot":"","sources":["../../src/utils/error-factories.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,gBAAgB,EAAC,eAAe,EAAE,MAAM,UAAU,CAAC;AAC9F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,UAAU,GACnB,eAAe,CAOjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAOjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAOjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,EACnB,aAAa,CAAC,EAAE,KAAK,GACpB,YAAY,CAEd;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,GACb,kBAAkB,CAEpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,MAAM,EACtB,IAAI,CAAC,EAAE,MAAM,GACZ,gBAAgB,CAElB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,GAClB,YAAY,CAgBd;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAC7B,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAQjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAC7B,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAQjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAC7B,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAQjB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,WAAW,CAAC,EAAE,OAAO,EACrB,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAYjB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAC7B,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAQjB;AAMD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,MAAM,GAClB,eAAe,CAWjB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,MAAM,GACX,eAAe,CAOjB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,MAAM,GAAG,MAAM,GAC1B,eAAe,CAMjB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,IAAI,GAAE,MAA2B,GAChC,eAAe,CAMjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,eAAe,CAMjB;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,OAAO,EACpB,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CASjB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAAE,EACpB,IAAI,CAAC,EAAE,MAAM,GACZ,eAAe,CAoBjB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAQjB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAOjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,mBAAmB,CAAC,EAAE,MAAM,EAC5B,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAQjB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAOjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,MAAuB,EAC/B,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAOjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,GACnB,eAAe,CAOjB"}