@push.rocks/smartproxy/dist_ts/proxies/smart-proxy/connection-manager.js

A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.

import * as plugins from '../../plugins.js';
import { logger } from '../../core/utils/logger.js';
import { connectionLogDeduplicator } from '../../core/utils/log-deduplicator.js';
import { LifecycleComponent } from '../../core/utils/lifecycle-component.js';
import { cleanupSocket } from '../../core/utils/socket-utils.js';
import { WrappedSocket } from '../../core/models/wrapped-socket.js';
import { ProtocolDetector } from '../../detection/index.js';
/**
 * Manages connection lifecycle, tracking, and cleanup with performance optimizations
 */
export class ConnectionManager extends LifecycleComponent {
    constructor(smartProxy) {
        super();
        this.smartProxy = smartProxy;
        this.connectionRecords = new Map();
        this.terminationStats = { incoming: {}, outgoing: {} };
        // Performance optimization: Track connections needing inactivity check
        this.nextInactivityCheck = new Map();
        this.cleanupBatchSize = 100;
        // Cleanup queue for batched processing
        this.cleanupQueue = new Set();
        this.cleanupTimer = null;
        this.isProcessingCleanup = false;
        // Route-level connection tracking
        this.connectionsByRoute = new Map();
        // Set reasonable defaults for connection limits
        this.maxConnections = smartProxy.settings.defaults?.security?.maxConnections || 10000;
        // Start inactivity check timer if not disabled
        if (!smartProxy.settings.disableInactivityCheck) {
            this.startInactivityCheckTimer();
        }
    }
    /**
     * Generate a unique connection ID
     */
    generateConnectionId() {
        return Math.random().toString(36).substring(2, 15) +
            Math.random().toString(36).substring(2, 15);
    }
    /**
     * Create and track a new connection
     * Accepts either a regular net.Socket or a WrappedSocket for transparent PROXY protocol support
     */
    createConnection(socket) {
        // Enforce connection limit
        if (this.connectionRecords.size >= this.maxConnections) {
            // Use deduplicated logging for connection limit
            connectionLogDeduplicator.log('connection-rejected', 'warn', 'Global connection limit reached', {
                reason: 'global-limit',
                currentConnections: this.connectionRecords.size,
                maxConnections: this.maxConnections,
                component: 'connection-manager'
            }, 'global-limit');
            socket.destroy();
            return null;
        }
        const connectionId = this.generateConnectionId();
        const remoteIP = socket.remoteAddress || '';
        const remotePort = socket.remotePort || 0;
        const localPort = socket.localPort || 0;
        const now = Date.now();
        const record = {
            id: connectionId,
            incoming: socket,
            outgoing: null,
            incomingStartTime: now,
            lastActivity: now,
            connectionClosed: false,
            pendingData: [],
            pendingDataSize: 0,
            bytesReceived: 0,
            bytesSent: 0,
            remoteIP,
            remotePort,
            localPort,
            isTLS: false,
            tlsHandshakeComplete: false,
            hasReceivedInitialData: false,
            hasKeepAlive: false,
            incomingTerminationReason: null,
            outgoingTerminationReason: null,
            usingNetworkProxy: false,
            isBrowserConnection: false,
            domainSwitches: 0
        };
        this.trackConnection(connectionId, record);
        return record;
    }
    /**
     * Track an existing connection
     */
    trackConnection(connectionId, record) {
        this.connectionRecords.set(connectionId, record);
        this.smartProxy.securityManager.trackConnectionByIP(record.remoteIP, connectionId);
        // Schedule inactivity check
        if (!this.smartProxy.settings.disableInactivityCheck) {
            this.scheduleInactivityCheck(connectionId, record);
        }
    }
    /**
     * Schedule next inactivity check for a connection
     */
    scheduleInactivityCheck(connectionId, record) {
        let timeout = this.smartProxy.settings.inactivityTimeout;
        if (record.hasKeepAlive) {
            if (this.smartProxy.settings.keepAliveTreatment === 'immortal') {
                // Don't schedule check for immortal connections
                return;
            }
            else if (this.smartProxy.settings.keepAliveTreatment === 'extended') {
                const multiplier = this.smartProxy.settings.keepAliveInactivityMultiplier || 6;
                timeout = timeout * multiplier;
            }
        }
        const checkTime = Date.now() + timeout;
        this.nextInactivityCheck.set(connectionId, checkTime);
    }
    /**
     * Start the inactivity check timer
     */
    startInactivityCheckTimer() {
        // Check more frequently (every 10 seconds) to catch zombies and stuck connections faster
        this.setInterval(() => {
            this.performOptimizedInactivityCheck();
        }, 10000);
        // Note: LifecycleComponent's setInterval already calls unref()
    }
    /**
     * Get a connection by ID
     */
    getConnection(connectionId) {
        return this.connectionRecords.get(connectionId);
    }
    /**
     * Get all active connections
     */
    getConnections() {
        return this.connectionRecords;
    }
    /**
     * Get count of active connections
     */
    getConnectionCount() {
        return this.connectionRecords.size;
    }
    /**
     * Track connection by route
     */
    trackConnectionByRoute(routeId, connectionId) {
        if (!this.connectionsByRoute.has(routeId)) {
            this.connectionsByRoute.set(routeId, new Set());
        }
        this.connectionsByRoute.get(routeId).add(connectionId);
    }
    /**
     * Remove connection tracking for a route
     */
    removeConnectionByRoute(routeId, connectionId) {
        if (this.connectionsByRoute.has(routeId)) {
            const connections = this.connectionsByRoute.get(routeId);
            connections.delete(connectionId);
            if (connections.size === 0) {
                this.connectionsByRoute.delete(routeId);
            }
        }
    }
    /**
     * Get connection count by route
     */
    getConnectionCountByRoute(routeId) {
        return this.connectionsByRoute.get(routeId)?.size || 0;
    }
    /**
     * Initiates cleanup once for a connection
     */
    initiateCleanupOnce(record, reason = 'normal') {
        // Use deduplicated logging for cleanup events
        connectionLogDeduplicator.log('connection-cleanup', 'info', `Connection cleanup: ${reason}`, {
            connectionId: record.id,
            remoteIP: record.remoteIP,
            reason,
            component: 'connection-manager'
        }, reason);
        if (record.incomingTerminationReason == null) {
            record.incomingTerminationReason = reason;
            this.incrementTerminationStat('incoming', reason);
        }
        // Add to cleanup queue for batched processing
        this.queueCleanup(record.id);
    }
    /**
     * Queue a connection for cleanup
     */
    queueCleanup(connectionId) {
        // Check if connection is already being processed
        const record = this.connectionRecords.get(connectionId);
        if (!record || record.connectionClosed) {
            // Already cleaned up or doesn't exist, skip
            return;
        }
        this.cleanupQueue.add(connectionId);
        // Process immediately if queue is getting large and not already processing
        if (this.cleanupQueue.size >= this.cleanupBatchSize && !this.isProcessingCleanup) {
            this.processCleanupQueue();
        }
        else if (!this.cleanupTimer && !this.isProcessingCleanup) {
            // Otherwise, schedule batch processing
            this.cleanupTimer = this.setTimeout(() => {
                this.processCleanupQueue();
            }, 100);
        }
    }
    /**
     * Process the cleanup queue in batches
     */
    processCleanupQueue() {
        // Prevent concurrent processing
        if (this.isProcessingCleanup) {
            return;
        }
        this.isProcessingCleanup = true;
        if (this.cleanupTimer) {
            this.clearTimeout(this.cleanupTimer);
            this.cleanupTimer = null;
        }
        try {
            // Take a snapshot of items to process
            const toCleanup = Array.from(this.cleanupQueue).slice(0, this.cleanupBatchSize);
            // Remove only the items we're processing from the queue
            for (const connectionId of toCleanup) {
                this.cleanupQueue.delete(connectionId);
                const record = this.connectionRecords.get(connectionId);
                if (record) {
                    this.cleanupConnection(record, record.incomingTerminationReason || 'normal');
                }
            }
        }
        finally {
            // Always reset the processing flag
            this.isProcessingCleanup = false;
            // Check if more items were added while we were processing
            if (this.cleanupQueue.size > 0) {
                this.cleanupTimer = this.setTimeout(() => {
                    this.processCleanupQueue();
                }, 10);
            }
        }
    }
    /**
     * Clean up a connection record
     */
    cleanupConnection(record, reason = 'normal') {
        if (!record.connectionClosed) {
            record.connectionClosed = true;
            // Remove from inactivity check
            this.nextInactivityCheck.delete(record.id);
            // Track connection termination
            this.smartProxy.securityManager.removeConnectionByIP(record.remoteIP, record.id);
            // Remove from route tracking
            if (record.routeId) {
                this.removeConnectionByRoute(record.routeId, record.id);
            }
            // Remove from metrics tracking
            if (this.smartProxy.metricsCollector) {
                this.smartProxy.metricsCollector.removeConnection(record.id);
            }
            // Clean up protocol detection fragments
            const context = ProtocolDetector.createConnectionContext({
                sourceIp: record.remoteIP,
                sourcePort: record.incoming?.remotePort || 0,
                destIp: record.incoming?.localAddress || '',
                destPort: record.localPort,
                socketId: record.id
            });
            // Clean up any pending detection fragments for this connection
            ProtocolDetector.cleanupConnection(context);
            if (record.cleanupTimer) {
                clearTimeout(record.cleanupTimer);
                record.cleanupTimer = undefined;
            }
            // Calculate metrics once
            const duration = Date.now() - record.incomingStartTime;
            const logData = {
                connectionId: record.id,
                remoteIP: record.remoteIP,
                localPort: record.localPort,
                reason,
                duration: plugins.prettyMs(duration),
                bytes: { in: record.bytesReceived, out: record.bytesSent },
                tls: record.isTLS,
                keepAlive: record.hasKeepAlive,
                usingNetworkProxy: record.usingNetworkProxy,
                domainSwitches: record.domainSwitches || 0,
                component: 'connection-manager'
            };
            // Remove all data handlers to make sure we clean up properly
            if (record.incoming) {
                try {
                    record.incoming.removeAllListeners('data');
                    record.renegotiationHandler = undefined;
                }
                catch (err) {
                    logger.log('error', `Error removing data handlers: ${err}`, {
                        connectionId: record.id,
                        error: err,
                        component: 'connection-manager'
                    });
                }
            }
            // Handle socket cleanup - check if sockets are still active
            const cleanupPromises = [];
            if (record.incoming) {
                // Extract underlying socket if it's a WrappedSocket
                const incomingSocket = record.incoming instanceof WrappedSocket ? record.incoming.socket : record.incoming;
                if (!record.incoming.writable || record.incoming.destroyed) {
                    // Socket is not active, clean up immediately
                    cleanupPromises.push(cleanupSocket(incomingSocket, `${record.id}-incoming`, { immediate: true }));
                }
                else {
                    // Socket is still active, allow graceful cleanup
                    cleanupPromises.push(cleanupSocket(incomingSocket, `${record.id}-incoming`, { allowDrain: true, gracePeriod: 5000 }));
                }
            }
            if (record.outgoing) {
                // Extract underlying socket if it's a WrappedSocket
                const outgoingSocket = record.outgoing instanceof WrappedSocket ? record.outgoing.socket : record.outgoing;
                if (!record.outgoing.writable || record.outgoing.destroyed) {
                    // Socket is not active, clean up immediately
                    cleanupPromises.push(cleanupSocket(outgoingSocket, `${record.id}-outgoing`, { immediate: true }));
                }
                else {
                    // Socket is still active, allow graceful cleanup
                    cleanupPromises.push(cleanupSocket(outgoingSocket, `${record.id}-outgoing`, { allowDrain: true, gracePeriod: 5000 }));
                }
            }
            // Wait for cleanup to complete
            Promise.all(cleanupPromises).catch(err => {
                logger.log('error', `Error during socket cleanup: ${err}`, {
                    connectionId: record.id,
                    error: err,
                    component: 'connection-manager'
                });
            });
            // Clear pendingData to avoid memory leaks
            record.pendingData = [];
            record.pendingDataSize = 0;
            // Remove the record from the tracking map
            this.connectionRecords.delete(record.id);
            // Use deduplicated logging for connection termination
            if (this.smartProxy.settings.enableDetailedLogging) {
                // For detailed logging, include more info but still deduplicate by IP+reason
                connectionLogDeduplicator.log('connection-terminated', 'info', `Connection terminated: ${record.remoteIP}:${record.localPort}`, {
                    ...logData,
                    duration_ms: duration,
                    bytesIn: record.bytesReceived,
                    bytesOut: record.bytesSent
                }, `${record.remoteIP}-${reason}`);
            }
            else {
                // For normal logging, deduplicate by termination reason
                connectionLogDeduplicator.log('connection-terminated', 'info', `Connection terminated`, {
                    remoteIP: record.remoteIP,
                    reason,
                    activeConnections: this.connectionRecords.size,
                    component: 'connection-manager'
                }, reason // Group by termination reason
                );
            }
        }
    }
    /**
     * Creates a generic error handler for incoming or outgoing sockets
     */
    handleError(side, record) {
        return (err) => {
            const code = err.code;
            let reason = 'error';
            const now = Date.now();
            const connectionDuration = now - record.incomingStartTime;
            const lastActivityAge = now - record.lastActivity;
            // Update activity tracking
            if (side === 'incoming') {
                record.lastActivity = now;
                this.scheduleInactivityCheck(record.id, record);
            }
            const errorData = {
                connectionId: record.id,
                side,
                remoteIP: record.remoteIP,
                error: err.message,
                duration: plugins.prettyMs(connectionDuration),
                lastActivity: plugins.prettyMs(lastActivityAge),
                component: 'connection-manager'
            };
            switch (code) {
                case 'ECONNRESET':
                    reason = 'econnreset';
                    logger.log('warn', `ECONNRESET on ${side}: ${record.remoteIP}`, errorData);
                    break;
                case 'ETIMEDOUT':
                    reason = 'etimedout';
                    logger.log('warn', `ETIMEDOUT on ${side}: ${record.remoteIP}`, errorData);
                    break;
                default:
                    logger.log('error', `Error on ${side}: ${record.remoteIP} - ${err.message}`, errorData);
            }
            if (side === 'incoming' && record.incomingTerminationReason == null) {
                record.incomingTerminationReason = reason;
                this.incrementTerminationStat('incoming', reason);
            }
            else if (side === 'outgoing' && record.outgoingTerminationReason == null) {
                record.outgoingTerminationReason = reason;
                this.incrementTerminationStat('outgoing', reason);
            }
            this.initiateCleanupOnce(record, reason);
        };
    }
    /**
     * Creates a generic close handler for incoming or outgoing sockets
     */
    handleClose(side, record) {
        return () => {
            if (this.smartProxy.settings.enableDetailedLogging) {
                logger.log('info', `Connection closed on ${side} side`, {
                    connectionId: record.id,
                    side,
                    remoteIP: record.remoteIP,
                    component: 'connection-manager'
                });
            }
            if (side === 'incoming' && record.incomingTerminationReason == null) {
                record.incomingTerminationReason = 'normal';
                this.incrementTerminationStat('incoming', 'normal');
            }
            else if (side === 'outgoing' && record.outgoingTerminationReason == null) {
                record.outgoingTerminationReason = 'normal';
                this.incrementTerminationStat('outgoing', 'normal');
                record.outgoingClosedTime = Date.now();
            }
            this.initiateCleanupOnce(record, 'closed_' + side);
        };
    }
    /**
     * Increment termination statistics
     */
    incrementTerminationStat(side, reason) {
        this.terminationStats[side][reason] = (this.terminationStats[side][reason] || 0) + 1;
    }
    /**
     * Get termination statistics
     */
    getTerminationStats() {
        return this.terminationStats;
    }
    /**
     * Optimized inactivity check - only checks connections that are due
     */
    performOptimizedInactivityCheck() {
        const now = Date.now();
        const connectionsToCheck = [];
        // Find connections that need checking
        for (const [connectionId, checkTime] of this.nextInactivityCheck) {
            if (checkTime <= now) {
                connectionsToCheck.push(connectionId);
            }
        }
        // Also check ALL connections for zombie state (destroyed sockets but not cleaned up)
        // This is critical for proxy chains where sockets can be destroyed without events
        for (const [connectionId, record] of this.connectionRecords) {
            if (!record.connectionClosed) {
                const incomingDestroyed = record.incoming?.destroyed || false;
                const outgoingDestroyed = record.outgoing?.destroyed || false;
                // Check for zombie connections: both sockets destroyed but connection not cleaned up
                if (incomingDestroyed && outgoingDestroyed) {
                    logger.log('warn', `Zombie connection detected: ${connectionId} - both sockets destroyed but not cleaned up`, {
                        connectionId,
                        remoteIP: record.remoteIP,
                        age: plugins.prettyMs(now - record.incomingStartTime),
                        component: 'connection-manager'
                    });
                    // Clean up immediately
                    this.cleanupConnection(record, 'zombie_cleanup');
                    continue;
                }
                // Check for half-zombie: one socket destroyed
                if (incomingDestroyed || outgoingDestroyed) {
                    const age = now - record.incomingStartTime;
                    // Use longer grace period for encrypted connections (5 minutes vs 30 seconds)
                    const gracePeriod = record.isTLS ? 300000 : 30000;
                    // Also ensure connection is old enough to avoid premature cleanup
                    if (age > gracePeriod && age > 10000) {
                        logger.log('warn', `Half-zombie connection detected: ${connectionId} - ${incomingDestroyed ? 'incoming' : 'outgoing'} destroyed`, {
                            connectionId,
                            remoteIP: record.remoteIP,
                            age: plugins.prettyMs(age),
                            incomingDestroyed,
                            outgoingDestroyed,
                            isTLS: record.isTLS,
                            gracePeriod: plugins.prettyMs(gracePeriod),
                            component: 'connection-manager'
                        });
                        // Clean up
                        this.cleanupConnection(record, 'half_zombie_cleanup');
                    }
                }
                // Check for stuck connections: no data sent back to client
                if (!record.connectionClosed && record.outgoing && record.bytesReceived > 0 && record.bytesSent === 0) {
                    const age = now - record.incomingStartTime;
                    // Use longer grace period for encrypted connections (5 minutes vs 60 seconds)
                    const stuckThreshold = record.isTLS ? 300000 : 60000;
                    // If connection is older than threshold and no data sent back, likely stuck
                    if (age > stuckThreshold) {
                        logger.log('warn', `Stuck connection detected: ${connectionId} - received ${record.bytesReceived} bytes but sent 0 bytes`, {
                            connectionId,
                            remoteIP: record.remoteIP,
                            age: plugins.prettyMs(age),
                            bytesReceived: record.bytesReceived,
                            targetHost: record.targetHost,
                            targetPort: record.targetPort,
                            isTLS: record.isTLS,
                            threshold: plugins.prettyMs(stuckThreshold),
                            component: 'connection-manager'
                        });
                        // Set termination reason and increment stats
                        if (record.incomingTerminationReason == null) {
                            record.incomingTerminationReason = 'stuck_no_response';
                            this.incrementTerminationStat('incoming', 'stuck_no_response');
                        }
                        // Clean up
                        this.cleanupConnection(record, 'stuck_no_response');
                    }
                }
            }
        }
        // Process only connections that need checking
        for (const connectionId of connectionsToCheck) {
            const record = this.connectionRecords.get(connectionId);
            if (!record || record.connectionClosed) {
                this.nextInactivityCheck.delete(connectionId);
                continue;
            }
            const inactivityTime = now - record.lastActivity;
            // Use extended timeout for extended-treatment keep-alive connections
            let effectiveTimeout = this.smartProxy.settings.inactivityTimeout;
            if (record.hasKeepAlive && this.smartProxy.settings.keepAliveTreatment === 'extended') {
                const multiplier = this.smartProxy.settings.keepAliveInactivityMultiplier || 6;
                effectiveTimeout = effectiveTimeout * multiplier;
            }
            if (inactivityTime > effectiveTimeout) {
                // For keep-alive connections, issue a warning first
                if (record.hasKeepAlive && !record.inactivityWarningIssued) {
                    logger.log('warn', `Keep-alive connection inactive: ${record.remoteIP}`, {
                        connectionId,
                        remoteIP: record.remoteIP,
                        inactiveFor: plugins.prettyMs(inactivityTime),
                        component: 'connection-manager'
                    });
                    record.inactivityWarningIssued = true;
                    // Reschedule check for 10 minutes later
                    this.nextInactivityCheck.set(connectionId, now + 600000);
                    // Try to stimulate activity with a probe packet
                    if (record.outgoing && !record.outgoing.destroyed) {
                        try {
                            record.outgoing.write(Buffer.alloc(0));
                        }
                        catch (err) {
                            logger.log('error', `Error sending probe packet: ${err}`, {
                                connectionId,
                                error: err,
                                component: 'connection-manager'
                            });
                        }
                    }
                }
                else {
                    // Close the connection
                    logger.log('warn', `Closing inactive connection: ${record.remoteIP}`, {
                        connectionId,
                        remoteIP: record.remoteIP,
                        inactiveFor: plugins.prettyMs(inactivityTime),
                        hasKeepAlive: record.hasKeepAlive,
                        component: 'connection-manager'
                    });
                    this.cleanupConnection(record, 'inactivity');
                }
            }
            else {
                // Reschedule next check
                this.scheduleInactivityCheck(connectionId, record);
            }
            // Parity check: if outgoing socket closed and incoming remains active
            // Increased from 2 minutes to 30 minutes for long-lived connections
            if (record.outgoingClosedTime &&
                !record.incoming.destroyed &&
                !record.connectionClosed &&
                now - record.outgoingClosedTime > 1800000 // 30 minutes
            ) {
                // Only close if no data activity for 10 minutes
                if (now - record.lastActivity > 600000) {
                    logger.log('warn', `Parity check failed after extended timeout: ${record.remoteIP}`, {
                        connectionId,
                        remoteIP: record.remoteIP,
                        timeElapsed: plugins.prettyMs(now - record.outgoingClosedTime),
                        inactiveFor: plugins.prettyMs(now - record.lastActivity),
                        component: 'connection-manager'
                    });
                    this.cleanupConnection(record, 'parity_check');
                }
            }
        }
    }
    /**
     * Legacy method for backward compatibility
     */
    performInactivityCheck() {
        this.performOptimizedInactivityCheck();
    }
    /**
     * Clear all connections (for shutdown)
     */
    async clearConnections() {
        // Delegate to LifecycleComponent's cleanup
        await this.cleanup();
    }
    /**
     * Override LifecycleComponent's onCleanup method
     */
    async onCleanup() {
        // Process connections in batches to avoid blocking
        const connections = Array.from(this.connectionRecords.values());
        const batchSize = 100;
        let index = 0;
        const processBatch = () => {
            const batch = connections.slice(index, index + batchSize);
            for (const record of batch) {
                try {
                    if (record.cleanupTimer) {
                        clearTimeout(record.cleanupTimer);
                        record.cleanupTimer = undefined;
                    }
                    // Immediate destruction using socket-utils
                    const shutdownPromises = [];
                    if (record.incoming) {
                        const incomingSocket = record.incoming instanceof WrappedSocket ? record.incoming.socket : record.incoming;
                        shutdownPromises.push(cleanupSocket(incomingSocket, `${record.id}-incoming-shutdown`, { immediate: true }));
                    }
                    if (record.outgoing) {
                        const outgoingSocket = record.outgoing instanceof WrappedSocket ? record.outgoing.socket : record.outgoing;
                        shutdownPromises.push(cleanupSocket(outgoingSocket, `${record.id}-outgoing-shutdown`, { immediate: true }));
                    }
                    // Don't wait for shutdown cleanup in this batch processing
                    Promise.all(shutdownPromises).catch(() => { });
                }
                catch (err) {
                    logger.log('error', `Error during connection cleanup: ${err}`, {
                        connectionId: record.id,
                        error: err,
                        component: 'connection-manager'
                    });
                }
            }
            index += batchSize;
            // Continue with next batch if needed
            if (index < connections.length) {
                setImmediate(processBatch);
            }
            else {
                // Clear all maps
                this.connectionRecords.clear();
                this.nextInactivityCheck.clear();
                this.cleanupQueue.clear();
                this.terminationStats = { incoming: {}, outgoing: {} };
            }
        };
        // Start batch processing
        setImmediate(processBatch);
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connection-manager.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/connection-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;GAEG;AACH,MAAM,OAAO,iBAAkB,SAAQ,kBAAkB;IAsBvD,YACU,UAAsB;QAE9B,KAAK,EAAE,CAAC;QAFA,eAAU,GAAV,UAAU,CAAY;QAtBxB,sBAAiB,GAAmC,IAAI,GAAG,EAAE,CAAC;QAC9D,qBAAgB,GAGpB,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;QAEnC,uEAAuE;QAC/D,wBAAmB,GAAwB,IAAI,GAAG,EAAE,CAAC;QAI5C,qBAAgB,GAAW,GAAG,CAAC;QAEhD,uCAAuC;QAC/B,iBAAY,GAAgB,IAAI,GAAG,EAAE,CAAC;QACtC,iBAAY,GAA0B,IAAI,CAAC;QAC3C,wBAAmB,GAAY,KAAK,CAAC;QAE7C,kCAAkC;QAC1B,uBAAkB,GAA6B,IAAI,GAAG,EAAE,CAAC;QAO/D,gDAAgD;QAChD,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,cAAc,IAAI,KAAK,CAAC;QAEtF,+CAA+C;QAC/C,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,sBAAsB,EAAE,CAAC;YAChD,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACnC,CAAC;IACH,CAAC;IAED;;OAEG;IACI,oBAAoB;QACzB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC;YAC3C,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACI,gBAAgB,CAAC,MAA0C;QAChE,2BAA2B;QAC3B,IAAI,IAAI,CAAC,iBAAiB,CAAC,IAAI,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACvD,gDAAgD;YAChD,yBAAyB,CAAC,GAAG,CAC3B,qBAAqB,EACrB,MAAM,EACN,iCAAiC,EACjC;gBACE,MAAM,EAAE,cAAc;gBACtB,kBAAkB,EAAE,IAAI,CAAC,iBAAiB,CAAC,IAAI;gBAC/C,cAAc,EAAE,IAAI,CAAC,cAAc;gBACnC,SAAS,EAAE,oBAAoB;aAChC,EACD,cAAc,CACf,CAAC;YACF,MAAM,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,YAAY,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACjD,MAAM,QAAQ,GAAG,MAAM,CAAC,aAAa,IAAI,EAAE,CAAC;QAC5C,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,CAAC,CAAC;QAC1C,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,CAAC,CAAC;QACxC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,MAAM,MAAM,GAAsB;YAChC,EAAE,EAAE,YAAY;YAChB,QAAQ,EAAE,MAAM;YAChB,QAAQ,EAAE,IAAI;YACd,iBAAiB,EAAE,GAAG;YACtB,YAAY,EAAE,GAAG;YACjB,gBAAgB,EAAE,KAAK;YACvB,WAAW,EAAE,EAAE;YACf,eAAe,EAAE,CAAC;YAClB,aAAa,EAAE,CAAC;YAChB,SAAS,EAAE,CAAC;YACZ,QAAQ;YACR,UAAU;YACV,SAAS;YACT,KAAK,EAAE,KAAK;YACZ,oBAAoB,EAAE,KAAK;YAC3B,sBAAsB,EAAE,KAAK;YAC7B,YAAY,EAAE,KAAK;YACnB,yBAAyB,EAAE,IAAI;YAC/B,yBAAyB,EAAE,IAAI;YAC/B,iBAAiB,EAAE,KAAK;YACxB,mBAAmB,EAAE,KAAK;YAC1B,cAAc,EAAE,CAAC;SAClB,CAAC;QAEF,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAC3C,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACI,eAAe,CAAC,YAAoB,EAAE,MAAyB;QACpE,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QACjD,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,mBAAmB,CAAC,MAAM,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAEnF,4BAA4B;QAC5B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,sBAAsB,EAAE,CAAC;YACrD,IAAI,CAAC,uBAAuB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAED;;OAEG;IACK,uBAAuB,CAAC,YAAoB,EAAE,MAAyB;QAC7E,IAAI,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,iBAAkB,CAAC;QAE1D,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;YACxB,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,kBAAkB,KAAK,UAAU,EAAE,CAAC;gBAC/D,gDAAgD;gBAChD,OAAO;YACT,CAAC;iBAAM,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,kBAAkB,KAAK,UAAU,EAAE,CAAC;gBACtE,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,6BAA6B,IAAI,CAAC,CAAC;gBAC/E,OAAO,GAAG,OAAO,GAAG,UAAU,CAAC;YACjC,CAAC;QACH,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC;QACvC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;IACxD,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,yFAAyF;QACzF,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE;YACpB,IAAI,CAAC,+BAA+B,EAAE,CAAC;QACzC,CAAC,EAAE,KAAK,CAAC,CAAC;QACV,+DAA+D;IACjE,CAAC;IAED;;OAEG;IACI,aAAa,CAAC,YAAoB;QACvC,OAAO,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACI,cAAc;QACnB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,kBAAkB;QACvB,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC;IACrC,CAAC;IAED;;OAEG;IACI,sBAAsB,CAAC,OAAe,EAAE,YAAoB;QACjE,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QAClD,CAAC;QACD,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAE,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAC1D,CAAC;IAED;;OAEG;IACI,uBAAuB,CAAC,OAAe,EAAE,YAAoB;QAClE,IAAI,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YACzC,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAE,CAAC;YAC1D,WAAW,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YACjC,IAAI,WAAW,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;gBAC3B,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC1C,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACI,yBAAyB,CAAC,OAAe;QAC9C,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC;IACzD,CAAC;IAED;;OAEG;IACI,mBAAmB,CAAC,MAAyB,EAAE,SAAiB,QAAQ;QAC7E,8CAA8C;QAC9C,yBAAyB,CAAC,GAAG,CAC3B,oBAAoB,EACpB,MAAM,EACN,uBAAuB,MAAM,EAAE,EAC/B;YACE,YAAY,EAAE,MAAM,CAAC,EAAE;YACvB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,MAAM;YACN,SAAS,EAAE,oBAAoB;SAChC,EACD,MAAM,CACP,CAAC;QAEF,IAAI,MAAM,CAAC,yBAAyB,IAAI,IAAI,EAAE,CAAC;YAC7C,MAAM,CAAC,yBAAyB,GAAG,MAAM,CAAC;YAC1C,IAAI,CAAC,wBAAwB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QACpD,CAAC;QAED,8CAA8C;QAC9C,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED;;OAEG;IACK,YAAY,CAAC,YAAoB;QACvC,iDAAiD;QACjD,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,gBAAgB,EAAE,CAAC;YACvC,4CAA4C;YAC5C,OAAO;QACT,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAEpC,2EAA2E;QAC3E,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,IAAI,IAAI,CAAC,gBAAgB,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC;YACjF,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7B,CAAC;aAAM,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3D,uCAAuC;YACvC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE;gBACvC,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC7B,CAAC,EAAE,GAAG,CAAC,CAAC;QACV,CAAC;IACH,CAAC;IAED;;OAEG;IACK,mBAAmB;QACzB,gCAAgC;QAChC,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC7B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAEhC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACrC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAC3B,CAAC;QAED,IAAI,CAAC;YACH,sCAAsC;YACtC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;YAEhF,wDAAwD;YACxD,KAAK,MAAM,YAAY,IAAI,SAAS,EAAE,CAAC;gBACrC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;gBACvC,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;gBACxD,IAAI,MAAM,EAAE,CAAC;oBACX,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,yBAAyB,IAAI,QAAQ,CAAC,CAAC;gBAC/E,CAAC;YACH,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,mCAAmC;YACnC,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;YAEjC,0DAA0D;YAC1D,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;gBAC/B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE;oBACvC,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC7B,CAAC,EAAE,EAAE,CAAC,CAAC;YACT,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACI,iBAAiB,CAAC,MAAyB,EAAE,SAAiB,QAAQ;QAC3E,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;YAC7B,MAAM,CAAC,gBAAgB,GAAG,IAAI,CAAC;YAE/B,+BAA+B;YAC/B,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAE3C,+BAA+B;YAC/B,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,oBAAoB,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;YAEjF,6BAA6B;YAC7B,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;YAC1D,CAAC;YAED,+BAA+B;YAC/B,IAAI,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,CAAC;gBACrC,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAC/D,CAAC;YAED,wCAAwC;YACxC,MAAM,OAAO,GAAG,gBAAgB,CAAC,uBAAuB,CAAC;gBACvD,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,UAAU,EAAE,MAAM,CAAC,QAAQ,EAAE,UAAU,IAAI,CAAC;gBAC5C,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,YAAY,IAAI,EAAE;gBAC3C,QAAQ,EAAE,MAAM,CAAC,SAAS;gBAC1B,QAAQ,EAAE,MAAM,CAAC,EAAE;aACpB,CAAC,CAAC;YAEH,+DAA+D;YAC/D,gBAAgB,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;YAE5C,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;gBACxB,YAAY,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;gBAClC,MAAM,CAAC,YAAY,GAAG,SAAS,CAAC;YAClC,CAAC;YAED,yBAAyB;YACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,iBAAiB,CAAC;YACvD,MAAM,OAAO,GAAG;gBACd,YAAY,EAAE,MAAM,CAAC,EAAE;gBACvB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,MAAM;gBACN,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBACpC,KAAK,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,aAAa,EAAE,GAAG,EAAE,MAAM,CAAC,SAAS,EAAE;gBAC1D,GAAG,EAAE,MAAM,CAAC,KAAK;gBACjB,SAAS,EAAE,MAAM,CAAC,YAAY;gBAC9B,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;gBAC3C,cAAc,EAAE,MAAM,CAAC,cAAc,IAAI,CAAC;gBAC1C,SAAS,EAAE,oBAAoB;aAChC,CAAC;YAEF,6DAA6D;YAC7D,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACpB,IAAI,CAAC;oBACH,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;oBAC3C,MAAM,CAAC,oBAAoB,GAAG,SAAS,CAAC;gBAC1C,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,iCAAiC,GAAG,EAAE,EAAE;wBAC1D,YAAY,EAAE,MAAM,CAAC,EAAE;wBACvB,KAAK,EAAE,GAAG;wBACV,SAAS,EAAE,oBAAoB;qBAChC,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;YAED,4DAA4D;YAC5D,MAAM,eAAe,GAAoB,EAAE,CAAC;YAE5C,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACpB,oDAAoD;gBACpD,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,YAAY,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;gBAC3G,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;oBAC3D,6CAA6C;oBAC7C,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,GAAG,MAAM,CAAC,EAAE,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;gBACpG,CAAC;qBAAM,CAAC;oBACN,iDAAiD;oBACjD,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,GAAG,MAAM,CAAC,EAAE,WAAW,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;gBACxH,CAAC;YACH,CAAC;YAED,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACpB,oDAAoD;gBACpD,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,YAAY,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;gBAC3G,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;oBAC3D,6CAA6C;oBAC7C,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,GAAG,MAAM,CAAC,EAAE,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;gBACpG,CAAC;qBAAM,CAAC;oBACN,iDAAiD;oBACjD,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,GAAG,MAAM,CAAC,EAAE,WAAW,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;gBACxH,CAAC;YACH,CAAC;YAED,+BAA+B;YAC/B,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;gBACvC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,gCAAgC,GAAG,EAAE,EAAE;oBACzD,YAAY,EAAE,MAAM,CAAC,EAAE;oBACvB,KAAK,EAAE,GAAG;oBACV,SAAS,EAAE,oBAAoB;iBAChC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAEH,0CAA0C;YAC1C,MAAM,CAAC,WAAW,GAAG,EAAE,CAAC;YACxB,MAAM,CAAC,eAAe,GAAG,CAAC,CAAC;YAE3B,0CAA0C;YAC1C,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAEzC,sDAAsD;YACtD,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,qBAAqB,EAAE,CAAC;gBACnD,6EAA6E;gBAC7E,yBAAyB,CAAC,GAAG,CAC3B,uBAAuB,EACvB,MAAM,EACN,0BAA0B,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,SAAS,EAAE,EAC/D;oBACE,GAAG,OAAO;oBACV,WAAW,EAAE,QAAQ;oBACrB,OAAO,EAAE,MAAM,CAAC,aAAa;oBAC7B,QAAQ,EAAE,MAAM,CAAC,SAAS;iBAC3B,EACD,GAAG,MAAM,CAAC,QAAQ,IAAI,MAAM,EAAE,CAC/B,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,wDAAwD;gBACxD,yBAAyB,CAAC,GAAG,CAC3B,uBAAuB,EACvB,MAAM,EACN,uBAAuB,EACvB;oBACE,QAAQ,EAAE,MAAM,CAAC,QAAQ;oBACzB,MAAM;oBACN,iBAAiB,EAAE,IAAI,CAAC,iBAAiB,CAAC,IAAI;oBAC9C,SAAS,EAAE,oBAAoB;iBAChC,EACD,MAAM,CAAC,8BAA8B;iBACtC,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAGD;;OAEG;IACI,WAAW,CAAC,IAA6B,EAAE,MAAyB;QACzE,OAAO,CAAC,GAAU,EAAE,EAAE;YACpB,MAAM,IAAI,GAAI,GAAW,CAAC,IAAI,CAAC;YAC/B,IAAI,MAAM,GAAG,OAAO,CAAC;YAErB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACvB,MAAM,kBAAkB,GAAG,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC;YAC1D,MAAM,eAAe,GAAG,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC;YAElD,2BAA2B;YAC3B,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;gBACxB,MAAM,CAAC,YAAY,GAAG,GAAG,CAAC;gBAC1B,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;YAClD,CAAC;YAED,MAAM,SAAS,GAAG;gBAChB,YAAY,EAAE,MAAM,CAAC,EAAE;gBACvB,IAAI;gBACJ,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,KAAK,EAAE,GAAG,CAAC,OAAO;gBAClB,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAC;gBAC9C,YAAY,EAAE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC;gBAC/C,SAAS,EAAE,oBAAoB;aAChC,CAAC;YAEF,QAAQ,IAAI,EAAE,CAAC;gBACb,KAAK,YAAY;oBACf,MAAM,GAAG,YAAY,CAAC;oBACtB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iBAAiB,IAAI,KAAK,MAAM,CAAC,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC;oBAC3E,MAAM;gBACR,KAAK,WAAW;oBACd,MAAM,GAAG,WAAW,CAAC;oBACrB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,IAAI,KAAK,MAAM,CAAC,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC;oBAC1E,MAAM;gBACR;oBACE,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,YAAY,IAAI,KAAK,MAAM,CAAC,QAAQ,MAAM,GAAG,CAAC,OAAO,EAAE,EAAE,SAAS,CAAC,CAAC;YAC5F,CAAC;YAED,IAAI,IAAI,KAAK,UAAU,IAAI,MAAM,CAAC,yBAAyB,IAAI,IAAI,EAAE,CAAC;gBACpE,MAAM,CAAC,yBAAyB,GAAG,MAAM,CAAC;gBAC1C,IAAI,CAAC,wBAAwB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;YACpD,CAAC;iBAAM,IAAI,IAAI,KAAK,UAAU,IAAI,MAAM,CAAC,yBAAyB,IAAI,IAAI,EAAE,CAAC;gBAC3E,MAAM,CAAC,yBAAyB,GAAG,MAAM,CAAC;gBAC1C,IAAI,CAAC,wBAAwB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;YACpD,CAAC;YAED,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC3C,CAAC,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,WAAW,CAAC,IAA6B,EAAE,MAAyB;QACzE,OAAO,GAAG,EAAE;YACV,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,qBAAqB,EAAE,CAAC;gBACnD,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,wBAAwB,IAAI,OAAO,EAAE;oBACtD,YAAY,EAAE,MAAM,CAAC,EAAE;oBACvB,IAAI;oBACJ,QAAQ,EAAE,MAAM,CAAC,QAAQ;oBACzB,SAAS,EAAE,oBAAoB;iBAChC,CAAC,CAAC;YACL,CAAC;YAED,IAAI,IAAI,KAAK,UAAU,IAAI,MAAM,CAAC,yBAAyB,IAAI,IAAI,EAAE,CAAC;gBACpE,MAAM,CAAC,yBAAyB,GAAG,QAAQ,CAAC;gBAC5C,IAAI,CAAC,wBAAwB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YACtD,CAAC;iBAAM,IAAI,IAAI,KAAK,UAAU,IAAI,MAAM,CAAC,yBAAyB,IAAI,IAAI,EAAE,CAAC;gBAC3E,MAAM,CAAC,yBAAyB,GAAG,QAAQ,CAAC;gBAC5C,IAAI,CAAC,wBAAwB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;gBACpD,MAAM,CAAC,kBAAkB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACzC,CAAC;YAED,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC,CAAC;QACrD,CAAC,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,wBAAwB,CAAC,IAA6B,EAAE,MAAc;QAC3E,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACvF,CAAC;IAED;;OAEG;IACI,mBAAmB;QACxB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED;;OAEG;IACK,+BAA+B;QACrC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,kBAAkB,GAAa,EAAE,CAAC;QAExC,sCAAsC;QACtC,KAAK,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YACjE,IAAI,SAAS,IAAI,GAAG,EAAE,CAAC;gBACrB,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACxC,CAAC;QACH,CAAC;QAED,qFAAqF;QACrF,kFAAkF;QAClF,KAAK,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC5D,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;gBAC7B,MAAM,iBAAiB,GAAG,MAAM,CAAC,QAAQ,EAAE,SAAS,IAAI,KAAK,CAAC;gBAC9D,MAAM,iBAAiB,GAAG,MAAM,CAAC,QAAQ,EAAE,SAAS,IAAI,KAAK,CAAC;gBAE9D,qFAAqF;gBACrF,IAAI,iBAAiB,IAAI,iBAAiB,EAAE,CAAC;oBAC3C,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,+BAA+B,YAAY,8CAA8C,EAAE;wBAC5G,YAAY;wBACZ,QAAQ,EAAE,MAAM,CAAC,QAAQ;wBACzB,GAAG,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC;wBACrD,SAAS,EAAE,oBAAoB;qBAChC,CAAC,CAAC;oBAEH,uBAAuB;oBACvB,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;oBACjD,SAAS;gBACX,CAAC;gBAED,8CAA8C;gBAC9C,IAAI,iBAAiB,IAAI,iBAAiB,EAAE,CAAC;oBAC3C,MAAM,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC;oBAC3C,8EAA8E;oBAC9E,MAAM,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;oBAElD,kEAAkE;oBAClE,IAAI,GAAG,GAAG,WAAW,IAAI,GAAG,GAAG,KAAK,E