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

package/dist/utils/data-transform-patterns.d.ts

@@ -0,0 +1,393 @@
+/**
+ * Data Transformation Utility Patterns
+ *
+ * Consolidates reusable data transformation patterns used across the SDK
+ * for API response normalization, DTO conversion, and array manipulation.
+ *
+ * Patterns consolidated:
+ * - transformRawApiTokenToDomainModel: Convert raw API token to domain model (4+ occurrences)
+ * - extractFieldWithFallbackPath: Extract value using multiple field path candidates (11+ occurrences)
+ * - normalizeDataWithMapping: Transform array with field renaming and transformation (4+ occurrences)
+ * - deduplicateByKey: Remove duplicates from array based on key function (6+ occurrences)
+ *
+ * @category Utilities
+ * @since 5.17.0
+ */
+/**
+ * Token domain model representing normalized token structure
+ *
+ * @since 5.17.0
+ */
+export interface DomainToken {
+    name: string;
+    symbol: string;
+    decimals: number;
+    address?: string;
+    verified?: boolean;
+}
+/**
+ * Transform raw API token response to SDK domain model
+ *
+ * Converts raw token data from various API sources (DEX, GalaChain, etc.)
+ * to a normalized domain model with sensible defaults.
+ *
+ * Consolidates 4+ occurrences in:
+ * - GSwapAssetService.transformRawTokenToDexToken()
+ * - GSwapAssetService.transformRawTokenToUserAsset()
+ * - GSwapService token transformation logic
+ *
+ * Handles:
+ * - Missing fields with defaults (decimals: 8, verified: false, etc.)
+ * - Field name variations (tokenName vs name, tokenSymbol vs symbol)
+ * - Symbol fallback chain: symbol → tokenSymbol → collection → ''
+ * - Validates required fields (name, symbol) exist and are non-empty
+ *
+ * @param rawToken - Raw token object from API response (may have missing fields)
+ * @returns Normalized token domain model with required fields and defaults applied
+ * @throws Error if required fields (name, symbol) are missing or empty
+ *
+ * @example Basic transformation
+ * ```typescript
+ * const rawToken = {
+ *   tokenName: 'Anime',
+ *   tokenSymbol: 'ANI',
+ *   decimals: 18,
+ *   verified: true,
+ *   address: '0xabc123...'
+ * };
+ *
+ * const domain = transformRawApiTokenToDomainModel(rawToken);
+ * // Returns: {
+ * //   name: 'Anime',
+ * //   symbol: 'ANI',
+ * //   decimals: 18,
+ * //   verified: true,
+ * //   address: '0xabc123...'
+ * // }
+ * ```
+ *
+ * @example With missing optional fields
+ * ```typescript
+ * const minimalToken = {
+ *   name: 'GALA',
+ *   symbol: 'GALA'
+ * };
+ *
+ * const domain = transformRawApiTokenToDomainModel(minimalToken);
+ * // Returns: {
+ * //   name: 'GALA',
+ * //   symbol: 'GALA',
+ * //   decimals: 8,  // default
+ * //   verified: false  // default
+ * // }
+ * ```
+ *
+ * @example With field name variations
+ * ```typescript
+ * const apiResponse = {
+ *   tokenName: 'Demon K-Pop',
+ *   tokenSymbol: 'DEMONKPOP',
+ *   decimals: 18
+ * };
+ *
+ * const domain = transformRawApiTokenToDomainModel(apiResponse);
+ * // Normalizes both name and symbol field names automatically
+ * ```
+ *
+ * @example Error on missing required field
+ * ```typescript
+ * transformRawApiTokenToDomainModel({ name: 'Test' });
+ * // Throws: Error('Token symbol is required')
+ * ```
+ */
+export declare function transformRawApiTokenToDomainModel(rawToken: unknown): DomainToken;
+/**
+ * Extract field value from object using fallback path chain
+ *
+ * Tries multiple field paths in order (both flat and nested) and returns
+ * the first one that has a non-empty value. Supports nested paths like
+ * "response.data.error" for deep object traversal.
+ *
+ * Consolidates 11+ occurrences in:
+ * - LiquidityEventExtractor field extraction
+ * - SwapEventExtractor field extraction
+ * - Response handler fallback logic
+ *
+ * Note: extractFieldWithCandidates() already exists in object-extractors.ts
+ * for simple field name candidates. This function extends that pattern to
+ * support nested paths (dot-notation) for deeper object traversal.
+ *
+ * @template T - Type of the default value (inferred from defaultValue parameter)
+ * @param obj - Object to extract field from (can be any type, will check for object)
+ * @param fieldPaths - Array of field paths to try in order (e.g., ['id', 'error.code', 'response.data.message'])
+ * @param defaultValue - Value to return if no field path has a value (default: null)
+ * @returns First non-empty value found, or defaultValue if none found
+ *
+ * @example Basic field extraction
+ * ```typescript
+ * const obj = { id: '123', transactionId: null };
+ *
+ * const id = extractFieldWithFallbackPath(obj, ['id', 'transactionId']);
+ * // Returns: '123'
+ * ```
+ *
+ * @example With nested paths
+ * ```typescript
+ * const response = {
+ *   data: {
+ *     error: {
+ *       code: 'VALIDATION_ERROR'
+ *     }
+ *   }
+ * };
+ *
+ * const errorCode = extractFieldWithFallbackPath(
+ *   response,
+ *   ['error.code', 'code', 'message'],
+ *   'UNKNOWN'
+ * );
+ * // Returns: 'VALIDATION_ERROR'
+ * ```
+ *
+ * @example With default value
+ * ```typescript
+ * const obj = { name: null };
+ *
+ * const name = extractFieldWithFallbackPath(
+ *   obj,
+ *   ['name', 'displayName', 'title'],
+ *   'Unknown'
+ * );
+ * // Returns: 'Unknown' (all paths empty, uses default)
+ * ```
+ *
+ * @example With type-safe default
+ * ```typescript
+ * const obj = { count: null };
+ *
+ * const count: number = extractFieldWithFallbackPath(
+ *   obj,
+ *   ['count', 'total', 'size'],
+ *   0
+ * );
+ * // Returns: 0 (type inferred from defaultValue)
+ * ```
+ *
+ * @example Error case - non-object input
+ * ```typescript
+ * const value = extractFieldWithFallbackPath(null, ['field'], null);
+ * // Returns: null (input is null, not an object)
+ * ```
+ */
+export declare function extractFieldWithFallbackPath<T = unknown>(obj: unknown, fieldPaths: string[], defaultValue?: T): T | null;
+/**
+ * Transform array of objects with field mapping and transformation functions
+ *
+ * Maps field names from source objects to target field names, with optional
+ * transformation functions applied per field. Replaces manual map/reduce patterns.
+ *
+ * Consolidates 4+ occurrences in:
+ * - DTO → Domain conversions
+ * - API response field renaming
+ * - Array normalization workflows
+ *
+ * @template T - Type of items in source array
+ * @template R - Type of items in result array
+ * @param items - Array of source objects to transform
+ * @param mapping - Record mapping target field names to transformation functions.
+ *                  Each function receives the source object and returns the value
+ *                  for that field. Undefined values are omitted from result.
+ * @returns Array of transformed objects with mapped field names
+ *
+ * @example Basic field renaming
+ * ```typescript
+ * interface ApiUser {
+ *   user_name: string;
+ *   user_email: string;
+ *   created_at: string;
+ * }
+ *
+ * const apiUsers: ApiUser[] = [
+ *   { user_name: 'alice', user_email: 'alice@example.com', created_at: '2025-01-01' }
+ * ];
+ *
+ * const domainUsers = normalizeDataWithMapping(apiUsers, {
+ *   name: (item) => item.user_name,
+ *   email: (item) => item.user_email,
+ *   createdAt: (item) => item.created_at
+ * });
+ *
+ * // Returns: [{ name: 'alice', email: 'alice@example.com', createdAt: '2025-01-01' }]
+ * ```
+ *
+ * @example With type transformations
+ * ```typescript
+ * interface RawPrice {
+ *   symbol: string;
+ *   price: string;
+ *   timestamp: string;
+ * }
+ *
+ * interface PriceData {
+ *   symbol: string;
+ *   price: number;
+ *   date: Date;
+ * }
+ *
+ * const rawPrices: RawPrice[] = [
+ *   { symbol: 'BTC', price: '42500.50', timestamp: '2025-01-11T10:00:00Z' }
+ * ];
+ *
+ * const prices = normalizeDataWithMapping<RawPrice, PriceData>(rawPrices, {
+ *   symbol: (item) => item.symbol,
+ *   price: (item) => parseFloat(item.price), // Transform string to number
+ *   date: (item) => new Date(item.timestamp) // Transform string to Date
+ * });
+ *
+ * // Returns: [{ symbol: 'BTC', price: 42500.5, date: Date }]
+ * ```
+ *
+ * @example Conditional field inclusion
+ * ```typescript
+ * interface RawEvent {
+ *   id: string;
+ *   name: string;
+ *   description?: string;
+ *   verified?: boolean;
+ * }
+ *
+ * interface Event {
+ *   id: string;
+ *   title: string;
+ *   notes?: string;
+ *   trusted?: boolean;
+ * }
+ *
+ * const events = normalizeDataWithMapping<RawEvent, Event>(rawData, {
+ *   id: (item) => item.id,
+ *   title: (item) => item.name,
+ *   notes: (item) => item.description, // undefined if not present
+ *   trusted: (item) => item.verified // undefined if not present
+ * });
+ *
+ * // Undefined fields are omitted from result objects
+ * ```
+ *
+ * @example Merging multiple source fields
+ * ```typescript
+ * interface TokenData {
+ *   first_name: string;
+ *   last_name: string;
+ *   amount: string;
+ * }
+ *
+ * interface TokenInfo {
+ *   fullName: string;
+ *   quantity: number;
+ * }
+ *
+ * const tokens = normalizeDataWithMapping<TokenData, TokenInfo>(data, {
+ *   fullName: (item) => `${item.first_name} ${item.last_name}`,
+ *   quantity: (item) => parseFloat(item.amount)
+ * });
+ * ```
+ */
+export declare function normalizeDataWithMapping<T extends Record<string, unknown>, R extends Record<string, unknown>>(items: T[], mapping: Record<keyof R, (item: T) => unknown>): Partial<R>[];
+/**
+ * Remove duplicate items from array based on key function
+ *
+ * Returns a new array with duplicate items removed, maintaining original order.
+ * Determines uniqueness by comparing the result of keyFn for each item.
+ *
+ * Consolidates 6+ occurrences of deduplication patterns in:
+ * - Event deduplication (by transaction ID, pool ID, etc.)
+ * - Position result deduplication
+ * - Pool discovery deduplication
+ *
+ * Related to groupByKey() in array-helpers.ts but returns deduplicated array
+ * instead of grouped Map structure.
+ *
+ * @template T - Type of items in array
+ * @param items - Array of items to deduplicate (may contain duplicates)
+ * @param keyFn - Function that computes uniqueness key for each item
+ * @param keepFirst - If true, keeps first occurrence; if false, keeps last (default: true)
+ * @returns New array with duplicates removed, original order maintained
+ *
+ * @example Basic deduplication
+ * ```typescript
+ * interface Position {
+ *   id: string;
+ *   amount: string;
+ * }
+ *
+ * const positions: Position[] = [
+ *   { id: '1', amount: '100' },
+ *   { id: '2', amount: '200' },
+ *   { id: '1', amount: '150' }, // Duplicate ID
+ * ];
+ *
+ * const unique = deduplicateByKey(positions, (pos) => pos.id);
+ * // Returns: [{ id: '1', amount: '100' }, { id: '2', amount: '200' }]
+ * // (first occurrence of id '1' is kept)
+ * ```
+ *
+ * @example String key deduplication
+ * ```typescript
+ * interface Event {
+ *   txId: string;
+ *   type: string;
+ *   timestamp: number;
+ * }
+ *
+ * const events: Event[] = [
+ *   { txId: 'abc', type: 'swap', timestamp: 1000 },
+ *   { txId: 'def', type: 'liquidity', timestamp: 2000 },
+ *   { txId: 'abc', type: 'swap', timestamp: 1500 }, // Duplicate txId
+ * ];
+ *
+ * const deduplicated = deduplicateByKey(events, (e) => e.txId);
+ * // Returns: [{ txId: 'abc', type: 'swap', timestamp: 1000 }, ...]
+ * ```
+ *
+ * @example Keep last occurrence
+ * ```typescript
+ * const items = [
+ *   { id: 'a', value: 1 },
+ *   { id: 'b', value: 2 },
+ *   { id: 'a', value: 3 }, // Same id, newer value
+ * ];
+ *
+ * const lastOccurrence = deduplicateByKey(
+ *   items,
+ *   (item) => item.id,
+ *   false // Keep last occurrence
+ * );
+ * // Returns: [{ id: 'b', value: 2 }, { id: 'a', value: 3 }]
+ * ```
+ *
+ * @example Composite key deduplication
+ * ```typescript
+ * interface Pair {
+ *   token0: string;
+ *   token1: string;
+ *   fee: number;
+ * }
+ *
+ * const pairs: Pair[] = [
+ *   { token0: 'GALA', token1: 'GUSDC', fee: 3000 },
+ *   { token0: 'GALA', token1: 'GWETH', fee: 3000 },
+ *   { token0: 'GALA', token1: 'GUSDC', fee: 3000 }, // Duplicate
+ * ];
+ *
+ * const uniquePairs = deduplicateByKey(
+ *   pairs,
+ *   (pair) => `${pair.token0}/${pair.token1}/${pair.fee}`
+ * );
+ * // Returns: [
+ * //   { token0: 'GALA', token1: 'GUSDC', fee: 3000 },
+ * //   { token0: 'GALA', token1: 'GWETH', fee: 3000 }
+ * // ]
+ * ```
+ */
+export declare function deduplicateByKey<T>(items: T[], keyFn: (item: T) => unknown, keepFirst?: boolean): T[];
+//# sourceMappingURL=data-transform-patterns.d.ts.map

