@gala-chain/launchpad-sdk 6.0.0 → 7.0.0-beta.2

package/dist/src/utils/SwapEventExtractor.d.ts

@@ -1,152 +0,0 @@
-/**
- * Swap Event Extractor
- *
- * Parses WebSocket event payloads to extract swap transaction data.
- * Handles recursive payload traversal and multiple swap event formats.
- *
- * Follows the same pattern as pool discovery (newPoolsWatch.js) but adapted
- * for swap events instead of pool creation events.
- *
- * @packageDocumentation
- */
-import type { SwapEventData } from '../types/swap-monitor.dto';
-import { Logger } from './Logger';
-/**
- * Extracts swap event data from WebSocket payloads
- *
- * Recursively walks through event payloads to find swap transaction data
- * in various possible locations (direct fields, nested objects, etc).
- *
- * @internal
- */
-export declare class SwapEventExtractor {
-    private readonly logger;
-    constructor(logger?: Logger);
-    /**
-     * Recursively walk through a payload to find and extract swap events
-     *
-     * Follows the pattern from newPoolsWatch.js::walkPayload but adapted
-     * for swap events. Returns all newly discovered swaps not in seenTransactions.
-     *
-     * Includes depth limiting to prevent DoS attacks from deeply nested payloads.
-     * Maximum nesting depth is 50 levels.
-     *
-     * @param payload - Event payload to search
-     * @param seenTransactions - Set-like object of transaction IDs already processed
-     * @returns Array of extracted swap events
-     */
-    walkPayloadForSwaps(payload: unknown, seenTransactions: {
-        has(id: string): boolean;
-        add(id: string): unknown;
-    }): SwapEventData[];
-    /**
-     * Try to extract a swap event from an object
-     *
-     * Checks for various swap event structures from the backend:
-     * - functionName === 'Swap' or 'ExecuteSwap'
-     * - Direct swap fields (fromToken, toToken, amount0, amount1, etc)
-     * - Nested swap data in payload.swap or payload.swapData
-     * - Backend WebSocket format: { Data: {...swap fields}, transactionId: "..." }
-     *
-     * @param obj - Object to check
-     * @returns Extracted SwapEventData or null if not a swap event
-     */
-    private extractSwapFromObject;
-    /**
-     * Extract transaction ID from swap event object
-     *
-     * Tries multiple common field names for transaction IDs.
-     *
-     * @param obj - Object to search
-     * @returns Transaction ID or null
-     */
-    private extractTransactionId;
-    /**
-     * Extract token from object, trying multiple field names
-     *
-     * @param obj - Object to search
-     * @param fieldNames - Field names to try in order
-     * @returns Token string or null
-     */
-    private extractToken;
-    /**
-     * Extract amount from object, trying multiple field names
-     *
-     * @param obj - Object to search
-     * @param fieldNames - Field names to try in order
-     * @returns Amount string or null
-     */
-    private extractAmount;
-    /**
-     * Extract fee tier from object
-     *
-     * Tries multiple field names and normalizes the value to basis points.
-     *
-     * @param obj - Object to search
-     * @returns Fee tier in basis points (500, 3000, 10000) or null
-     */
-    private extractFeeTier;
-    /**
-     * Normalize fee value to basis points
-     *
-     * Accepts multiple formats:
-     * - Basis points: 500, 3000, 10000
-     * - Decimal: 0.05, 0.3, 1
-     * - Percentage: "0.05%", "0.3%", "1%"
-     *
-     * @param value - Fee value in any format
-     * @returns Normalized fee in basis points or null
-     */
-    private normalizeFee;
-    /**
-     * Extract timestamp from object
-     *
-     * @param obj - Object to search
-     * @returns Timestamp in milliseconds or current time
-     */
-    private extractTimestamp;
-    /**
-     * Extract user/wallet address from object
-     *
-     * @param obj - Object to search
-     * @returns User address or undefined
-     */
-    private extractUser;
-    /**
-     * Determine swap direction (zeroForOne or oneForZero)
-     *
-     * @param obj - Object to check
-     * @param token0 - First token
-     * @param token1 - Second token
-     * @returns Swap direction
-     */
-    private determineDirection;
-    /**
-     * Determine if swap is exact input or exact output
-     *
-     * Exact input: input amount is fixed, output amount is variable
-     * Exact output: output amount is fixed, input amount is variable
-     *
-     * For zeroForOne direction: exact input if amountIn is specified in event
-     * For oneForZero direction: exact input if amountIn is specified in event
-     *
-     * Defaults to exact input if unable to determine from event structure.
-     *
-     * @param obj - Swap event object
-     * @param direction - Swap direction ('zeroForOne' or 'oneForZero')
-     * @returns true for exact input, false for exact output
-     */
-    private determineExactInput;
-    /**
-     * Build pool key from tokens and fee
-     *
-     * Pool key format: token0|token1|feeTier
-     *
-     * @param token0 - First token
-     * @param token1 - Second token
-     * @param feeTier - Fee tier in basis points
-     * @returns Pool key string
-     */
-    private buildPoolKey;
-}
-//# sourceMappingURL=SwapEventExtractor.d.ts.map

