@builderbot/provider-baileys 1.4.1 → 1.4.2-alpha.10

package/dist/lidCache.d.ts

@@ -0,0 +1,569 @@
+/**
+ * @fileoverview LID (Local Identifier) Cache for WhatsApp Baileys Provider
+ *
+ * This module provides a caching layer for mapping WhatsApp Local Identifiers (LIDs)
+ * to Phone Numbers (PNs). LIDs are privacy-preserving identifiers used by WhatsApp
+ * that don't reveal the user's actual phone number.
+ *
+ * ## Architecture
+ *
+ * The cache uses a hybrid memory+file approach:
+ * - **Hot path**: In-memory lookups via NodeCache (O(1), ~1μs)
+ * - **Persistence**: JSON file for cross-restart durability
+ * - **Strategy**: Write-through to memory, async flush to disk every 30s
+ *
+ * ## Key Features
+ *
+ * - **Zero-config**: Works out of the box with sensible defaults
+ * - **Device suffix normalization**: `123:45@lid` and `123:99@lid` resolve to same entry
+ * - **Phone number normalization**: Accepts `+123 456-7890`, `1234567890@c.us`, etc.
+ * - **Security**: File permissions 0o600, PII masking in logs
+ * - **Resilience**: Corrupted files auto-rebuild, flush failures logged
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * // Default: Hybrid (memory + file)
+ * const cache = new HybridLidCache('my-bot', 86400 * 7) // 7 day TTL
+ * await cache.ready()
+ *
+ * await cache.set('123456789:45@lid', '+34 691 015 468')
+ * const pn = await cache.get('123456789:99@lid') // Returns '34691015468@s.whatsapp.net'
+ *
+ * await cache.close() // Persists to disk
+ * ```
+ *
+ * @module lidCache
+ * @author BuilderBot Team
+ * @since 1.4.2
+ */
+/**
+ * Branded type for WhatsApp Local Identifier (LID).
+ * Ensures compile-time distinction from regular strings.
+ *
+ * @example
+ * ```typescript
+ * const lid = '123456789@lid' as LidJid
+ * const pn = resolveLidToPn(cache, fallback, logger, lid) // OK
+ * resolveLidToPn(cache, fallback, logger, '123456789@lid') // Error: not branded
+ * ```
+ */
+export type LidJid = string & {
+    readonly __brand: 'LidJid';
+};
+/**
+ * Branded type for Phone Number JID.
+ * Format: `1234567890@s.whatsapp.net`
+ */
+export type PnJid = string & {
+    readonly __brand: 'PnJid';
+};
+/**
+ * Helper to brand a string as LidJid (runtime check).
+ * Returns null if the string is not a valid LID.
+ */
+export declare function asLidJid(value: string): LidJid | null;
+/**
+ * Helper to brand a string as PnJid (runtime check).
+ * Returns null if the string is not a valid phone number JID.
+ */
+export declare function asPnJid(value: string): PnJid | null;
+/**
+ * Interface for LID cache implementations.
+ *
+ * Defines the contract for any cache that maps WhatsApp LIDs to phone numbers.
+ * Both {@link HybridLidCache} and {@link MemoryLidCache} implement this interface.
+ *
+ * @example
+ * ```typescript
+ * // Custom implementation (e.g., Redis)
+ * class RedisLidCache implements LidCache {
+ *   async get(lid: LidJid): Promise<PnJid | null> {
+ *     return redis.get(`lid:${lid}`) as Promise<PnJid | null>
+ *   }
+ *   // ... other methods
+ * }
+ * ```
+ */
+export interface LidCache {
+    /**
+     * Retrieves the phone number for a given LID.
+     *
+     * @param lid - WhatsApp Local Identifier (e.g., '123456789@lid' or '123456789:45@lid')
+     * @returns Phone number in format '1234567890@s.whatsapp.net', or null if not found/invalid
+     */
+    get(lid: LidJid | string): Promise<PnJid | string | null>;
+    /**
+     * Stores a LID → phone number mapping.
+     *
+     * @param lid - WhatsApp Local Identifier
+     * @param pn - Phone number (any format: +123, 123, 123@c.us, 123@s.whatsapp.net)
+     * @returns Promise that resolves when the value is stored in memory
+     *
+     * @remarks
+     * - PN is normalized to `123@s.whatsapp.net` format before storage
+     * - LID device suffix is normalized (e.g., `123:45@lid` → `123@lid`)
+     * - Invalid inputs are silently rejected (no throw)
+     */
+    set(lid: LidJid | string, pn: PnJid | string): Promise<void>;
+    /**
+     * Checks if a LID exists in the cache.
+     *
+     * @param lid - WhatsApp Local Identifier
+     * @returns true if the LID exists and hasn't expired
+     */
+    has(lid: LidJid | string): Promise<boolean>;
+    /**
+     * Clears all entries from the cache.
+     *
+     * @remarks Also triggers immediate flush to disk (if HybridLidCache)
+     */
+    clear(): Promise<void>;
+    /**
+     * Closes the cache, releasing resources and triggering final persistence.
+     *
+     * @remarks After close(), all operations return null/void. Call only once.
+     */
+    close?(): Promise<void>;
+}
+/**
+ * Normalizes a LID by removing the device suffix.
+ *
+ * WhatsApp sends LIDs with device identifiers (e.g., `:45`, `:99`) that vary
+ * based on the user's device. The same contact will have different suffixes
+ * on phone vs web vs tablet. This function strips the suffix for consistent
+ * caching.
+ *
+ * @param lid - LID to normalize (e.g., '123456789:45@lid')
+ * @returns Normalized LID (e.g., '123456789@lid'), or original if invalid
+ *
+ * @example
+ * ```typescript
+ * normalizeLid('123456789:45@lid')    // '123456789@lid'
+ * normalizeLid('123456789:99@lid')    // '123456789@lid'
+ * normalizeLid('123456789@lid')       // '123456789@lid' (no change)
+ * normalizeLid('123456789@c.us')      // '123456789@c.us' (no change, not a LID)
+ * normalizeLid('invalid')             // 'invalid' (no change, invalid)
+ * ```
+ */
+export declare function normalizeLid(lid: string): string;
+/**
+ * Hybrid LID cache implementation with memory hot-path and file persistence.
+ *
+ * This is the recommended production implementation, providing:
+ * - **Speed**: O(1) in-memory lookups via NodeCache (~1μs)
+ * - **Durability**: Automatic persistence to JSON file every 30s
+ * - **Resilience**: Survives process restarts, handles corrupted files gracefully
+ * - **Security**: File permissions 0o600 (owner read/write only)
+ *
+ * ## File Location
+ *
+ * Files are stored at: `{cwd}/{sessionName}_sessions/lid-cache.json`
+ *
+ * The session name is sanitized to prevent path traversal attacks.
+ *
+ * ## Configuration
+ *
+ * | Option | Default | Description |
+ * |--------|---------|-------------|
+ * | `sessionName` | required | Unique name for this bot instance |
+ * | `ttlSeconds` | 604800 (7 days) | Time-to-live for cache entries |
+ * | `basePath` | `process.cwd()` | Directory for session files |
+ * | `logger` | `console` | Logger for operational events |
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const cache = new HybridLidCache('my-bot')
+ * await cache.ready()
+ *
+ * // Custom TTL and logger
+ * const cache = new HybridLidCache('my-bot', 86400 * 30, undefined, winstonLogger)
+ *
+ * // Custom base path
+ * const cache = new HybridLidCache('my-bot', 86400, '/var/lib/bot')
+ * ```
+ */
+export declare class HybridLidCache implements LidCache {
+    /** In-memory cache via NodeCache */
+    private memory;
+    /** Absolute path to the JSON persistence file */
+    private filePath;
+    /** True if memory has unwritten changes */
+    private dirty;
+    /** True if flushToDisk() is currently running (prevents concurrent flushes) */
+    private flushing;
+    /** Interval handle for periodic auto-flush */
+    private flushInterval?;
+    /** TTL in seconds (for expiry calculations on load) */
+    private readonly ttlSeconds;
+    /** Logger for operational events (defaults to console) */
+    private readonly logger;
+    /** Consecutive flush failure count (disables persistence after threshold) */
+    private consecutiveFlushFailures;
+    /** Promise tracking initial file load (prevents race conditions) */
+    private loadPromise;
+    /** True after close() has been called */
+    private isClosed;
+    /**
+     * Creates a new HybridLidCache instance.
+     *
+     * @param sessionName - Unique identifier for this cache instance (used in filename)
+     * @param ttlSeconds - Time-to-live for cache entries (default: 7 days)
+     * @param basePath - Base directory for session files (default: process.cwd())
+     * @param logger - Logger instance for operational events (default: console)
+     *
+     * @throws Error if sessionName is empty or not a string
+     * @throws Error if ttlSeconds is less than 60
+     *
+     * @remarks
+     * The constructor starts async file loading and sets up periodic auto-flush.
+     * Use {@link ready()} to wait for initial load completion before operations
+     * that require data from previous runs.
+     */
+    constructor(sessionName: string, ttlSeconds?: number, basePath?: string, logger?: Console);
+    /**
+     * Waits for the initial file load to complete.
+     *
+     * Use this method before operations that depend on data from previous runs:
+     * - Before checking if a LID exists from a previous session
+     * - In tests to ensure deterministic state
+     * - During cache warming procedures
+     *
+     * @returns Promise that resolves when initial load completes
+     *
+     * @example
+     * ```typescript
+     * const cache = new HybridLidCache('my-bot')
+     * await cache.ready() // Wait for any existing data to load
+     * const pn = await cache.get('existing@lid') // Now safe to access
+     * ```
+     */
+    ready(): Promise<void>;
+    /**
+     * Retrieves the phone number for a given LID.
+     *
+     * @param lid - WhatsApp Local Identifier (e.g., '123456789:45@lid')
+     * @returns Phone number in format '1234567890@s.whatsapp.net', or null if:
+     *   - Cache is closed
+     *   - LID is invalid (doesn't match `*@lid` pattern)
+     *   - LID not found in cache
+     *   - Entry has expired
+     */
+    get(lid: string): Promise<string | null>;
+    /**
+     * Stores a LID → phone number mapping.
+     *
+     * Both the LID and phone number are normalized before storage:
+     * - LID: Device suffix removed (`123:45@lid` → `123@lid`)
+     * - PN: Formatted to `123@s.whatsapp.net`
+     *
+     * @param lid - WhatsApp Local Identifier
+     * @param pn - Phone number in any accepted format
+     * @returns Promise that resolves immediately (memory write is synchronous)
+     *
+     * @remarks
+     * - Invalid inputs are silently rejected (no throw)
+     * - The `dirty` flag is set, triggering async flush to disk within 30s
+     * - If the cache is closed, this is a no-op
+     */
+    set(lid: string, pn: string): Promise<void>;
+    /**
+     * Checks if a LID exists in the cache.
+     *
+     * @param lid - WhatsApp Local Identifier
+     * @returns true if:
+     *   - LID is valid
+     *   - Cache is open
+     *   - Entry exists and hasn't expired
+     *
+     * @example
+     * ```typescript
+     * if (await cache.has('123@lid')) {
+     *   const pn = await cache.get('123@lid')
+     *   // ...
+     * }
+     * ```
+     */
+    has(lid: string): Promise<boolean>;
+    /**
+     * Clears all entries from the cache.
+     *
+     * @remarks
+     * - Immediately clears memory
+     * - Triggers synchronous flush to disk (empty file)
+     * - Logs the operation at info level
+     */
+    clear(): Promise<void>;
+    /**
+     * Closes the cache, releasing resources and triggering final persistence.
+     *
+     * This method:
+     * 1. Stops the auto-flush interval
+     * 2. Waits for any in-progress file load
+     * 3. Performs a final flush to disk
+     * 4. Closes the NodeCache instance
+     * 5. Marks the cache as closed
+     *
+     * @returns Promise that resolves when cleanup is complete
+     *
+     * @remarks
+     * - After close(), all operations return null/void
+     * - Safe to call multiple times (subsequent calls are no-ops)
+     * - Flush errors are logged but don't throw
+     */
+    close(): Promise<void>;
+    /**
+     * Forces compaction of the cache file by rewriting it with only valid entries.
+     *
+     * This removes any expired entries that might still be in the file
+     * (since NodeCache auto-expiry only removes from memory, not disk).
+     *
+     * @returns Promise that resolves when compaction completes
+     *
+     * @remarks
+     * - If the cache is empty, the file is deleted instead
+     * - Automatically called when file exceeds 10MB or 10k entries
+     */
+    compact(): Promise<void>;
+    /**
+     * Persists the current cache state to disk.
+     *
+     * @internal
+     * @remarks
+     * - Concurrent calls are deduplicated (only one flush runs at a time)
+     * - No-op if nothing has changed since last flush (`dirty` flag check)
+     * - File is written with 0o600 permissions (owner read/write only)
+     * - After 10 consecutive failures, persistence is disabled
+     */
+    flushToDisk(): Promise<void>;
+    /**
+     * Checks file size and triggers compaction if exceeds threshold.
+     *
+     * @internal
+     */
+    private checkAndCompactIfNeeded;
+    /**
+     * Loads cache data from disk on startup.
+     *
+     * @internal
+     * @remarks
+     * - Silently handles missing file (first run)
+     * - Automatically removes and recovers from corrupted files
+     * - Validates TTL on each entry (entries older than TTL are skipped)
+     */
+    private loadFromDisk;
+    /**
+     * Returns cache statistics for monitoring.
+     *
+     * @returns Object with:
+     *   - `keys`: Number of entries currently in memory
+     *   - `hits`: Cache hit count (from NodeCache stats)
+     *   - `misses`: Cache miss count (from NodeCache stats)
+     *
+     * @example
+     * ```typescript
+     * const stats = cache.getStats()
+     * console.log(`Cache: ${stats.keys} entries, ${stats.hits} hits, ${stats.misses} misses`)
+     * // → Cache: 1523 entries, 4500 hits, 123 misses
+     * ```
+     */
+    getStats(): {
+        keys: number;
+        hits: number;
+        misses: number;
+    };
+}
+/**
+ * Memory-only LID cache implementation for testing.
+ *
+ * This implementation provides the same {@link LidCache} interface but without
+ * file persistence. Useful for:
+ * - Unit tests (no file I/O, no cleanup needed)
+ * - Ephemeral caches that don't need durability
+ * - Reducing disk wear in high-frequency test scenarios
+ *
+ * ## Differences from HybridLidCache
+ *
+ * | Feature | MemoryLidCache | HybridLidCache |
+ * |---------|---------------|----------------|
+ * | Persistence | ❌ None | ✅ JSON file |
+ * | `ready()` | Optional | Recommended |
+ * | `close()` | No-op | Flushes to disk |
+ * | `compact()` | No-op | Rewrites file |
+ * | Cross-restart | Data lost | Data preserved |
+ *
+ * @example
+ * ```typescript
+ * // Testing scenario
+ * const cache = new MemoryLidCache(3600) // 1 hour TTL
+ * await cache.set('123@lid', '456@s.whatsapp.net')
+ * expect(await cache.get('123@lid')).toBe('456@s.whatsapp.net')
+ * // No cleanup needed - data is ephemeral
+ * ```
+ */
+export declare class MemoryLidCache implements LidCache {
+    /** In-memory cache via NodeCache (no persistence) */
+    private memory;
+    /**
+     * Creates a new MemoryLidCache instance.
+     *
+     * @param ttlSeconds - Time-to-live for cache entries (default: 7 days)
+     */
+    constructor(ttlSeconds?: number);
+    /**
+     * Retrieves the phone number for a given LID.
+     *
+     * @param lid - WhatsApp Local Identifier
+     * @returns Phone number or null if not found/invalid
+     */
+    get(lid: string): Promise<string | null>;
+    /**
+     * Stores a LID → phone number mapping.
+     *
+     * @param lid - WhatsApp Local Identifier
+     * @param pn - Phone number in any format
+     */
+    set(lid: string, pn: string): Promise<void>;
+    /**
+     * Checks if a LID exists in the cache.
+     *
+     * @param lid - WhatsApp Local Identifier
+     * @returns true if entry exists and hasn't expired
+     */
+    has(lid: string): Promise<boolean>;
+    /**
+     * Clears all entries from the cache.
+     */
+    clear(): Promise<void>;
+    /**
+     * Closes the cache. For MemoryLidCache, this is a no-op.
+     *
+     * @remarks The NodeCache instance is not closed to allow continued testing.
+     * If you need to free memory, use `clear()` before `close()`.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Configuration options for creating a LidCache instance.
+ */
+export interface LidCacheFactoryOptions {
+    /** Cache strategy: 'file' (default), 'memory', or custom LidCache instance */
+    strategy?: 'file' | 'memory' | LidCache;
+    /** Session name for file-based cache (used in filename) */
+    sessionName?: string;
+    /** TTL in seconds (default: 7 days) */
+    ttlSeconds?: number;
+    /** Base path for session files (default: process.cwd()) */
+    basePath?: string;
+    /** Logger for operational events (default: console) */
+    logger?: Console;
+}
+/**
+ * Factory function to create a LidCache instance based on configuration.
+ *
+ * This factory centralizes cache creation logic, making it reusable across
+ * the codebase and easier to test/maintain.
+ *
+ * @param options - Factory configuration options
+ * @returns Configured LidCache instance
+ *
+ * @example
+ * ```typescript
+ * // Default: HybridLidCache (file + memory)
+ * const cache = createLidCache({ sessionName: 'my-bot' })
+ *
+ * // Memory-only (testing)
+ * const cache = createLidCache({ strategy: 'memory', ttlSeconds: 3600 })
+ *
+ * // Custom implementation
+ * const cache = createLidCache({ strategy: new RedisLidCache() })
+ * ```
+ */
+export declare function createLidCache(options?: LidCacheFactoryOptions): LidCache;
+/**
+ * Minimal interface for Baileys message context key.
+ * Used for type-safe extraction of LID/PN mappings from incoming messages.
+ *
+ * @internal
+ */
+export interface MessageContextKey {
+    /** Remote JID (LID for DMs, group ID for groups) */
+    remoteJid?: string;
+    /** Participant LID in group messages */
+    participant?: string;
+    /** Participant phone number (if available) */
+    participantAlt?: string;
+    /** Alternative remote JID with phone number */
+    remoteJidAlt?: string;
+    /** Sender phone number (if available) */
+    senderPn?: string;
+    /** Participant phone number (alternative field) */
+    participantPn?: string;
+}
+/**
+ * Minimal interface for Baileys message context.
+ *
+ * @internal
+ */
+export interface MessageContext {
+    /** Message key with JID information */
+    key?: MessageContextKey;
+}
+/**
+ * Type guard to check if a value is a valid MessageContext.
+ *
+ * @param value - Value to check
+ * @returns true if the value matches MessageContext structure
+ */
+export declare function isMessageContext(value: unknown): value is MessageContext;
+/**
+ * Extracts and caches LID → PN mapping from an incoming message.
+ *
+ * This utility function inspects the message context to find LID/PN pairs
+ * and stores them in the provided cache for future lookups.
+ *
+ * @param cache - LidCache instance to store the mapping
+ * @param messageCtx - Baileys message context (WAMessage)
+ * @returns Promise that resolves when caching is complete (or silently fails)
+ *
+ * @example
+ * ```typescript
+ * // In message handler:
+ * for (const message of messages) {
+ *     await extractAndCacheLidFromMessage(lidCache, message)
+ * }
+ * ```
+ */
+export declare function extractAndCacheLidFromMessage(cache: LidCache, messageCtx: MessageContext): Promise<void>;
+/**
+ * LID resolver function type.
+ * Takes a LID string and returns the corresponding phone number JID or null.
+ */
+export type LidResolver = (lid: LidJid) => Promise<PnJid | null>;
+/**
+ * Resolves a LID to a phone number using cache-first strategy.
+ *
+ * This function implements the resolution chain:
+ * 1. Check cache first (O(1), ~1μs)
+ * 2. If miss, call fallback resolver (e.g., Baileys lidMapping)
+ * 3. If resolved, store in cache for future lookups
+ *
+ * @param cache - LidCache instance for storing/retrieving mappings
+ * @param fallbackResolver - Async function to resolve LID when not in cache
+ * @param logger - Logger for operational events (optional)
+ * @param lid - WhatsApp Local Identifier to resolve
+ * @returns Phone number in format '1234567890@s.whatsapp.net', or null
+ *
+ * @example
+ * ```typescript
+ * const pn = await resolveLidToPn(
+ *     lidCache,
+ *     (lid) => baileysSignalRepo.lidMapping.getPNForLID(lid),
+ *     console,
+ *     '123456789@lid' as LidJid
+ * )
+ * ```
+ */
+export declare function resolveLidToPn(cache: LidCache, fallbackResolver: LidResolver | ((lid: string) => Promise<string | null>), logger: Console | undefined, lid: LidJid | string): Promise<PnJid | string | null>;
+//# sourceMappingURL=lidCache.d.ts.map

package/dist/lidCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lidCache.d.ts","sourceRoot":"","sources":["../src/lidCache.ts"],"names":[],"mappings":"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"}

package/dist/type.d.ts

@@ -1,5 +1,6 @@
 import type { GlobalVendorArgs } from '@builderbot/bot/dist/types';
 import { proto, WABrowserDescription, WAVersion } from 'baileys';
+import type { LidCache } from './lidCache';
 export interface BaileyGlobalVendorArgs extends GlobalVendorArgs {
     gifPlayback: boolean;
     usePairingCode: boolean;
@@ -15,5 +16,17 @@ export interface BaileyGlobalVendorArgs extends GlobalVendorArgs {
     version?: WAVersion;
     autoRefresh?: number;
     host?: any;
+    /**
+     * Estrategia de caché para resolución LID→PN.
+     * - 'file' (default): HybridLidCache (memory + file persistence)
+     * - 'memory': MemoryLidCache (solo memoria, no persiste)
+     * - LidCache: Implementación custom (e.g., Redis)
+     */
+    lidCache?: 'file' | 'memory' | LidCache;
+    /**
+     * TTL (time-to-live) en segundos para entradas del LID cache.
+     * Default: 604800 (7 días)
+     */
+    lidCacheTtl?: number;
 }
 //# sourceMappingURL=type.d.ts.map

package/dist/type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../src/type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAChE,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC5D,WAAW,EAAE,OAAO,CAAA;IACpB,cAAc,EAAE,OAAO,CAAA;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,OAAO,EAAE,oBAAoB,CAAA;IAC7B,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9D,eAAe,EAAE,OAAO,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,YAAY,EAAE,OAAO,CAAA;IACrB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,GAAG,CAAA;CACb"}
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../src/type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAEhE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAE1C,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC5D,WAAW,EAAE,OAAO,CAAA;IACpB,cAAc,EAAE,OAAO,CAAA;IACvB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,OAAO,EAAE,oBAAoB,CAAA;IAC7B,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9D,eAAe,EAAE,OAAO,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,YAAY,EAAE,OAAO,CAAA;IACrB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,GAAG,CAAA;IAEV;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAA;IAEvC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACvB"}