package/dist/utils/data-transform-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-transform-patterns.d.ts","sourceRoot":"","sources":["../../src/utils/data-transform-patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,OAAO,GAAG,WAAW,CAmDhF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,GAAG,OAAO,EACtD,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,MAAM,EAAE,EACpB,YAAY,GAAE,CAAwB,GACrC,CAAC,GAAG,IAAI,CAmCV;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+GG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3G,KAAK,EAAE,CAAC,EAAE,EACV,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,GAC7C,OAAO,CAAC,CAAC,CAAC,EAAE,CAcd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC3B,SAAS,GAAE,OAAc,GACxB,CAAC,EAAE,CA6BL"}

package/dist/utils/date-utils.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Date parsing utilities for safe type conversion
+ *
+ * These utilities provide safe date parsing with fallback handling
+ * to prevent runtime errors from malformed date strings.
+ */
+/**
+ * Safely parse a date string to a Date object with fallback
+ *
+ * @param dateString - ISO date string from backend
+ * @param fallback - Fallback date if parsing fails (defaults to current date)
+ * @returns Valid Date object
+ */
+export declare function safeParseDate(dateString: string | Date | null | undefined, fallback?: Date): Date;
+/**
+ * Safely parse multiple date strings to Date objects
+ *
+ * @param dateStrings - Array of ISO date strings
+ * @param fallback - Fallback date for any parsing failures
+ * @returns Array of valid Date objects
+ */
+export declare function safeParseDates(dateStrings: (string | Date | null | undefined)[], fallback?: Date): Date[];
+/**
+ * Validate if a string is a valid date format before parsing
+ *
+ * @param dateString - String to validate
+ * @returns True if the string represents a valid date
+ */
+export declare function isValidDateString(dateString: string | Date | null | undefined): boolean;
+/**
+ * Parse date with validation and detailed error context
+ *
+ * @param dateString - Date string to parse
+ * @param context - Context information for debugging (e.g., 'user.createdAt')
+ * @param fallback - Fallback date if parsing fails
+ * @returns Valid Date object with debug information
+ */
+export declare function safeParseWithContext(dateString: string | Date | null | undefined, context: string, fallback?: Date): Date;
+/**
+ * Calculate elapsed time in milliseconds since a start timestamp
+ *
+ * Replaces the common pattern: `Date.now() - startTimeMs`
+ *
+ * @param startTimeMs - Start timestamp in milliseconds (from Date.now())
+ * @returns Elapsed milliseconds between start and now
+ *
+ * @example
+ * ```typescript
+ * const startTime = Date.now();
+ * // ... perform operation ...
+ * const elapsed = calculateElapsedTime(startTime);
+ * console.log(`Operation took ${elapsed}ms`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Measuring performance of async operations
+ * const start = Date.now();
+ * const result = await fetchData();
+ * const duration = calculateElapsedTime(start);
+ * metrics.record('fetch_duration_ms', duration);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Timeout checking
+ * const timeout = 5000;
+ * const start = Date.now();
+ * while (!completed) {
+ *   if (calculateElapsedTime(start) > timeout) {
+ *     throw new TimeoutError('Operation exceeded 5 second limit');
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Rate limiting with time windows
+ * const requestTime = Date.now();
+ * const timeSinceLastRequest = calculateElapsedTime(lastRequestTime);
+ * if (timeSinceLastRequest < minIntervalMs) {
+ *   throw new RateLimitError(`Must wait ${minIntervalMs - timeSinceLastRequest}ms`);
+ * }
+ * ```
+ *
+ * @remarks
+ * - Always use the same timestamp source (Date.now()) for accurate calculations
+ * - Results are in milliseconds, divide by 1000 for seconds
+ * - Useful for performance monitoring, timeout checking, and rate limiting
+ * - Simpler and more readable than inline Date.now() subtraction
+ */
+export declare function calculateElapsedTime(startTimeMs: number): number;
+/**
+ * Check if a timestamp has expired
+ *
+ * Replaces the common pattern: `Date.now() > expiresAt`
+ * Used for cache expiration, JWT validation, token expiry checks.
+ *
+ * @param expiresAt - Expiration timestamp in milliseconds
+ * @returns True if the current time is past the expiration time
+ *
+ * @example
+ * ```typescript
+ * if (isExpired(cacheEntry.expiresAt)) {
+ *   cache.delete(key);
+ * }
+ * ```
+ */
+export declare function isExpired(expiresAt: number): boolean;
+/**
+ * Set an expiry time by adding TTL (time-to-live) to current time
+ *
+ * Replaces the common pattern: `Date.now() + ttl`
+ * Used for cache timestamps, token expiry, session validity.
+ *
+ * @param ttl - Time-to-live in milliseconds
+ * @returns Expiration timestamp in milliseconds
+ *
+ * @example
+ * ```typescript
+ * const expiresAt = setExpiryTime(3600000); // 1 hour from now
+ * ```
+ */
+export declare function setExpiryTime(ttl: number): number;
+/**
+ * Convert timestamp to ISO 8601 string
+ *
+ * Replaces the common pattern: `new Date(ts).toISOString()`
+ * Used for API responses, logging, date serialization.
+ *
+ * @param timestamp - Timestamp in milliseconds (from Date.now())
+ * @returns ISO 8601 formatted string
+ *
+ * @example
+ * ```typescript
+ * const isoString = timestampToISOString(Date.now());
+ * // "2025-01-09T15:30:45.123Z"
+ * ```
+ */
+export declare function timestampToISOString(timestamp: number): string;
+/**
+ * Time constant helper: convert minutes to milliseconds
+ *
+ * Replaces the common pattern: `n * 60 * 1000`
+ * Used for timeout values, cache TTLs, polling intervals.
+ *
+ * @param n - Number of minutes
+ * @returns Milliseconds equivalent
+ *
+ * @example
+ * ```typescript
+ * const timeout = minutes(5); // 300000ms
+ * const cacheTtl = minutes(30); // 1800000ms
+ * ```
+ */
+export declare function minutes(n: number): number;
+/**
+ * Time constant helper: convert hours to milliseconds
+ *
+ * Replaces the common pattern: `n * 60 * 60 * 1000`
+ * Used for long-lived cache entries, session durations.
+ *
+ * @param n - Number of hours
+ * @returns Milliseconds equivalent
+ *
+ * @example
+ * ```typescript
+ * const sessionTtl = hours(24); // 86400000ms (1 day)
+ * ```
+ */
+export declare function hours(n: number): number;
+/**
+ * Time constant helper: convert days to milliseconds
+ *
+ * Replaces the common pattern: `n * 24 * 60 * 60 * 1000`
+ * Used for date calculations, expiry windows.
+ *
+ * @param n - Number of days
+ * @returns Milliseconds equivalent
+ *
+ * @example
+ * ```typescript
+ * const tokenExpiry = days(365); // 1 year
+ * const archiveThreshold = days(30);
+ * ```
+ */
+export declare function days(n: number): number;
+/**
+ * Normalize various date formats to milliseconds timestamp
+ *
+ * Handles Date objects, numeric timestamps, and ISO string dates.
+ * Consolidates the common pattern: `value instanceof Date ? value.getTime() : value`
+ *
+ * @param value - Date object, timestamp in milliseconds, or ISO date string
+ * @returns Timestamp in milliseconds (or current time if invalid)
+ *
+ * @example
+ * ```typescript
+ * const ts1 = dateToMilliseconds(new Date());        // Date object
+ * const ts2 = dateToMilliseconds(1609459200000);      // Already milliseconds
+ * const ts3 = dateToMilliseconds('2021-01-01T00:00:00Z'); // ISO string
+ * ```
+ */
+export declare function dateToMilliseconds(value: Date | number | string | null | undefined): number;
+//# sourceMappingURL=date-utils.d.ts.map

package/dist/utils/date-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-utils.d.ts","sourceRoot":"","sources":["../../src/utils/date-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,EAC5C,QAAQ,CAAC,EAAE,IAAI,GACd,IAAI,CA2BN;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,CAAC,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACjD,QAAQ,CAAC,EAAE,IAAI,GACd,IAAI,EAAE,CAER;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,GAC3C,OAAO,CAiBT;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,EAC5C,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,IAAI,GACd,IAAI,CAiCN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEvC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/C,MAAM,CAmBR"}