package/dist/src/utils/SwapEventExtractor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SwapEventExtractor.d.ts","sourceRoot":"","sources":["../../../src/utils/SwapEventExtractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAKlC;;;;;;;GAOG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,MAAM,CAAC,EAAE,MAAM;IAI3B;;;;;;;;;;;;OAYG;IACH,mBAAmB,CACjB,OAAO,EAAE,OAAO,EAChB,gBAAgB,EAAE;QAAE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,GACvE,aAAa,EAAE;IA2ClB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,qBAAqB;IAgE7B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAUpB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAerB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAqBtB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,YAAY;IAmCpB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAanB;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;IAwC1B;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,mBAAmB;IAqC3B;;;;;;;;;OASG;IACH,OAAO,CAAC,YAAY;CAGrB"}

package/dist/src/utils/adapters.d.ts

@@ -1,111 +0,0 @@
-import type { PaginationParams } from '../types/common';
-/**
- * Type adapters to handle backend quirks and inconsistencies
- *
- * The backend has some type inconsistencies (strings vs numbers) that we need
- * to handle transparently while providing clean interfaces to SDK users.
- */
-/**
- * Converts clean pagination parameters to backend's expected string format
- *
- * Backend expects page and pageSize as strings, but SDK users should use numbers
- *
- * @param pagination Clean pagination parameters
- * @returns Backend-compatible query parameters
- */
-export declare function adaptPagination(pagination: PaginationParams): Record<string, string>;
-/**
- * Converts clean query parameters to backend's expected format
- *
- * Handles various type conversions the backend expects:
- * - Numbers to strings
- * - Booleans to strings
- * - Arrays to comma-separated strings
- * - Removes undefined/null values
- *
- * @param params Clean query parameters
- * @returns Backend-compatible query parameters
- */
-export declare function adaptQueryParams(params: unknown): Record<string, string>;
-/**
- * Adapts request data for backend consumption
- *
- * Handles common transformations:
- * - Converts camelCase to snake_case for all fields
- * - Ensures address formats are correct
- * - Handles date/timestamp conversions
- * - Recursively processes nested objects and arrays
- *
- * @param data Request data
- * @param visited Set to track circular references
- * @returns Backend-compatible request data
- */
-export declare function adaptRequestData(data: unknown, visited?: WeakSet<object>): unknown;
-/**
- * Adapts backend response data to clean SDK format
- *
- * Handles common transformations:
- * - Converts snake_case to camelCase for all fields
- * - Parses string numbers back to numbers where appropriate
- * - Standardizes date formats
- * - Recursively processes nested objects and arrays
- *
- * @param data Backend response data
- * @param visited Set to track circular references
- * @returns Clean SDK-compatible data
- */
-export declare function adaptResponseData<T = any>(data: unknown, visited?: WeakSet<object>): T;
-/**
- * Known backend type quirks and their handling
- *
- * This documents the specific inconsistencies we've discovered:
- */
-export declare const BACKEND_TYPE_QUIRKS: {
-    /**
-     * Pagination parameters must be sent as strings
-     * Clean interface: { page: number, limit: number }
-     * Backend expects: { page: string, limit: string }
-     */
-    readonly PAGINATION_AS_STRINGS: true;
-    /**
-     * Some numeric fields are returned as strings
-     * We convert them back to numbers for clean interfaces
-     */
-    readonly NUMERIC_FIELDS_AS_STRINGS: "numeric-strings";
-    /**
-     * Date fields use inconsistent naming
-     * created_at vs createdAt, updated_at vs updatedAt
-     */
-    readonly INCONSISTENT_DATE_NAMING: "date-naming";
-    /**
-     * Array filters may need to be comma-separated strings
-     * Clean interface: string[]
-     * Backend expects: string (comma-separated)
-     */
-    readonly ARRAYS_AS_CSV: "arrays-csv";
-    /**
-     * Backend expects snake_case field names
-     * SDK uses camelCase for clean interfaces
-     */
-    readonly SNAKE_CASE_FIELDS: true;
-    /**
-     * Type parameter handling varies by endpoint
-     */
-    readonly TYPE_PARAMETER_HANDLING: {
-        readonly TOKEN_LIST_ENDPOINT: {
-            readonly includesType: true;
-        };
-        readonly TOKEN_HELD_ENDPOINT: {
-            readonly includesType: false;
-        };
-    };
-};
-/**
- * Validates that an adapted value matches expected format
- *
- * @param adapted The adapted value
- * @param formatType The expected format ('request' for snake_case, 'response' for camelCase)
- * @throws Error if format is mixed or incorrect
- */
-export declare function validateAdaptedFormat(adapted: unknown, formatType: 'request' | 'response'): void;
-//# sourceMappingURL=adapters.d.ts.map

