@fin.cx/opendata 3.2.2 → 3.4.0

package/dist_ts/stocks/providers/provider.coingecko.js

@@ -0,0 +1,596 @@
+import * as plugins from '../../plugins.js';
+/**
+ * Custom error for rate limit exceeded responses
+ */
+class RateLimitError extends Error {
+    constructor(message, waitTime, retryAfter) {
+        super(message);
+        this.waitTime = waitTime;
+        this.retryAfter = retryAfter;
+        this.name = 'RateLimitError';
+    }
+}
+/**
+ * Rate limiter for CoinGecko API
+ * Free tier (Demo): 30 requests per minute
+ * Without registration: 5-15 requests per minute
+ */
+class RateLimiter {
+    constructor(maxRequestsPerMinute = 30) {
+        this.requestTimes = [];
+        this.consecutiveRateLimitErrors = 0;
+        this.maxRequestsPerMinute = maxRequestsPerMinute;
+    }
+    async waitForSlot() {
+        const now = Date.now();
+        const oneMinuteAgo = now - 60000;
+        // Remove requests older than 1 minute
+        this.requestTimes = this.requestTimes.filter(time => time > oneMinuteAgo);
+        // If we've hit the limit, wait
+        if (this.requestTimes.length >= this.maxRequestsPerMinute) {
+            const oldestRequest = this.requestTimes[0];
+            const waitTime = 60000 - (now - oldestRequest) + 100; // +100ms buffer
+            await plugins.smartdelay.delayFor(waitTime);
+            return this.waitForSlot(); // Recursively check again
+        }
+        // Record this request
+        this.requestTimes.push(now);
+    }
+    /**
+     * Get time in milliseconds until next request slot is available
+     */
+    getTimeUntilNextSlot() {
+        const now = Date.now();
+        const oneMinuteAgo = now - 60000;
+        // Clean old requests
+        const recentRequests = this.requestTimes.filter(time => time > oneMinuteAgo);
+        if (recentRequests.length < this.maxRequestsPerMinute) {
+            return 0; // Slot available now
+        }
+        // Calculate wait time until oldest request expires
+        const oldestRequest = recentRequests[0];
+        return Math.max(0, 60000 - (now - oldestRequest) + 100);
+    }
+    /**
+     * Handle rate limit error with exponential backoff
+     * Returns wait time in milliseconds
+     */
+    handleRateLimitError() {
+        this.consecutiveRateLimitErrors++;
+        // Exponential backoff: 1s, 2s, 4s, 8s, 16s, 32s, 60s (max)
+        const baseWait = 1000; // 1 second
+        const exponent = this.consecutiveRateLimitErrors - 1;
+        const backoff = Math.min(baseWait * Math.pow(2, exponent), 60000 // max 60 seconds
+        );
+        // After 3 consecutive 429s, reduce rate limit to 80% as safety measure
+        if (this.consecutiveRateLimitErrors >= 3) {
+            const newLimit = Math.floor(this.maxRequestsPerMinute * 0.8);
+            if (newLimit < this.maxRequestsPerMinute) {
+                console.warn(`Adjusting rate limit from ${this.maxRequestsPerMinute} to ${newLimit} requests/min due to repeated 429 errors`);
+                this.maxRequestsPerMinute = newLimit;
+            }
+        }
+        return backoff;
+    }
+    /**
+     * Reset consecutive error count on successful request
+     */
+    resetErrors() {
+        if (this.consecutiveRateLimitErrors > 0) {
+            this.consecutiveRateLimitErrors = 0;
+        }
+    }
+}
+/**
+ * CoinGecko Crypto Price Provider
+ *
+ * Documentation: https://docs.coingecko.com/v3.0.1/reference/endpoint-overview
+ *
+ * Features:
+ * - Current crypto prices (single and batch)
+ * - Historical price data with OHLCV
+ * - 13M+ tokens, 240+ networks, 1600+ exchanges
+ * - Accepts both ticker symbols (BTC, ETH) and CoinGecko IDs (bitcoin, ethereum)
+ * - 24/7 market data (crypto never closes)
+ *
+ * Rate Limits:
+ * - Free tier (no key): 5-15 requests/minute
+ * - Demo plan (free with registration): ~30 requests/minute, 10,000/month
+ * - Paid plans: Higher limits
+ *
+ * API Authentication:
+ * - Optional API key for Demo/paid plans
+ * - Header: x-cg-demo-api-key (Demo) or x-cg-pro-api-key (paid)
+ */
+export class CoinGeckoProvider {
+    constructor(apiKey, config) {
+        this.config = config;
+        this.name = 'CoinGecko';
+        this.priority = 90; // High priority for crypto, between Yahoo (100) and Marketstack (80)
+        this.requiresAuth = false; // API key is optional
+        this.rateLimit = {
+            requestsPerMinute: 30, // Demo plan default
+            requestsPerDay: 10000 // Demo plan monthly quota / 30
+        };
+        this.logger = console;
+        this.baseUrl = 'https://api.coingecko.com/api/v3';
+        // Coin mapping cache
+        this.coinMapCache = new Map(); // ticker/id -> coingecko id
+        this.coinListLoadedAt = null;
+        this.coinListCacheTTL = 24 * 60 * 60 * 1000; // 24 hours
+        // Priority map for common crypto tickers (to avoid conflicts)
+        this.priorityTickerMap = new Map([
+            ['btc', 'bitcoin'],
+            ['eth', 'ethereum'],
+            ['usdt', 'tether'],
+            ['bnb', 'binancecoin'],
+            ['sol', 'solana'],
+            ['usdc', 'usd-coin'],
+            ['xrp', 'ripple'],
+            ['ada', 'cardano'],
+            ['doge', 'dogecoin'],
+            ['trx', 'tron'],
+            ['dot', 'polkadot'],
+            ['matic', 'matic-network'],
+            ['ltc', 'litecoin'],
+            ['shib', 'shiba-inu'],
+            ['avax', 'avalanche-2'],
+            ['link', 'chainlink'],
+            ['atom', 'cosmos'],
+            ['uni', 'uniswap'],
+            ['etc', 'ethereum-classic'],
+            ['xlm', 'stellar']
+        ]);
+        this.apiKey = apiKey;
+        this.rateLimiter = new RateLimiter(this.rateLimit.requestsPerMinute);
+    }
+    /**
+     * Unified data fetching method supporting all request types
+     */
+    async fetchData(request) {
+        switch (request.type) {
+            case 'current':
+                return this.fetchCurrentPrice(request);
+            case 'batch':
+                return this.fetchBatchCurrentPrices(request);
+            case 'historical':
+                return this.fetchHistoricalPrices(request);
+            case 'intraday':
+                return this.fetchIntradayPrices(request);
+            default:
+                throw new Error(`Unsupported request type: ${request.type}`);
+        }
+    }
+    /**
+     * Fetch current price for a single crypto
+     */
+    async fetchCurrentPrice(request) {
+        return this.fetchWithRateLimitRetry(async () => {
+            // Resolve ticker to CoinGecko ID
+            const coinId = await this.resolveCoinId(request.ticker);
+            // Build URL
+            const params = new URLSearchParams({
+                ids: coinId,
+                vs_currencies: 'usd',
+                include_market_cap: 'true',
+                include_24hr_vol: 'true',
+                include_24hr_change: 'true',
+                include_last_updated_at: 'true'
+            });
+            const url = `${this.baseUrl}/simple/price?${params}`;
+            // Wait for rate limit slot
+            await this.rateLimiter.waitForSlot();
+            // Make request
+            const response = await plugins.smartrequest.SmartRequest.create()
+                .url(url)
+                .headers(this.buildHeaders())
+                .timeout(this.config?.timeout || 10000)
+                .get();
+            const responseData = await response.json();
+            // Check for rate limit error
+            if (this.isRateLimitError(responseData)) {
+                const waitTime = this.rateLimiter.handleRateLimitError();
+                throw new RateLimitError(`Rate limit exceeded for ${request.ticker}`, waitTime);
+            }
+            if (!responseData[coinId]) {
+                throw new Error(`No data found for ${request.ticker} (${coinId})`);
+            }
+            return this.mapToStockPrice(request.ticker, coinId, responseData[coinId], 'live');
+        }, `current price for ${request.ticker}`);
+    }
+    /**
+     * Fetch batch current prices for multiple cryptos
+     */
+    async fetchBatchCurrentPrices(request) {
+        return this.fetchWithRateLimitRetry(async () => {
+            // Resolve all tickers to CoinGecko IDs
+            const coinIds = await Promise.all(request.tickers.map(ticker => this.resolveCoinId(ticker)));
+            // Build URL with comma-separated IDs
+            const params = new URLSearchParams({
+                ids: coinIds.join(','),
+                vs_currencies: 'usd',
+                include_market_cap: 'true',
+                include_24hr_vol: 'true',
+                include_24hr_change: 'true',
+                include_last_updated_at: 'true'
+            });
+            const url = `${this.baseUrl}/simple/price?${params}`;
+            // Wait for rate limit slot
+            await this.rateLimiter.waitForSlot();
+            // Make request
+            const response = await plugins.smartrequest.SmartRequest.create()
+                .url(url)
+                .headers(this.buildHeaders())
+                .timeout(this.config?.timeout || 15000)
+                .get();
+            const responseData = await response.json();
+            // Check for rate limit error
+            if (this.isRateLimitError(responseData)) {
+                const waitTime = this.rateLimiter.handleRateLimitError();
+                throw new RateLimitError(`Rate limit exceeded for batch request`, waitTime);
+            }
+            const prices = [];
+            // Map responses back to original tickers
+            for (let i = 0; i < request.tickers.length; i++) {
+                const ticker = request.tickers[i];
+                const coinId = coinIds[i];
+                if (responseData[coinId]) {
+                    try {
+                        prices.push(this.mapToStockPrice(ticker, coinId, responseData[coinId], 'live'));
+                    }
+                    catch (error) {
+                        this.logger.warn(`Failed to parse data for ${ticker}:`, error);
+                    }
+                }
+                else {
+                    this.logger.warn(`No data returned for ${ticker} (${coinId})`);
+                }
+            }
+            if (prices.length === 0) {
+                throw new Error('No valid price data received from batch request');
+            }
+            return prices;
+        }, `batch prices for ${request.tickers.length} tickers`);
+    }
+    /**
+     * Fetch historical prices with OHLCV data
+     */
+    async fetchHistoricalPrices(request) {
+        return this.fetchWithRateLimitRetry(async () => {
+            const coinId = await this.resolveCoinId(request.ticker);
+            // Calculate days between dates
+            const days = Math.ceil((request.to.getTime() - request.from.getTime()) / (1000 * 60 * 60 * 24));
+            // Build URL
+            const params = new URLSearchParams({
+                vs_currency: 'usd',
+                days: days.toString(),
+                interval: 'daily' // Explicit daily granularity for historical data
+            });
+            const url = `${this.baseUrl}/coins/${coinId}/market_chart?${params}`;
+            // Wait for rate limit slot
+            await this.rateLimiter.waitForSlot();
+            // Make request
+            const response = await plugins.smartrequest.SmartRequest.create()
+                .url(url)
+                .headers(this.buildHeaders())
+                .timeout(this.config?.timeout || 20000)
+                .get();
+            const responseData = await response.json();
+            // Check for rate limit error
+            if (this.isRateLimitError(responseData)) {
+                const waitTime = this.rateLimiter.handleRateLimitError();
+                throw new RateLimitError(`Rate limit exceeded for historical ${request.ticker}`, waitTime);
+            }
+            if (!responseData.prices || !Array.isArray(responseData.prices)) {
+                this.logger.error(`Invalid API response for ${request.ticker}:`, JSON.stringify(responseData).substring(0, 500));
+                throw new Error(`Invalid response format for ${request.ticker}: ${JSON.stringify(responseData).substring(0, 200)}`);
+            }
+            const prices = [];
+            const priceData = responseData.prices;
+            const marketCapData = responseData.market_caps || [];
+            const volumeData = responseData.total_volumes || [];
+            // Process each data point
+            for (let i = 0; i < priceData.length; i++) {
+                const [timestamp, price] = priceData[i];
+                const date = new Date(timestamp);
+                // Filter by date range
+                if (date < request.from || date > request.to)
+                    continue;
+                const marketCap = marketCapData[i]?.[1];
+                const volume = volumeData[i]?.[1];
+                // Calculate previous close for change calculation
+                const previousClose = i > 0 ? priceData[i - 1][1] : price;
+                const change = price - previousClose;
+                const changePercent = previousClose !== 0 ? (change / previousClose) * 100 : 0;
+                prices.push({
+                    ticker: request.ticker.toUpperCase(),
+                    price: price,
+                    currency: 'USD',
+                    change: change,
+                    changePercent: changePercent,
+                    previousClose: previousClose,
+                    timestamp: date,
+                    provider: this.name,
+                    marketState: 'REGULAR', // Crypto markets are always open
+                    // OHLCV data (note: market_chart doesn't provide OHLC, only close prices)
+                    volume: volume,
+                    dataType: 'eod',
+                    fetchedAt: new Date(),
+                    companyName: coinId.charAt(0).toUpperCase() + coinId.slice(1)
+                });
+            }
+            return prices;
+        }, `historical prices for ${request.ticker}`);
+    }
+    /**
+     * Fetch intraday prices with hourly intervals
+     */
+    async fetchIntradayPrices(request) {
+        return this.fetchWithRateLimitRetry(async () => {
+            const coinId = await this.resolveCoinId(request.ticker);
+            // Map interval to days parameter (CoinGecko auto-granularity)
+            // For hourly data, request 1-7 days
+            let days = 1;
+            switch (request.interval) {
+                case '1min':
+                case '5min':
+                case '10min':
+                case '15min':
+                case '30min':
+                    throw new Error('CoinGecko only supports hourly intervals in market_chart. Use interval: "1hour"');
+                case '1hour':
+                    days = 1; // Last 24 hours with hourly granularity
+                    break;
+            }
+            // Build URL (omit interval param for automatic granularity based on days)
+            const params = new URLSearchParams({
+                vs_currency: 'usd',
+                days: days.toString()
+            });
+            const url = `${this.baseUrl}/coins/${coinId}/market_chart?${params}`;
+            // Wait for rate limit slot
+            await this.rateLimiter.waitForSlot();
+            // Make request
+            const response = await plugins.smartrequest.SmartRequest.create()
+                .url(url)
+                .headers(this.buildHeaders())
+                .timeout(this.config?.timeout || 15000)
+                .get();
+            const responseData = await response.json();
+            // Check for rate limit error
+            if (this.isRateLimitError(responseData)) {
+                const waitTime = this.rateLimiter.handleRateLimitError();
+                throw new RateLimitError(`Rate limit exceeded for intraday ${request.ticker}`, waitTime);
+            }
+            if (!responseData.prices || !Array.isArray(responseData.prices)) {
+                this.logger.error(`Invalid API response for ${request.ticker}:`, JSON.stringify(responseData).substring(0, 500));
+                throw new Error(`Invalid response format for ${request.ticker}: ${JSON.stringify(responseData).substring(0, 200)}`);
+            }
+            const prices = [];
+            const priceData = responseData.prices;
+            const marketCapData = responseData.market_caps || [];
+            const volumeData = responseData.total_volumes || [];
+            // Apply limit if specified
+            const limit = request.limit || priceData.length;
+            const dataToProcess = priceData.slice(-limit);
+            for (let i = 0; i < dataToProcess.length; i++) {
+                const actualIndex = priceData.length - limit + i;
+                const [timestamp, price] = dataToProcess[i];
+                const date = new Date(timestamp);
+                const marketCap = marketCapData[actualIndex]?.[1];
+                const volume = volumeData[actualIndex]?.[1];
+                const previousClose = i > 0 ? dataToProcess[i - 1][1] : price;
+                const change = price - previousClose;
+                const changePercent = previousClose !== 0 ? (change / previousClose) * 100 : 0;
+                prices.push({
+                    ticker: request.ticker.toUpperCase(),
+                    price: price,
+                    currency: 'USD',
+                    change: change,
+                    changePercent: changePercent,
+                    previousClose: previousClose,
+                    timestamp: date,
+                    provider: this.name,
+                    marketState: 'REGULAR',
+                    volume: volume,
+                    dataType: 'intraday',
+                    fetchedAt: new Date(),
+                    companyName: coinId.charAt(0).toUpperCase() + coinId.slice(1)
+                });
+            }
+            return prices;
+        }, `intraday prices for ${request.ticker}`);
+    }
+    /**
+     * Check if CoinGecko API is available
+     */
+    async isAvailable() {
+        try {
+            const url = `${this.baseUrl}/simple/price?ids=bitcoin&vs_currencies=usd`;
+            await this.rateLimiter.waitForSlot();
+            const response = await plugins.smartrequest.SmartRequest.create()
+                .url(url)
+                .headers(this.buildHeaders())
+                .timeout(5000)
+                .get();
+            const responseData = await response.json();
+            return responseData.bitcoin?.usd !== undefined;
+        }
+        catch (error) {
+            this.logger.warn('CoinGecko provider is not available:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if a market/network is supported
+     * CoinGecko supports 240+ networks
+     */
+    supportsMarket(market) {
+        // CoinGecko has extensive crypto network coverage
+        const supportedNetworks = [
+            'CRYPTO', 'BTC', 'ETH', 'BSC', 'POLYGON', 'AVALANCHE',
+            'SOLANA', 'ARBITRUM', 'OPTIMISM', 'BASE'
+        ];
+        return supportedNetworks.includes(market.toUpperCase());
+    }
+    /**
+     * Check if a ticker format is supported
+     * Supports both ticker symbols (BTC) and CoinGecko IDs (bitcoin)
+     */
+    supportsTicker(ticker) {
+        // Accept alphanumeric with hyphens (for coin IDs like 'wrapped-bitcoin')
+        return /^[A-Za-z0-9\-]{1,50}$/.test(ticker);
+    }
+    /**
+     * Resolve ticker symbol or CoinGecko ID to canonical CoinGecko ID
+     * Supports both formats: "BTC" -> "bitcoin", "bitcoin" -> "bitcoin"
+     */
+    async resolveCoinId(tickerOrId) {
+        const normalized = tickerOrId.toLowerCase();
+        // Check priority map first (for common cryptos)
+        if (this.priorityTickerMap.has(normalized)) {
+            const coinId = this.priorityTickerMap.get(normalized);
+            this.coinMapCache.set(normalized, coinId);
+            return coinId;
+        }
+        // Check cache
+        if (this.coinMapCache.has(normalized)) {
+            return this.coinMapCache.get(normalized);
+        }
+        // Check if it's already a valid CoinGecko ID (contains hyphens or is all lowercase with original case)
+        if (normalized.includes('-') || normalized === tickerOrId) {
+            // Assume it's a CoinGecko ID, cache it
+            this.coinMapCache.set(normalized, normalized);
+            return normalized;
+        }
+        // Load coin list if needed
+        if (!this.coinListLoadedAt ||
+            Date.now() - this.coinListLoadedAt.getTime() > this.coinListCacheTTL) {
+            await this.loadCoinList();
+        }
+        // Try to find in cache after loading
+        if (this.coinMapCache.has(normalized)) {
+            return this.coinMapCache.get(normalized);
+        }
+        // Not found - return as-is and let API handle the error
+        this.logger.warn(`Could not resolve ticker ${tickerOrId} to CoinGecko ID, using as-is`);
+        return normalized;
+    }
+    /**
+     * Load complete coin list from CoinGecko API
+     */
+    async loadCoinList() {
+        try {
+            const url = `${this.baseUrl}/coins/list`;
+            await this.rateLimiter.waitForSlot();
+            const response = await plugins.smartrequest.SmartRequest.create()
+                .url(url)
+                .headers(this.buildHeaders())
+                .timeout(10000)
+                .get();
+            const coinList = await response.json();
+            // Build mapping: symbol -> id
+            for (const coin of coinList) {
+                const symbol = coin.symbol.toLowerCase();
+                const id = coin.id.toLowerCase();
+                // Don't overwrite priority mappings or existing cache entries
+                if (!this.priorityTickerMap.has(symbol) && !this.coinMapCache.has(symbol)) {
+                    this.coinMapCache.set(symbol, id);
+                }
+                // Always cache the ID mapping
+                this.coinMapCache.set(id, id);
+            }
+            this.coinListLoadedAt = new Date();
+            this.logger.info(`Loaded ${coinList.length} coins from CoinGecko`);
+        }
+        catch (error) {
+            this.logger.error('Failed to load coin list from CoinGecko:', error);
+            // Don't throw - we can still work with direct IDs
+        }
+    }
+    /**
+     * Map CoinGecko simple/price response to IStockPrice
+     */
+    mapToStockPrice(ticker, coinId, data, dataType) {
+        const price = data.usd;
+        const change24h = data.usd_24h_change || 0;
+        // Calculate previous close from 24h change
+        const changePercent = change24h;
+        const change = (price * changePercent) / 100;
+        const previousClose = price - change;
+        // Parse last updated timestamp
+        const timestamp = data.last_updated_at
+            ? new Date(data.last_updated_at * 1000)
+            : new Date();
+        return {
+            ticker: ticker.toUpperCase(),
+            price: price,
+            currency: 'USD',
+            change: change,
+            changePercent: changePercent,
+            previousClose: previousClose,
+            timestamp: timestamp,
+            provider: this.name,
+            marketState: 'REGULAR', // Crypto markets are 24/7
+            // Volume and market cap
+            volume: data.usd_24h_vol,
+            dataType: dataType,
+            fetchedAt: new Date(),
+            // Company identification (use coin name)
+            companyName: coinId.charAt(0).toUpperCase() + coinId.slice(1),
+            companyFullName: `${coinId.charAt(0).toUpperCase() + coinId.slice(1)} (${ticker.toUpperCase()})`
+        };
+    }
+    /**
+     * Build HTTP headers with optional API key
+     */
+    buildHeaders() {
+        const headers = {
+            'Accept': 'application/json'
+        };
+        if (this.apiKey) {
+            // Use Demo or Pro API key header
+            // CoinGecko accepts both x-cg-demo-api-key and x-cg-pro-api-key
+            headers['x-cg-demo-api-key'] = this.apiKey;
+        }
+        return headers;
+    }
+    /**
+     * Check if response indicates a rate limit error (429)
+     */
+    isRateLimitError(responseData) {
+        return responseData?.status?.error_code === 429;
+    }
+    /**
+     * Wrapper for fetch operations with automatic rate limit retry and exponential backoff
+     */
+    async fetchWithRateLimitRetry(fetchFn, operationName, maxRetries = 3) {
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                const result = await fetchFn();
+                this.rateLimiter.resetErrors();
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                if (error instanceof RateLimitError) {
+                    const attemptInfo = `${attempt + 1}/${maxRetries}`;
+                    this.logger.warn(`Rate limit hit for ${operationName}, waiting ${error.waitTime}ms before retry ${attemptInfo}`);
+                    if (attempt < maxRetries - 1) {
+                        await plugins.smartdelay.delayFor(error.waitTime);
+                        continue;
+                    }
+                    else {
+                        this.logger.error(`Max retries (${maxRetries}) exceeded for ${operationName} due to rate limiting`);
+                        throw error;
+                    }
+                }
+                // Non-rate-limit errors: throw immediately
+                throw error;
+            }
+        }
+        throw lastError;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.coingecko.js","sourceRoot":"","sources":["../../../ts/stocks/providers/provider.coingecko.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAW5C;;GAEG;AACH,MAAM,cAAe,SAAQ,KAAK;IAChC,YACE,OAAe,EACR,QAAgB,EAChB,UAAmB;QAE1B,KAAK,CAAC,OAAO,CAAC,CAAC;QAHR,aAAQ,GAAR,QAAQ,CAAQ;QAChB,eAAU,GAAV,UAAU,CAAS;QAG1B,IAAI,CAAC,IAAI,GAAG,gBAAgB,CAAC;IAC/B,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,WAAW;IAKf,YAAY,uBAA+B,EAAE;QAJrC,iBAAY,GAAa,EAAE,CAAC;QAE5B,+BAA0B,GAAW,CAAC,CAAC;QAG7C,IAAI,CAAC,oBAAoB,GAAG,oBAAoB,CAAC;IACnD,CAAC;IAEM,KAAK,CAAC,WAAW;QACtB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,YAAY,GAAG,GAAG,GAAG,KAAK,CAAC;QAEjC,sCAAsC;QACtC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,GAAG,YAAY,CAAC,CAAC;QAE1E,+BAA+B;QAC/B,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC1D,MAAM,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAC3C,MAAM,QAAQ,GAAG,KAAK,GAAG,CAAC,GAAG,GAAG,aAAa,CAAC,GAAG,GAAG,CAAC,CAAC,gBAAgB;YACtE,MAAM,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAC5C,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,0BAA0B;QACvD,CAAC;QAED,sBAAsB;QACtB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED;;OAEG;IACI,oBAAoB;QACzB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,YAAY,GAAG,GAAG,GAAG,KAAK,CAAC;QAEjC,qBAAqB;QACrB,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,GAAG,YAAY,CAAC,CAAC;QAE7E,IAAI,cAAc,CAAC,MAAM,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;YACtD,OAAO,CAAC,CAAC,CAAC,qBAAqB;QACjC,CAAC;QAED,mDAAmD;QACnD,MAAM,aAAa,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,GAAG,GAAG,aAAa,CAAC,GAAG,GAAG,CAAC,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACI,oBAAoB;QACzB,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAElC,2DAA2D;QAC3D,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,WAAW;QAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,0BAA0B,GAAG,CAAC,CAAC;QACrD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CACtB,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,EAChC,KAAK,CAAC,iBAAiB;SACxB,CAAC;QAEF,uEAAuE;QACvE,IAAI,IAAI,CAAC,0BAA0B,IAAI,CAAC,EAAE,CAAC;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,oBAAoB,GAAG,GAAG,CAAC,CAAC;YAC7D,IAAI,QAAQ,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBACzC,OAAO,CAAC,IAAI,CACV,6BAA6B,IAAI,CAAC,oBAAoB,OAAO,QAAQ,0CAA0C,CAChH,CAAC;gBACF,IAAI,CAAC,oBAAoB,GAAG,QAAQ,CAAC;YACvC,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,IAAI,IAAI,CAAC,0BAA0B,GAAG,CAAC,EAAE,CAAC;YACxC,IAAI,CAAC,0BAA0B,GAAG,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;CACF;AAWD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,iBAAiB;IA2C5B,YAAY,MAAe,EAAU,MAAwB;QAAxB,WAAM,GAAN,MAAM,CAAkB;QA1CtD,SAAI,GAAG,WAAW,CAAC;QACnB,aAAQ,GAAG,EAAE,CAAC,CAAC,qEAAqE;QAC3E,iBAAY,GAAG,KAAK,CAAC,CAAC,sBAAsB;QAC5C,cAAS,GAAG;YAC1B,iBAAiB,EAAE,EAAE,EAAE,oBAAoB;YAC3C,cAAc,EAAE,KAAK,CAAC,+BAA+B;SACtD,CAAC;QAEM,WAAM,GAAG,OAAO,CAAC;QACjB,YAAO,GAAG,kCAAkC,CAAC;QAIrD,qBAAqB;QACb,iBAAY,GAAG,IAAI,GAAG,EAAkB,CAAC,CAAC,4BAA4B;QACtE,qBAAgB,GAAgB,IAAI,CAAC;QAC5B,qBAAgB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,WAAW;QAEpE,8DAA8D;QAC7C,sBAAiB,GAAG,IAAI,GAAG,CAAiB;YAC3D,CAAC,KAAK,EAAE,SAAS,CAAC;YAClB,CAAC,KAAK,EAAE,UAAU,CAAC;YACnB,CAAC,MAAM,EAAE,QAAQ,CAAC;YAClB,CAAC,KAAK,EAAE,aAAa,CAAC;YACtB,CAAC,KAAK,EAAE,QAAQ,CAAC;YACjB,CAAC,MAAM,EAAE,UAAU,CAAC;YACpB,CAAC,KAAK,EAAE,QAAQ,CAAC;YACjB,CAAC,KAAK,EAAE,SAAS,CAAC;YAClB,CAAC,MAAM,EAAE,UAAU,CAAC;YACpB,CAAC,KAAK,EAAE,MAAM,CAAC;YACf,CAAC,KAAK,EAAE,UAAU,CAAC;YACnB,CAAC,OAAO,EAAE,eAAe,CAAC;YAC1B,CAAC,KAAK,EAAE,UAAU,CAAC;YACnB,CAAC,MAAM,EAAE,WAAW,CAAC;YACrB,CAAC,MAAM,EAAE,aAAa,CAAC;YACvB,CAAC,MAAM,EAAE,WAAW,CAAC;YACrB,CAAC,MAAM,EAAE,QAAQ,CAAC;YAClB,CAAC,KAAK,EAAE,SAAS,CAAC;YAClB,CAAC,KAAK,EAAE,kBAAkB,CAAC;YAC3B,CAAC,KAAK,EAAE,SAAS,CAAC;SACnB,CAAC,CAAC;QAGD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;IACvE,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,SAAS,CAAC,OAA0B;QAC/C,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;YACrB,KAAK,SAAS;gBACZ,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;YACzC,KAAK,OAAO;gBACV,OAAO,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;YAC/C,KAAK,YAAY;gBACf,OAAO,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;YAC7C,KAAK,UAAU;gBACb,OAAO,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;YAC3C;gBACE,MAAM,IAAI,KAAK,CAAC,6BAA8B,OAAe,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1E,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,iBAAiB,CAAC,OAA6B;QAC3D,OAAO,IAAI,CAAC,uBAAuB,CAAC,KAAK,IAAI,EAAE;YAC7C,iCAAiC;YACjC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAExD,YAAY;YACZ,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC;gBACjC,GAAG,EAAE,MAAM;gBACX,aAAa,EAAE,KAAK;gBACpB,kBAAkB,EAAE,MAAM;gBAC1B,gBAAgB,EAAE,MAAM;gBACxB,mBAAmB,EAAE,MAAM;gBAC3B,uBAAuB,EAAE,MAAM;aAChC,CAAC,CAAC;YAEH,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,iBAAiB,MAAM,EAAE,CAAC;YAErD,2BAA2B;YAC3B,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;YAErC,eAAe;YACf,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE;iBAC9D,GAAG,CAAC,GAAG,CAAC;iBACR,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;iBAC5B,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,IAAI,KAAK,CAAC;iBACtC,GAAG,EAAE,CAAC;YAET,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAS,CAAC;YAElD,6BAA6B;YAC7B,IAAI,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,EAAE,CAAC;gBACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;gBACzD,MAAM,IAAI,cAAc,CACtB,2BAA2B,OAAO,CAAC,MAAM,EAAE,EAC3C,QAAQ,CACT,CAAC;YACJ,CAAC;YAED,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC1B,MAAM,IAAI,KAAK,CAAC,qBAAqB,OAAO,CAAC,MAAM,KAAK,MAAM,GAAG,CAAC,CAAC;YACrE,CAAC;YAED,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;QACpF,CAAC,EAAE,qBAAqB,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,uBAAuB,CAAC,OAAkC;QACtE,OAAO,IAAI,CAAC,uBAAuB,CAAC,KAAK,IAAI,EAAE;YAC7C,uCAAuC;YACvC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAC1D,CAAC;YAEF,qCAAqC;YACrC,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC;gBACjC,GAAG,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC;gBACtB,aAAa,EAAE,KAAK;gBACpB,kBAAkB,EAAE,MAAM;gBAC1B,gBAAgB,EAAE,MAAM;gBACxB,mBAAmB,EAAE,MAAM;gBAC3B,uBAAuB,EAAE,MAAM;aAChC,CAAC,CAAC;YAEH,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,iBAAiB,MAAM,EAAE,CAAC;YAErD,2BAA2B;YAC3B,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;YAErC,eAAe;YACf,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE;iBAC9D,GAAG,CAAC,GAAG,CAAC;iBACR,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;iBAC5B,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,IAAI,KAAK,CAAC;iBACtC,GAAG,EAAE,CAAC;YAET,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAS,CAAC;YAElD,6BAA6B;YAC7B,IAAI,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,EAAE,CAAC;gBACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;gBACzD,MAAM,IAAI,cAAc,CACtB,uCAAuC,EACvC,QAAQ,CACT,CAAC;YACJ,CAAC;YAED,MAAM,MAAM,GAAkB,EAAE,CAAC;YAEjC,yCAAyC;YACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAChD,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAClC,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBAE1B,IAAI,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;oBACzB,IAAI,CAAC;wBACH,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;oBAClF,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,4BAA4B,MAAM,GAAG,EAAE,KAAK,CAAC,CAAC;oBACjE,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,wBAAwB,MAAM,KAAK,MAAM,GAAG,CAAC,CAAC;gBACjE,CAAC;YACH,CAAC;YAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACxB,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;YACrE,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC,EAAE,oBAAoB,OAAO,CAAC,OAAO,CAAC,MAAM,UAAU,CAAC,CAAC;IAC3D,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,qBAAqB,CAAC,OAAgC;QAClE,OAAO,IAAI,CAAC,uBAAuB,CAAC,KAAK,IAAI,EAAE;YAC7C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAExD,+BAA+B;YAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;YAEhG,YAAY;YACZ,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC;gBACjC,WAAW,EAAE,KAAK;gBAClB,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE;gBACrB,QAAQ,EAAE,OAAO,CAAC,iDAAiD;aACpE,CAAC,CAAC;YAEH,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,UAAU,MAAM,iBAAiB,MAAM,EAAE,CAAC;YAErE,2BAA2B;YAC3B,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;YAErC,eAAe;YACf,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE;iBAC9D,GAAG,CAAC,GAAG,CAAC;iBACR,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;iBAC5B,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,IAAI,KAAK,CAAC;iBACtC,GAAG,EAAE,CAAC;YAET,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAS,CAAC;YAElD,6BAA6B;YAC7B,IAAI,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,EAAE,CAAC;gBACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;gBACzD,MAAM,IAAI,cAAc,CACtB,sCAAsC,OAAO,CAAC,MAAM,EAAE,EACtD,QAAQ,CACT,CAAC;YACJ,CAAC;YAED,IAAI,CAAC,YAAY,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;gBAChE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,OAAO,CAAC,MAAM,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;gBACjH,MAAM,IAAI,KAAK,CAAC,+BAA+B,OAAO,CAAC,MAAM,KAAK,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;YACtH,CAAC;YAED,MAAM,MAAM,GAAkB,EAAE,CAAC;YACjC,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC;YACtC,MAAM,aAAa,GAAG,YAAY,CAAC,WAAW,IAAI,EAAE,CAAC;YACrD,MAAM,UAAU,GAAG,YAAY,CAAC,aAAa,IAAI,EAAE,CAAC;YAEpD,0BAA0B;YAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC1C,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;gBACxC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC;gBAEjC,uBAAuB;gBACvB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,IAAI,GAAG,OAAO,CAAC,EAAE;oBAAE,SAAS;gBAEvD,MAAM,SAAS,GAAG,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBACxC,MAAM,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAElC,kDAAkD;gBAClD,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;gBAC1D,MAAM,MAAM,GAAG,KAAK,GAAG,aAAa,CAAC;gBACrC,MAAM,aAAa,GAAG,aAAa,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,aAAa,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBAE/E,MAAM,CAAC,IAAI,CAAC;oBACV,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE;oBACpC,KAAK,EAAE,KAAK;oBACZ,QAAQ,EAAE,KAAK;oBACf,MAAM,EAAE,MAAM;oBACd,aAAa,EAAE,aAAa;oBAC5B,aAAa,EAAE,aAAa;oBAC5B,SAAS,EAAE,IAAI;oBACf,QAAQ,EAAE,IAAI,CAAC,IAAI;oBACnB,WAAW,EAAE,SAAS,EAAE,iCAAiC;oBAEzD,0EAA0E;oBAC1E,MAAM,EAAE,MAAM;oBAEd,QAAQ,EAAE,KAAK;oBACf,SAAS,EAAE,IAAI,IAAI,EAAE;oBAErB,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;iBAC9D,CAAC,CAAC;YACL,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC,EAAE,yBAAyB,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,mBAAmB,CAAC,OAA8B;QAC9D,OAAO,IAAI,CAAC,uBAAuB,CAAC,KAAK,IAAI,EAAE;YAC7C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAExD,8DAA8D;YAC9D,oCAAoC;YACpC,IAAI,IAAI,GAAG,CAAC,CAAC;YACb,QAAQ,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACzB,KAAK,MAAM,CAAC;gBACZ,KAAK,MAAM,CAAC;gBACZ,KAAK,OAAO,CAAC;gBACb,KAAK,OAAO,CAAC;gBACb,KAAK,OAAO;oBACV,MAAM,IAAI,KAAK,CAAC,iFAAiF,CAAC,CAAC;gBACrG,KAAK,OAAO;oBACV,IAAI,GAAG,CAAC,CAAC,CAAC,wCAAwC;oBAClD,MAAM;YACV,CAAC;YAED,0EAA0E;YAC1E,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC;gBACjC,WAAW,EAAE,KAAK;gBAClB,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE;aACtB,CAAC,CAAC;YAEH,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,UAAU,MAAM,iBAAiB,MAAM,EAAE,CAAC;YAErE,2BAA2B;YAC3B,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;YAErC,eAAe;YACf,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE;iBAC9D,GAAG,CAAC,GAAG,CAAC;iBACR,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;iBAC5B,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,IAAI,KAAK,CAAC;iBACtC,GAAG,EAAE,CAAC;YAET,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAS,CAAC;YAElD,6BAA6B;YAC7B,IAAI,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,EAAE,CAAC;gBACxC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;gBACzD,MAAM,IAAI,cAAc,CACtB,oCAAoC,OAAO,CAAC,MAAM,EAAE,EACpD,QAAQ,CACT,CAAC;YACJ,CAAC;YAED,IAAI,CAAC,YAAY,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;gBAChE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,OAAO,CAAC,MAAM,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;gBACjH,MAAM,IAAI,KAAK,CAAC,+BAA+B,OAAO,CAAC,MAAM,KAAK,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;YACtH,CAAC;YAED,MAAM,MAAM,GAAkB,EAAE,CAAC;YACjC,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC;YACtC,MAAM,aAAa,GAAG,YAAY,CAAC,WAAW,IAAI,EAAE,CAAC;YACrD,MAAM,UAAU,GAAG,YAAY,CAAC,aAAa,IAAI,EAAE,CAAC;YAEpD,2BAA2B;YAC3B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,SAAS,CAAC,MAAM,CAAC;YAChD,MAAM,aAAa,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;YAE9C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC9C,MAAM,WAAW,GAAG,SAAS,CAAC,MAAM,GAAG,KAAK,GAAG,CAAC,CAAC;gBACjD,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;gBAC5C,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC;gBAEjC,MAAM,SAAS,GAAG,aAAa,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAClD,MAAM,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAE5C,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;gBAC9D,MAAM,MAAM,GAAG,KAAK,GAAG,aAAa,CAAC;gBACrC,MAAM,aAAa,GAAG,aAAa,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,aAAa,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBAE/E,MAAM,CAAC,IAAI,CAAC;oBACV,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE;oBACpC,KAAK,EAAE,KAAK;oBACZ,QAAQ,EAAE,KAAK;oBACf,MAAM,EAAE,MAAM;oBACd,aAAa,EAAE,aAAa;oBAC5B,aAAa,EAAE,aAAa;oBAC5B,SAAS,EAAE,IAAI;oBACf,QAAQ,EAAE,IAAI,CAAC,IAAI;oBACnB,WAAW,EAAE,SAAS;oBAEtB,MAAM,EAAE,MAAM;oBAEd,QAAQ,EAAE,UAAU;oBACpB,SAAS,EAAE,IAAI,IAAI,EAAE;oBAErB,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;iBAC9D,CAAC,CAAC;YACL,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC,EAAE,uBAAuB,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,WAAW;QACtB,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,6CAA6C,CAAC;YAEzE,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;YAErC,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE;iBAC9D,GAAG,CAAC,GAAG,CAAC;iBACR,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;iBAC5B,OAAO,CAAC,IAAI,CAAC;iBACb,GAAG,EAAE,CAAC;YAET,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAS,CAAC;YAClD,OAAO,YAAY,CAAC,OAAO,EAAE,GAAG,KAAK,SAAS,CAAC;QACjD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAC;YAChE,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,cAAc,CAAC,MAAc;QAClC,kDAAkD;QAClD,MAAM,iBAAiB,GAAG;YACxB,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW;YACrD,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM;SACzC,CAAC;QACF,OAAO,iBAAiB,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACI,cAAc,CAAC,MAAc;QAClC,yEAAyE;QACzE,OAAO,uBAAuB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,aAAa,CAAC,UAAkB;QAC5C,MAAM,UAAU,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;QAE5C,gDAAgD;QAChD,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;YAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAE,CAAC;YACvD,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;YAC1C,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,cAAc;QACd,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;YACtC,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAE,CAAC;QAC5C,CAAC;QAED,uGAAuG;QACvG,IAAI,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,UAAU,KAAK,UAAU,EAAE,CAAC;YAC1D,uCAAuC;YACvC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;YAC9C,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,2BAA2B;QAC3B,IAAI,CAAC,IAAI,CAAC,gBAAgB;YACtB,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACzE,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;QAC5B,CAAC;QAED,qCAAqC;QACrC,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;YACtC,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAE,CAAC;QAC5C,CAAC;QAED,wDAAwD;QACxD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,4BAA4B,UAAU,+BAA+B,CAAC,CAAC;QACxF,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY;QACxB,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC;YAEzC,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;YAErC,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE;iBAC9D,GAAG,CAAC,GAAG,CAAC;iBACR,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;iBAC5B,OAAO,CAAC,KAAK,CAAC;iBACd,GAAG,EAAE,CAAC;YAET,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAqB,CAAC;YAE1D,8BAA8B;YAC9B,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;gBAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;gBACzC,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC;gBAEjC,8DAA8D;gBAC9D,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;oBAC1E,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;gBACpC,CAAC;gBACD,8BAA8B;gBAC9B,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YAChC,CAAC;YAED,IAAI,CAAC,gBAAgB,GAAG,IAAI,IAAI,EAAE,CAAC;YACnC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,QAAQ,CAAC,MAAM,uBAAuB,CAAC,CAAC;QACrE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,0CAA0C,EAAE,KAAK,CAAC,CAAC;YACrE,kDAAkD;QACpD,CAAC;IACH,CAAC;IAED;;OAEG;IACK,eAAe,CACrB,MAAc,EACd,MAAc,EACd,IAAS,EACT,QAAqC;QAErC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC;QACvB,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,IAAI,CAAC,CAAC;QAE3C,2CAA2C;QAC3C,MAAM,aAAa,GAAG,SAAS,CAAC;QAChC,MAAM,MAAM,GAAG,CAAC,KAAK,GAAG,aAAa,CAAC,GAAG,GAAG,CAAC;QAC7C,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,CAAC;QAErC,+BAA+B;QAC/B,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe;YACpC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;YACvC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC;QAEf,OAAO;YACL,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE;YAC5B,KAAK,EAAE,KAAK;YACZ,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,MAAM;YACd,aAAa,EAAE,aAAa;YAC5B,aAAa,EAAE,aAAa;YAC5B,SAAS,EAAE,SAAS;YACpB,QAAQ,EAAE,IAAI,CAAC,IAAI;YACnB,WAAW,EAAE,SAAS,EAAE,0BAA0B;YAElD,wBAAwB;YACxB,MAAM,EAAE,IAAI,CAAC,WAAW;YAExB,QAAQ,EAAE,QAAQ;YAClB,SAAS,EAAE,IAAI,IAAI,EAAE;YAErB,yCAAyC;YACzC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YAC7D,eAAe,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,WAAW,EAAE,GAAG;SACjG,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,YAAY;QAClB,MAAM,OAAO,GAA2B;YACtC,QAAQ,EAAE,kBAAkB;SAC7B,CAAC;QAEF,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,iCAAiC;YACjC,gEAAgE;YAChE,OAAO,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QAC7C,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACK,gBAAgB,CAAC,YAAiB;QACxC,OAAO,YAAY,EAAE,MAAM,EAAE,UAAU,KAAK,GAAG,CAAC;IAClD,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,uBAAuB,CACnC,OAAyB,EACzB,aAAqB,EACrB,aAAqB,CAAC;QAEtB,IAAI,SAA4B,CAAC;QAEjC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC;YACtD,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,OAAO,EAAE,CAAC;gBAC/B,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;gBAC/B,OAAO,MAAM,CAAC;YAChB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,SAAS,GAAG,KAAc,CAAC;gBAE3B,IAAI,KAAK,YAAY,cAAc,EAAE,CAAC;oBACpC,MAAM,WAAW,GAAG,GAAG,OAAO,GAAG,CAAC,IAAI,UAAU,EAAE,CAAC;oBACnD,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,sBAAsB,aAAa,aAAa,KAAK,CAAC,QAAQ,mBAAmB,WAAW,EAAE,CAC/F,CAAC;oBAEF,IAAI,OAAO,GAAG,UAAU,GAAG,CAAC,EAAE,CAAC;wBAC7B,MAAM,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;wBAClD,SAAS;oBACX,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,UAAU,kBAAkB,aAAa,uBAAuB,CAAC,CAAC;wBACpG,MAAM,KAAK,CAAC;oBACd,CAAC;gBACH,CAAC;gBAED,2CAA2C;gBAC3C,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QAED,MAAM,SAAU,CAAC;IACnB,CAAC;CACF"}