package/dist/src/utils/adapters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../../../src/utils/adapters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGxD;;;;;GAKG;AAEH;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,gBAAgB,GAC3B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,OAAO,GACd,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgCxB;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EACb,OAAO,kBAAgB,GACtB,OAAO,CAoDT;AAWD;;;;;;;;;;;;GAYG;AAEH,wBAAgB,iBAAiB,CAAC,CAAC,GAAG,GAAG,EACvC,IAAI,EAAE,OAAO,EACb,OAAO,kBAAgB,GACtB,CAAC,CAqEH;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;IAC9B;;;;OAIG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;;OAGG;;IAGH;;OAEG;;;;;;;;;CASK,CAAC;AAEX;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,SAAS,GAAG,UAAU,GACjC,IAAI,CAoCN"}

package/dist/src/utils/address-formatter.d.ts

@@ -1,318 +0,0 @@
-/**
- * AddressFormatter - Consolidated address format conversion utilities
- *
- * Consolidates address formatting logic scattered across multiple files:
- * - validation.ts: `toBackendAddressFormat()`, `fromBackendAddressFormat()`, `normalizeAddressInput()`
- * - validation-helpers.ts: `formatAddressForBackend()`, `isValidAddress()`, `assertValidWalletAddress()`
- * - Multiple services: Duplicate address parsing and normalization
- *
- * ## Problem Solved
- *
- * Address formatting was duplicated with inconsistent patterns:
- * - Ethereum format: "0x1234..."
- * - Backend format: "eth|1234..."
- * - Client format: "client|abc123"
- * - Different validation patterns in different files
- * - Inconsistent error messages
- *
- * This utility provides a cohesive, well-documented interface for all address operations.
- *
- * @category Utilities
- * @since 6.5.0
- */
-import { stripHexPrefix as bridgeStripHexPrefix } from '../bridge/utils/address-formatter';
-import type { AddressFormat } from '../types/common';
-/**
- * Address format types
- */
-export type AddressFormatType = 'ethereum' | 'backend' | 'client';
-/**
- * AddressFormatter - Unified address format operations
- *
- * Provides consistent, well-documented address formatting and validation
- * across all services that work with wallet addresses.
- *
- * ## Supported Formats
- *
- * - **Ethereum**: `0x1234567890abcdef...` (40 hex chars with 0x prefix)
- * - **Backend**: `eth|1234567890abcdef...` (40 hex chars without 0x)
- * - **Client**: `client|identifier` (arbitrary client identifiers)
- *
- * ## Usage Examples
- *
- * ### Format conversion
- * ```typescript
- * const formatter = new AddressFormatter();
- *
- * // Ethereum to backend
- * formatter.toBackendFormat('0x1234...abc');
- * // Returns: 'eth|1234...abc'
- *
- * // Backend to Ethereum
- * formatter.toEthereumFormat('eth|1234...abc');
- * // Returns: '0x1234...abc'
- *
- * // Auto-detect and convert
- * const format = formatter.normalizeInput('0x1234...abc');
- * // Returns: 'eth|1234...abc' (backend format)
- * ```
- *
- * ### Validation
- * ```typescript
- * const formatter = new AddressFormatter();
- *
- * // Check validity (no throw)
- * if (formatter.isValid('0x1234...abc')) {
- *   // Process address
- * }
- *
- * // Validate with throw
- * formatter.assertValid(address, 'userAddress');
- * // Safe to use
- * ```
- *
- * @since 6.5.0
- */
-export declare class AddressFormatter {
-    /**
-     * Convert Ethereum address to backend format
-     *
-     * Accepts Ethereum format (with or without 0x prefix) and returns backend format.
-     * Always returns EIP-55 checksummed addresses (required by GalaChain validators).
-     *
-     * @param address Ethereum address (0x... or plain 40 hex)
-     * @returns Backend format address (eth|...) with EIP-55 checksummed address
-     * @throws ValidationError if address format is invalid
-     *
-     * @example
-     * ```typescript
-     * const formatter = new AddressFormatter();
-     *
-     * formatter.toBackendFormat('0x1234567890abcdef1234567890abcdef12345678');
-     * // Returns: 'eth|1234567890aBcdEf1234567890abCdef12345678' (checksummed)
-     *
-     * formatter.toBackendFormat('1234567890abcdef1234567890abcdef12345678');
-     * // Returns: 'eth|1234567890aBcdEf1234567890abCdef12345678' (checksummed)
-     * ```
-     */
-    toBackendFormat(address: string): string;
-    /**
-     * Convert backend address format to Ethereum format
-     *
-     * Converts backend format (eth|...) to standard Ethereum format (0x...).
-     * Preserves the original case of the address portion (including EIP-55 checksummed addresses).
-     *
-     * @param address Backend format address (eth|...)
-     * @returns Ethereum format address (0x...)
-     * @throws ValidationError if address format is invalid
-     *
-     * @example
-     * ```typescript
-     * const formatter = new AddressFormatter();
-     *
-     * formatter.toEthereumFormat('eth|1234567890abcdef...abcdef');
-     * // Returns: '0x1234567890abcdef...abcdef'
-     *
-     * formatter.toEthereumFormat('eth|5aAeb6053f3E94C9b9A09f33669435E7Ef1BeAed');
-     * // Returns: '0x5aAeb6053f3E94C9b9A09f33669435E7Ef1BeAed' (preserves checksum case)
-     * ```
-     */
-    toEthereumFormat(address: string): string;
-    /**
-     * Smart address parser - accepts both Ethereum and backend formats
-     *
-     * Automatically detects format and converts to backend format required by SDK.
-     * Handles both "0x..." and "eth|..." formats seamlessly.
-     *
-     * @param address Address in either Ethereum or backend format
-     * @returns Backend format address (eth|...)
-     * @throws ValidationError if address format is invalid
-     *
-     * @example
-     * ```typescript
-     * const formatter = new AddressFormatter();
-     *
-     * // Ethereum format input
-     * formatter.normalizeInput('0x1234...abc');
-     * // Returns: 'eth|1234...abc'
-     *
-     * // Backend format input
-     * formatter.normalizeInput('eth|1234...abc');
-     * // Returns: 'eth|1234...abc' (unchanged)
-     *
-     * // Plain hex (with or without 0x)
-     * formatter.normalizeInput('1234...abc');
-     * // Returns: 'eth|1234...abc'
-     * ```
-     */
-    normalizeInput(address: string | undefined): AddressFormat | undefined;
-    /**
-     * Check if an address is valid (without throwing)
-     *
-     * Returns true if address is in valid Ethereum or backend format.
-     *
-     * @param address Address to check
-     * @returns true if valid, false otherwise
-     *
-     * @example
-     * ```typescript
-     * const formatter = new AddressFormatter();
-     *
-     * if (formatter.isValid('0x1234...abc')) {
-     *   // Process address
-     * }
-     * ```
-     */
-    isValid(address: string | undefined | null): address is string;
-    /**
-     * Validate address format, throwing on invalid
-     *
-     * @param address Address to validate
-     * @param fieldName Field name for error messages (default: 'address')
-     * @throws ValidationError if address is invalid
-     *
-     * @example
-     * ```typescript
-     * const formatter = new AddressFormatter();
-     *
-     * formatter.assertValid(userAddress, 'userAddress');
-     * // Safe to use userAddress
-     * ```
-     */
-    assertValid(address: string | undefined, fieldName?: string): void;
-    /**
-     * Detect the format of an address string
-     *
-     * @param address Address string to check
-     * @returns Format type ('ethereum', 'backend', 'client') or null if invalid
-     *
-     * @example
-     * ```typescript
-     * const formatter = new AddressFormatter();
-     *
-     * formatter.detectFormat('0x1234...abc');     // 'ethereum'
-     * formatter.detectFormat('eth|1234...abc');   // 'backend'
-     * formatter.detectFormat('client|xyz');       // 'client'
-     * formatter.detectFormat('invalid');          // null
-     * ```
-     */
-    detectFormat(address: string | undefined): AddressFormatType | null;
-    /**
-     * Normalize address casing (lowercase for consistency)
-     *
-     * Ethereum addresses can be checksummed, but we normalize to lowercase
-     * for consistency in comparisons and storage.
-     *
-     * @param address Address to normalize
-     * @returns Lowercase address
-     *
-     * @example
-     * ```typescript
-     * const formatter = new AddressFormatter();
-     *
-     * formatter.normalize('0xABCD...DCBA');
-     * // Returns: '0xabcd...dcba'
-     *
-     * formatter.normalize('ETH|ABCD...DCBA');
-     * // Returns: 'eth|abcd...dcba'
-     * ```
-     */
-    normalize(address: string | undefined): string | undefined;
-    /**
-     * Extract hex address from either format
-     *
-     * Returns just the 40-character hex portion without any prefix.
-     *
-     * @param address Ethereum or backend format address
-     * @returns 40-character hex string (lowercase)
-     * @throws ValidationError if address format is invalid
-     *
-     * @example
-     * ```typescript
-     * const formatter = new AddressFormatter();
-     *
-     * formatter.extractHex('0x1234...abc');
-     * // Returns: '1234...abc'
-     *
-     * formatter.extractHex('eth|1234...abc');
-     * // Returns: '1234...abc'
-     * ```
-     */
-    extractHex(address: string): string;
-}
-export declare const stripHexPrefix: typeof bridgeStripHexPrefix;
-/**
- * Convert Ethereum address to backend format (function style)
- *
- * @param address Ethereum address
- * @returns Backend format
- * @throws ValidationError if invalid
- */
-export declare function toBackendAddressFormat(address: string): string;
-/**
- * Convert backend address to Ethereum format (function style)
- *
- * @param address Backend format address
- * @returns Ethereum format
- * @throws ValidationError if invalid
- */
-export declare function fromBackendAddressFormat(address: string): string;
-/**
- * Smart address parser (function style)
- *
- * @param address Address to normalize
- * @returns Backend format or undefined
- */
-export declare function normalizeAddressInput(address: string | undefined): AddressFormat | undefined;
-/**
- * Check if address is valid (function style)
- *
- * @param address Address to check
- * @returns true if valid
- */
-export declare function isValidAddress(address: string | undefined): address is string;
-/**
- * Validate address and throw (function style)
- *
- * @param address Address to validate
- * @param fieldName Field name for errors
- * @throws ValidationError if invalid
- */
-export declare function assertValidWalletAddress(address: string | undefined, fieldName?: string): void;
-/**
- * Convert Ethereum address object (from ethers Wallet) to backend format
- *
- * Provides a convenient one-step conversion from ethers Wallet addresses to backend format.
- * Handles both Wallet objects and plain addresses.
- *
- * @param ethAddress Ethereum address with or without 0x prefix, or ethers Wallet object
- * @returns Backend format address (eth|...)
- * @throws ValidationError if address format is invalid
- *
- * @example
- * ```typescript
- * import { Wallet } from 'ethers';
- * import { toBackendAddressFromEthers } from '@/utils/address-formatter';
- *
- * const wallet = new Wallet(privateKey);
- * const backendAddr = toBackendAddressFromEthers(wallet.address);
- * // Returns: 'eth|1234567890abcdef...abcdef'
- *
- * // Also works with plain addresses
- * const result = toBackendAddressFromEthers('0x1234...abc');
- * // Returns: 'eth|1234...abc'
- * ```
- *
- * @since 6.6.0
- */
-export declare function toBackendAddressFromEthers(ethAddress: string | {
-    address: string;
-}): string;
-/**
- * Detect the format of an address string (function style)
- *
- * @param address Address to check
- * @returns Format type ('ethereum', 'backend', 'client') or null if invalid
- */
-export declare function detectFormat(address: string | undefined): AddressFormatType | null;
-//# sourceMappingURL=address-formatter.d.ts.map

package/dist/src/utils/address-formatter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"address-formatter.d.ts","sourceRoot":"","sources":["../../../src/utils/address-formatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,EAAE,cAAc,IAAI,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAC3F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;AAwBlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IA8CxC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAgCzC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS;IAkCtE;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,IAAI,MAAM;IA4B9D;;;;;;;;;;;;;;OAcG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,GAAE,MAAkB,GAAG,IAAI;IAU7E;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,iBAAiB,GAAG,IAAI;IAwBnE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS;IAQ1D;;;;;;;;;;;;;;;;;;;OAmBG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;CAoBpC;AAQD,eAAO,MAAM,cAAc,6BAAuB,CAAC;AAEnD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAE5F;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,IAAI,MAAM,CAE7E;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,GAAE,MAAkB,GAAG,IAAI,CAEzG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAG3F;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,iBAAiB,GAAG,IAAI,CAElF"}