@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/deliverability/classes.senderreputationmonitor.js

@@ -0,0 +1,961 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+import { logger } from '../logger.js';
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+    enabled: true,
+    domains: [],
+    updateFrequency: 24 * 60 * 60 * 1000, // Daily
+    dataSources: {
+        spamLists: [
+            'zen.spamhaus.org',
+            'bl.spamcop.net',
+            'dnsbl.sorbs.net',
+            'b.barracudacentral.org'
+        ],
+        deliverabilityMonitor: null
+    },
+    alertThresholds: {
+        minReputationScore: 70,
+        maxComplaintRate: 0.1, // 0.1%
+        maxBounceRate: 5, // 5%
+        minOpenRate: 15 // 15%
+    }
+};
+/**
+ * Class for monitoring and tracking sender reputation for domains
+ */
+export class SenderReputationMonitor {
+    /**
+     * Constructor for SenderReputationMonitor
+     * @param config Configuration options
+     * @param storageManager Optional StorageManager instance
+     */
+    constructor(config = {}, storageManager) {
+        this.reputationData = new Map();
+        this.updateTimer = null;
+        this.isInitialized = false;
+        // Merge with default config
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+            dataSources: {
+                ...DEFAULT_CONFIG.dataSources,
+                ...config.dataSources
+            },
+            alertThresholds: {
+                ...DEFAULT_CONFIG.alertThresholds,
+                ...config.alertThresholds
+            }
+        };
+        this.storageManager = storageManager;
+        // If no storage manager provided, log warning
+        if (!storageManager) {
+            logger.log('warn', '⚠️  WARNING: SenderReputationMonitor initialized without StorageManager.\n' +
+                '   Reputation data will only be stored to filesystem.\n' +
+                '   Consider passing a StorageManager instance for better storage flexibility.');
+        }
+        // Initialize (async, but we don't await here to avoid blocking constructor)
+        this.initialize().catch(error => {
+            logger.log('error', `Failed to initialize SenderReputationMonitor: ${error.message}`, {
+                stack: error.stack
+            });
+        });
+    }
+    /**
+     * Get the singleton instance
+     * @param config Configuration options
+     * @param storageManager Optional StorageManager instance
+     * @returns Singleton instance
+     */
+    static getInstance(config = {}, storageManager) {
+        if (!SenderReputationMonitor.instance) {
+            SenderReputationMonitor.instance = new SenderReputationMonitor(config, storageManager);
+        }
+        return SenderReputationMonitor.instance;
+    }
+    /**
+     * Initialize the reputation monitor
+     */
+    async initialize() {
+        if (this.isInitialized)
+            return;
+        try {
+            // Only load data if not running in a test environment
+            const isTestEnvironment = process.env.NODE_ENV === 'test' || !!process.env.JEST_WORKER_ID;
+            if (!isTestEnvironment) {
+                // Load existing reputation data
+                await this.loadReputationData();
+            }
+            // Initialize data for any new domains
+            for (const domain of this.config.domains) {
+                if (!this.reputationData.has(domain)) {
+                    this.initializeDomainData(domain);
+                }
+            }
+            // Schedule updates if enabled and not in test environment
+            if (this.config.enabled && !isTestEnvironment) {
+                this.scheduleUpdates();
+            }
+            this.isInitialized = true;
+            logger.log('info', `Sender Reputation Monitor initialized for ${this.config.domains.length} domains`);
+        }
+        catch (error) {
+            logger.log('error', `Failed to initialize Sender Reputation Monitor: ${error.message}`, {
+                stack: error.stack
+            });
+        }
+    }
+    /**
+     * Initialize reputation data for a new domain
+     * @param domain Domain to initialize
+     */
+    initializeDomainData(domain) {
+        // Create new domain reputation metrics with default values
+        const newMetrics = {
+            domain,
+            lastUpdated: new Date(),
+            volume: {
+                sent: 0,
+                delivered: 0,
+                hardBounces: 0,
+                softBounces: 0,
+                dailySendVolume: {}
+            },
+            engagement: {
+                opens: 0,
+                clicks: 0,
+                openRate: 0,
+                clickRate: 0,
+                clickToOpenRate: 0
+            },
+            complaints: {
+                total: 0,
+                rate: 0,
+                topDomains: []
+            },
+            authentication: {
+                spfPassRate: 100, // Assume perfect initially
+                dkimPassRate: 100,
+                dmarcPassRate: 100,
+                failures: []
+            },
+            blocklist: {
+                listed: false,
+                activeListings: [],
+                recentDelistings: []
+            },
+            inboxPlacement: {
+                overall: 95, // Start with optimistic estimate
+                providers: {
+                    gmail: 95,
+                    outlook: 95,
+                    yahoo: 95,
+                    aol: 95,
+                    other: 95
+                }
+            },
+            historical: {
+                reputationScores: {},
+                trends: {
+                    openRate: 0,
+                    complaintRate: 0,
+                    bounceRate: 0,
+                    spamListings: 0
+                }
+            }
+        };
+        // Generate some initial historical data points
+        const today = new Date();
+        for (let i = 0; i < 30; i++) {
+            const date = new Date(today);
+            date.setDate(date.getDate() - i);
+            const dateKey = date.toISOString().split('T')[0];
+            newMetrics.historical.reputationScores[dateKey] = 95; // Default good score
+            newMetrics.volume.dailySendVolume[dateKey] = 0;
+        }
+        // Save the new metrics
+        this.reputationData.set(domain, newMetrics);
+        logger.log('info', `Initialized reputation data for domain ${domain}`);
+    }
+    /**
+     * Schedule regular reputation data updates
+     */
+    scheduleUpdates() {
+        if (this.updateTimer) {
+            clearTimeout(this.updateTimer);
+        }
+        this.updateTimer = setTimeout(async () => {
+            await this.updateAllDomainMetrics();
+            this.scheduleUpdates(); // Reschedule for next update
+        }, this.config.updateFrequency);
+        logger.log('info', `Scheduled reputation updates every ${this.config.updateFrequency / (60 * 60 * 1000)} hours`);
+    }
+    /**
+     * Update metrics for all monitored domains
+     */
+    async updateAllDomainMetrics() {
+        if (!this.config.enabled)
+            return;
+        logger.log('info', 'Starting reputation metrics update for all domains');
+        for (const domain of this.config.domains) {
+            try {
+                await this.updateDomainMetrics(domain);
+                logger.log('info', `Updated reputation metrics for ${domain}`);
+            }
+            catch (error) {
+                logger.log('error', `Error updating metrics for ${domain}: ${error.message}`, {
+                    stack: error.stack
+                });
+            }
+        }
+        // Save all updated data
+        await this.saveReputationData();
+        logger.log('info', 'Completed reputation metrics update for all domains');
+    }
+    /**
+     * Update reputation metrics for a specific domain
+     * @param domain Domain to update
+     */
+    async updateDomainMetrics(domain) {
+        const metrics = this.reputationData.get(domain);
+        if (!metrics) {
+            logger.log('warn', `No reputation data found for domain ${domain}`);
+            return;
+        }
+        try {
+            // Update last updated timestamp
+            metrics.lastUpdated = new Date();
+            // Check blocklist status
+            await this.checkBlocklistStatus(domain, metrics);
+            // Update historical data
+            this.updateHistoricalData(metrics);
+            // Calculate current reputation score
+            const reputationScore = this.calculateReputationScore(metrics);
+            // Save current reputation score to historical data
+            const today = new Date().toISOString().split('T')[0];
+            metrics.historical.reputationScores[today] = reputationScore;
+            // Calculate trends
+            this.calculateTrends(metrics);
+            // Check alert thresholds
+            this.checkAlertThresholds(metrics);
+        }
+        catch (error) {
+            logger.log('error', `Error in updateDomainMetrics for ${domain}: ${error.message}`, {
+                stack: error.stack
+            });
+        }
+    }
+    /**
+     * Check domain blocklist status
+     * @param domain Domain to check
+     * @param metrics Metrics to update
+     */
+    async checkBlocklistStatus(domain, metrics) {
+        // Skip DNS lookups in test environment
+        const isTestEnvironment = process.env.NODE_ENV === 'test' || !!process.env.JEST_WORKER_ID;
+        if (isTestEnvironment || !this.config.dataSources.spamLists?.length) {
+            return;
+        }
+        const previouslyListed = metrics.blocklist.listed;
+        const previousListings = new Set(metrics.blocklist.activeListings.map(l => l.list));
+        // Store current listings to detect changes
+        const currentListings = [];
+        // Check each blocklist
+        for (const list of this.config.dataSources.spamLists) {
+            try {
+                const isListed = await this.checkDomainOnBlocklist(domain, list);
+                if (isListed) {
+                    // If already known to be listed on this one, keep the original listing date
+                    const existingListing = metrics.blocklist.activeListings.find(l => l.list === list);
+                    if (existingListing) {
+                        currentListings.push(existingListing);
+                    }
+                    else {
+                        // New listing
+                        currentListings.push({
+                            list,
+                            listedSince: new Date()
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                logger.log('warn', `Error checking ${domain} on blocklist ${list}: ${error.message}`);
+            }
+        }
+        // Update active listings
+        metrics.blocklist.activeListings = currentListings;
+        metrics.blocklist.listed = currentListings.length > 0;
+        // Check for delistings
+        if (previouslyListed) {
+            const currentListsSet = new Set(currentListings.map(l => l.list));
+            // Convert Set to Array for compatibility with older JS versions
+            Array.from(previousListings).forEach(list => {
+                if (!currentListsSet.has(list)) {
+                    // This list no longer contains the domain - it was delisted
+                    const previousListing = metrics.blocklist.activeListings.find(l => l.list === list);
+                    if (previousListing) {
+                        metrics.blocklist.recentDelistings.push({
+                            list,
+                            listedFrom: previousListing.listedSince,
+                            listedTo: new Date()
+                        });
+                    }
+                }
+            });
+            // Keep only recent delistings (last 90 days)
+            const ninetyDaysAgo = new Date();
+            ninetyDaysAgo.setDate(ninetyDaysAgo.getDate() - 90);
+            metrics.blocklist.recentDelistings = metrics.blocklist.recentDelistings
+                .filter(d => d.listedTo > ninetyDaysAgo);
+        }
+    }
+    /**
+     * Check if a domain is on a specific blocklist
+     * @param domain Domain to check
+     * @param list Blocklist to check
+     * @returns Whether the domain is listed
+     */
+    async checkDomainOnBlocklist(domain, list) {
+        try {
+            // Look up the domain in the blocklist (simplified)
+            if (list === 'zen.spamhaus.org') {
+                // For Spamhaus and similar lists, we check the domain MX IPs
+                const mxRecords = await plugins.dns.promises.resolveMx(domain);
+                if (mxRecords && mxRecords.length > 0) {
+                    // Check the primary MX record
+                    const primaryMx = mxRecords.sort((a, b) => a.priority - b.priority)[0].exchange;
+                    // Resolve IP addresses for the MX
+                    const ips = await plugins.dns.promises.resolve(primaryMx);
+                    // Check the first IP
+                    if (ips.length > 0) {
+                        const ip = ips[0];
+                        const reversedIp = ip.split('.').reverse().join('.');
+                        const lookupDomain = `${reversedIp}.${list}`;
+                        try {
+                            await plugins.dns.promises.resolve(lookupDomain);
+                            return true; // Listed
+                        }
+                        catch (err) {
+                            if (err.code === 'ENOTFOUND') {
+                                return false; // Not listed
+                            }
+                            throw err; // Other error
+                        }
+                    }
+                }
+                return false;
+            }
+            else {
+                // For domain-based blocklists
+                const lookupDomain = `${domain}.${list}`;
+                try {
+                    await plugins.dns.promises.resolve(lookupDomain);
+                    return true; // Listed
+                }
+                catch (err) {
+                    if (err.code === 'ENOTFOUND') {
+                        return false; // Not listed
+                    }
+                    throw err; // Other error
+                }
+            }
+        }
+        catch (error) {
+            logger.log('warn', `Error checking blocklist status for ${domain} on ${list}: ${error.message}`);
+            return false; // Assume not listed on error
+        }
+    }
+    /**
+     * Update historical data in metrics
+     * @param metrics Metrics to update
+     */
+    updateHistoricalData(metrics) {
+        // Keep only the last 30 days of data
+        const dates = Object.keys(metrics.historical.reputationScores)
+            .sort((a, b) => b.localeCompare(a)); // Sort descending
+        if (dates.length > 30) {
+            const daysToKeep = dates.slice(0, 30);
+            const newScores = {};
+            for (const day of daysToKeep) {
+                newScores[day] = metrics.historical.reputationScores[day];
+            }
+            metrics.historical.reputationScores = newScores;
+        }
+        // Same for daily send volume
+        const volumeDates = Object.keys(metrics.volume.dailySendVolume)
+            .sort((a, b) => b.localeCompare(a));
+        if (volumeDates.length > 30) {
+            const daysToKeep = volumeDates.slice(0, 30);
+            const newVolume = {};
+            for (const day of daysToKeep) {
+                newVolume[day] = metrics.volume.dailySendVolume[day];
+            }
+            metrics.volume.dailySendVolume = newVolume;
+        }
+    }
+    /**
+     * Calculate reputation score from metrics
+     * @param metrics Domain reputation metrics
+     * @returns Reputation score (0-100)
+     */
+    calculateReputationScore(metrics) {
+        // Calculate component scores
+        const components = {
+            engagement: this.calculateEngagementScore(metrics),
+            complaints: this.calculateComplaintScore(metrics),
+            authentication: this.calculateAuthenticationScore(metrics),
+            volumeStability: this.calculateVolumeStabilityScore(metrics),
+            infrastructure: this.calculateInfrastructureScore(metrics),
+            blocklist: this.calculateBlocklistScore(metrics)
+        };
+        // Apply weights to components
+        const weightedScore = components.engagement * 0.25 +
+            components.complaints * 0.25 +
+            components.authentication * 0.2 +
+            components.volumeStability * 0.1 +
+            components.infrastructure * 0.1 +
+            components.blocklist * 0.1;
+        // Round to 2 decimal places
+        return Math.round(weightedScore * 100) / 100;
+    }
+    /**
+     * Calculate engagement component score
+     * @param metrics Domain metrics
+     * @returns Engagement score (0-100)
+     */
+    calculateEngagementScore(metrics) {
+        const openRate = metrics.engagement.openRate;
+        const clickRate = metrics.engagement.clickRate;
+        // Benchmark open and click rates
+        // <5% open rate = poor (score: 0-30)
+        // 5-15% = average (score: 30-70)
+        // >15% = good (score: 70-100)
+        let openScore = 0;
+        if (openRate < 5) {
+            openScore = openRate * 6; // 0-30 scale
+        }
+        else if (openRate < 15) {
+            openScore = 30 + (openRate - 5) * 4; // 30-70 scale
+        }
+        else {
+            openScore = 70 + Math.min(30, (openRate - 15) * 2); // 70-100 scale
+        }
+        // Similarly for click rate
+        let clickScore = 0;
+        if (clickRate < 1) {
+            clickScore = clickRate * 30; // 0-30 scale
+        }
+        else if (clickRate < 5) {
+            clickScore = 30 + (clickRate - 1) * 10; // 30-70 scale
+        }
+        else {
+            clickScore = 70 + Math.min(30, (clickRate - 5) * 6); // 70-100 scale
+        }
+        // Combine with 60% weight to open rate, 40% to click rate
+        return (openScore * 0.6 + clickScore * 0.4);
+    }
+    /**
+     * Calculate complaint component score
+     * @param metrics Domain metrics
+     * @returns Complaint score (0-100)
+     */
+    calculateComplaintScore(metrics) {
+        const complaintRate = metrics.complaints.rate;
+        // Industry standard: complaint rate should be under 0.1%
+        // 0% = perfect (score: 100)
+        // 0.1% = threshold (score: 70)
+        // 0.5% = problematic (score: 30)
+        // 1%+ = critical (score: 0)
+        if (complaintRate === 0)
+            return 100;
+        if (complaintRate >= 1)
+            return 0;
+        if (complaintRate < 0.1) {
+            // 0-0.1% maps to 100-70
+            return 100 - (complaintRate / 0.1) * 30;
+        }
+        else if (complaintRate < 0.5) {
+            // 0.1-0.5% maps to 70-30
+            return 70 - ((complaintRate - 0.1) / 0.4) * 40;
+        }
+        else {
+            // 0.5-1% maps to 30-0
+            return 30 - ((complaintRate - 0.5) / 0.5) * 30;
+        }
+    }
+    /**
+     * Calculate authentication component score
+     * @param metrics Domain metrics
+     * @returns Authentication score (0-100)
+     */
+    calculateAuthenticationScore(metrics) {
+        const spfRate = metrics.authentication.spfPassRate;
+        const dkimRate = metrics.authentication.dkimPassRate;
+        const dmarcRate = metrics.authentication.dmarcPassRate;
+        // Weight SPF, DKIM, and DMARC
+        return (spfRate * 0.3 + dkimRate * 0.3 + dmarcRate * 0.4);
+    }
+    /**
+     * Calculate volume stability component score
+     * @param metrics Domain metrics
+     * @returns Volume stability score (0-100)
+     */
+    calculateVolumeStabilityScore(metrics) {
+        const volumes = Object.values(metrics.volume.dailySendVolume);
+        if (volumes.length < 2)
+            return 100; // Not enough data
+        // Calculate coefficient of variation (stdev / mean)
+        const mean = volumes.reduce((sum, v) => sum + v, 0) / volumes.length;
+        if (mean === 0)
+            return 100; // No sending activity
+        const variance = volumes.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / volumes.length;
+        const stdev = Math.sqrt(variance);
+        const cv = stdev / mean;
+        // Convert to score: lower CV means more stability
+        // CV < 0.1 is very stable (score: 90-100)
+        // CV < 0.5 is normal (score: 60-90)
+        // CV < 1.0 is somewhat unstable (score: 30-60)
+        // CV >= 1.0 is unstable (score: 0-30)
+        if (cv < 0.1) {
+            return 90 + (1 - cv / 0.1) * 10;
+        }
+        else if (cv < 0.5) {
+            return 60 + (1 - (cv - 0.1) / 0.4) * 30;
+        }
+        else if (cv < 1.0) {
+            return 30 + (1 - (cv - 0.5) / 0.5) * 30;
+        }
+        else {
+            return Math.max(0, 30 - (cv - 1.0) * 10);
+        }
+    }
+    /**
+     * Calculate infrastructure component score
+     * @param metrics Domain metrics
+     * @returns Infrastructure score (0-100)
+     */
+    calculateInfrastructureScore(metrics) {
+        // This is a placeholder; in reality, this would be based on:
+        // - IP reputation
+        // - Reverse DNS configuration
+        // - IP warming status
+        // - Historical IP behavior
+        // For now, assume good infrastructure
+        return 90;
+    }
+    /**
+     * Calculate blocklist component score
+     * @param metrics Domain metrics
+     * @returns Blocklist score (0-100)
+     */
+    calculateBlocklistScore(metrics) {
+        // If currently listed on any blocklist, score is heavily impacted
+        if (metrics.blocklist.listed) {
+            // Number of active listings determines severity
+            const listingCount = metrics.blocklist.activeListings.length;
+            if (listingCount >= 3)
+                return 0; // Critical: listed on 3+ lists
+            if (listingCount === 2)
+                return 20; // Severe: listed on 2 lists
+            return 40; // Serious: listed on 1 list
+        }
+        // If recently delisted, some penalty still applies
+        if (metrics.blocklist.recentDelistings.length > 0) {
+            // Check how recent the delistings are
+            const now = new Date();
+            const mostRecent = metrics.blocklist.recentDelistings
+                .reduce((latest, delisting) => delisting.listedTo > latest ? delisting.listedTo : latest, new Date(0));
+            const daysSinceDelisting = Math.floor((now.getTime() - mostRecent.getTime()) / (24 * 60 * 60 * 1000));
+            // Score improves as time passes since delisting
+            if (daysSinceDelisting < 7)
+                return 60; // Delisted within last week
+            if (daysSinceDelisting < 30)
+                return 80; // Delisted within last month
+            return 90; // Delisted over a month ago
+        }
+        // Never listed
+        return 100;
+    }
+    /**
+     * Calculate trend metrics
+     * @param metrics Domain metrics to update
+     */
+    calculateTrends(metrics) {
+        // Get dates in descending order
+        const dates = Object.keys(metrics.historical.reputationScores)
+            .sort((a, b) => b.localeCompare(a));
+        if (dates.length < 7) {
+            // Not enough data for trends
+            metrics.historical.trends = {
+                openRate: 0,
+                complaintRate: 0,
+                bounceRate: 0,
+                spamListings: 0
+            };
+            return;
+        }
+        // Calculate trends over past 7 days compared to previous 7 days
+        const current7Days = dates.slice(0, 7);
+        const previous7Days = dates.slice(7, 14);
+        if (previous7Days.length < 7) {
+            // Not enough historical data
+            return;
+        }
+        // Calculate averages for the periods
+        const currentReputation = current7Days.reduce((sum, date) => sum + metrics.historical.reputationScores[date], 0) / current7Days.length;
+        const previousReputation = previous7Days.reduce((sum, date) => sum + metrics.historical.reputationScores[date], 0) / previous7Days.length;
+        // Calculate percent change
+        const reputationChange = ((currentReputation - previousReputation) / previousReputation) * 100;
+        // For now, use reputation change for all trends (in a real implementation
+        // we would calculate each metric's trend separately)
+        metrics.historical.trends = {
+            openRate: reputationChange,
+            complaintRate: -reputationChange, // Inverse for complaint rate (negative is good)
+            bounceRate: -reputationChange, // Inverse for bounce rate
+            spamListings: -reputationChange // Inverse for spam listings
+        };
+    }
+    /**
+     * Check if metrics exceed alert thresholds
+     * @param metrics Domain metrics to check
+     */
+    checkAlertThresholds(metrics) {
+        const thresholds = this.config.alertThresholds;
+        const today = new Date().toISOString().split('T')[0];
+        const todayScore = metrics.historical.reputationScores[today] || 0;
+        // Check reputation score
+        if (todayScore < thresholds.minReputationScore) {
+            this.sendAlert(metrics.domain, 'reputation_score', {
+                score: todayScore,
+                threshold: thresholds.minReputationScore
+            });
+        }
+        // Check complaint rate
+        if (metrics.complaints.rate > thresholds.maxComplaintRate) {
+            this.sendAlert(metrics.domain, 'complaint_rate', {
+                rate: metrics.complaints.rate,
+                threshold: thresholds.maxComplaintRate
+            });
+        }
+        // Check bounce rate
+        const bounceRate = (metrics.volume.hardBounces + metrics.volume.softBounces) /
+            Math.max(1, metrics.volume.sent) * 100;
+        if (bounceRate > thresholds.maxBounceRate) {
+            this.sendAlert(metrics.domain, 'bounce_rate', {
+                rate: bounceRate,
+                threshold: thresholds.maxBounceRate
+            });
+        }
+        // Check open rate
+        if (metrics.engagement.openRate < thresholds.minOpenRate) {
+            this.sendAlert(metrics.domain, 'open_rate', {
+                rate: metrics.engagement.openRate,
+                threshold: thresholds.minOpenRate
+            });
+        }
+        // Check blocklist status
+        if (metrics.blocklist.listed) {
+            this.sendAlert(metrics.domain, 'blocklist', {
+                lists: metrics.blocklist.activeListings.map(l => l.list)
+            });
+        }
+    }
+    /**
+     * Send an alert for a reputation issue
+     * @param domain Domain with the issue
+     * @param alertType Type of alert
+     * @param data Alert data
+     */
+    sendAlert(domain, alertType, data) {
+        logger.log('warn', `Reputation alert for ${domain}: ${alertType}`, data);
+        // In a real implementation, this would send alerts via email, 
+        // notification systems, webhooks, etc.
+    }
+    /**
+     * Record a send event for domain reputation tracking
+     * @param domain The domain sending the email
+     * @param event Event details
+     */
+    recordSendEvent(domain, event) {
+        // Ensure we have metrics for this domain
+        if (!this.reputationData.has(domain)) {
+            this.initializeDomainData(domain);
+        }
+        const metrics = this.reputationData.get(domain);
+        const count = event.count || 1;
+        const today = new Date().toISOString().split('T')[0];
+        // Update metrics based on event type
+        switch (event.type) {
+            case 'sent':
+                metrics.volume.sent += count;
+                // Update daily send volume
+                metrics.volume.dailySendVolume[today] =
+                    (metrics.volume.dailySendVolume[today] || 0) + count;
+                break;
+            case 'delivered':
+                metrics.volume.delivered += count;
+                break;
+            case 'bounce':
+                if (event.hardBounce) {
+                    metrics.volume.hardBounces += count;
+                }
+                else {
+                    metrics.volume.softBounces += count;
+                }
+                break;
+            case 'complaint':
+                metrics.complaints.total += count;
+                // Track by receiving domain
+                if (event.receivingDomain) {
+                    const domainIndex = metrics.complaints.topDomains.findIndex(d => d.domain === event.receivingDomain);
+                    if (domainIndex >= 0) {
+                        metrics.complaints.topDomains[domainIndex].count += count;
+                        metrics.complaints.topDomains[domainIndex].rate =
+                            metrics.complaints.topDomains[domainIndex].count / Math.max(1, metrics.volume.sent);
+                    }
+                    else {
+                        metrics.complaints.topDomains.push({
+                            domain: event.receivingDomain,
+                            count,
+                            rate: count / Math.max(1, metrics.volume.sent)
+                        });
+                    }
+                    // Sort by count
+                    metrics.complaints.topDomains.sort((a, b) => b.count - a.count);
+                    // Keep only top 10
+                    if (metrics.complaints.topDomains.length > 10) {
+                        metrics.complaints.topDomains = metrics.complaints.topDomains.slice(0, 10);
+                    }
+                }
+                // Update overall complaint rate
+                metrics.complaints.rate =
+                    metrics.complaints.total / Math.max(1, metrics.volume.sent);
+                break;
+            case 'open':
+                metrics.engagement.opens += count;
+                metrics.engagement.openRate =
+                    metrics.engagement.opens / Math.max(1, metrics.volume.delivered);
+                break;
+            case 'click':
+                metrics.engagement.clicks += count;
+                metrics.engagement.clickRate =
+                    metrics.engagement.clicks / Math.max(1, metrics.volume.delivered);
+                metrics.engagement.clickToOpenRate =
+                    metrics.engagement.clicks / Math.max(1, metrics.engagement.opens);
+                break;
+        }
+        // Update last updated timestamp
+        metrics.lastUpdated = new Date();
+        // Save data periodically (not after every event to avoid excessive I/O)
+        // Skip in test environment
+        const isTestEnvironment = process.env.NODE_ENV === 'test' || !!process.env.JEST_WORKER_ID;
+        if (!isTestEnvironment && Math.random() < 0.01) { // ~1% chance to save on each event
+            this.saveReputationData().catch(error => {
+                logger.log('error', `Failed to save reputation data: ${error.message}`, {
+                    stack: error.stack
+                });
+            });
+        }
+    }
+    /**
+     * Get reputation data for a domain
+     * @param domain Domain to get data for
+     * @returns Reputation data
+     */
+    getReputationData(domain) {
+        return this.reputationData.get(domain) || null;
+    }
+    /**
+     * Get summary reputation data for all domains
+     * @returns Summary data for all domains
+     */
+    getReputationSummary() {
+        return Array.from(this.reputationData.entries())
+            .map(([domain, metrics]) => {
+            const today = new Date().toISOString().split('T')[0];
+            const score = metrics.historical.reputationScores[today] || 0;
+            // Determine status based on score
+            let status;
+            if (score >= 90)
+                status = 'excellent';
+            else if (score >= 75)
+                status = 'good';
+            else if (score >= 60)
+                status = 'fair';
+            else if (score >= 40)
+                status = 'poor';
+            else
+                status = 'critical';
+            return {
+                domain,
+                score,
+                status,
+                listed: metrics.blocklist.listed,
+                trend: metrics.historical.trends.openRate // Use open rate trend as overall trend
+            };
+        })
+            .sort((a, b) => b.score - a.score); // Sort by score descending
+    }
+    /**
+     * Add a domain to monitor
+     * @param domain Domain to monitor
+     */
+    addDomain(domain) {
+        if (this.config.domains.includes(domain)) {
+            logger.log('info', `Domain ${domain} is already being monitored`);
+            return;
+        }
+        this.config.domains.push(domain);
+        this.initializeDomainData(domain);
+        this.saveReputationData().catch(error => {
+            logger.log('error', `Failed to save reputation data after adding domain: ${error.message}`, {
+                stack: error.stack
+            });
+        });
+        logger.log('info', `Added ${domain} to reputation monitoring`);
+    }
+    /**
+     * Remove a domain from monitoring
+     * @param domain Domain to remove
+     */
+    removeDomain(domain) {
+        const index = this.config.domains.indexOf(domain);
+        if (index === -1) {
+            logger.log('info', `Domain ${domain} is not being monitored`);
+            return;
+        }
+        this.config.domains.splice(index, 1);
+        this.reputationData.delete(domain);
+        this.saveReputationData().catch(error => {
+            logger.log('error', `Failed to save reputation data after removing domain: ${error.message}`, {
+                stack: error.stack
+            });
+        });
+        logger.log('info', `Removed ${domain} from reputation monitoring`);
+    }
+    /**
+     * Load reputation data from storage
+     */
+    async loadReputationData() {
+        // Skip loading in test environment to prevent file system race conditions
+        const isTestEnvironment = process.env.NODE_ENV === 'test' || !!process.env.JEST_WORKER_ID;
+        if (isTestEnvironment) {
+            return;
+        }
+        try {
+            // Try to load from storage manager first
+            if (this.storageManager) {
+                try {
+                    const data = await this.storageManager.get('/email/reputation/domain-reputation.json');
+                    if (data) {
+                        const reputationEntries = JSON.parse(data);
+                        for (const entry of reputationEntries) {
+                            // Restore Date objects
+                            entry.lastUpdated = new Date(entry.lastUpdated);
+                            for (const listing of entry.blocklist.activeListings) {
+                                listing.listedSince = new Date(listing.listedSince);
+                            }
+                            for (const delisting of entry.blocklist.recentDelistings) {
+                                delisting.listedFrom = new Date(delisting.listedFrom);
+                                delisting.listedTo = new Date(delisting.listedTo);
+                            }
+                            this.reputationData.set(entry.domain, entry);
+                        }
+                        logger.log('info', `Loaded reputation data for ${this.reputationData.size} domains from StorageManager`);
+                        return;
+                    }
+                }
+                catch (error) {
+                    // Fall through to filesystem migration check
+                }
+                // Check if data exists in filesystem and migrate it to storage manager
+                const reputationDir = plugins.path.join(paths.dataDir, 'reputation');
+                const dataFile = plugins.path.join(reputationDir, 'domain_reputation.json');
+                if (plugins.fs.existsSync(dataFile)) {
+                    const data = plugins.fs.readFileSync(dataFile, 'utf8');
+                    const reputationEntries = JSON.parse(data);
+                    for (const entry of reputationEntries) {
+                        // Restore Date objects
+                        entry.lastUpdated = new Date(entry.lastUpdated);
+                        for (const listing of entry.blocklist.activeListings) {
+                            listing.listedSince = new Date(listing.listedSince);
+                        }
+                        for (const delisting of entry.blocklist.recentDelistings) {
+                            delisting.listedFrom = new Date(delisting.listedFrom);
+                            delisting.listedTo = new Date(delisting.listedTo);
+                        }
+                        this.reputationData.set(entry.domain, entry);
+                    }
+                    // Migrate to storage manager
+                    logger.log('info', `Migrating reputation data for ${this.reputationData.size} domains from filesystem to StorageManager`);
+                    await this.storageManager.set('/email/reputation/domain-reputation.json', JSON.stringify(Array.from(this.reputationData.values()), null, 2));
+                    logger.log('info', `Loaded and migrated reputation data for ${this.reputationData.size} domains`);
+                }
+            }
+            else {
+                // No storage manager, use filesystem directly
+                const reputationDir = plugins.path.join(paths.dataDir, 'reputation');
+                plugins.smartfile.fs.ensureDirSync(reputationDir);
+                const dataFile = plugins.path.join(reputationDir, 'domain_reputation.json');
+                if (plugins.fs.existsSync(dataFile)) {
+                    const data = plugins.fs.readFileSync(dataFile, 'utf8');
+                    const reputationEntries = JSON.parse(data);
+                    for (const entry of reputationEntries) {
+                        // Restore Date objects
+                        entry.lastUpdated = new Date(entry.lastUpdated);
+                        for (const listing of entry.blocklist.activeListings) {
+                            listing.listedSince = new Date(listing.listedSince);
+                        }
+                        for (const delisting of entry.blocklist.recentDelistings) {
+                            delisting.listedFrom = new Date(delisting.listedFrom);
+                            delisting.listedTo = new Date(delisting.listedTo);
+                        }
+                        this.reputationData.set(entry.domain, entry);
+                    }
+                    logger.log('info', `Loaded reputation data for ${this.reputationData.size} domains from filesystem`);
+                }
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to load reputation data: ${error.message}`, {
+                stack: error.stack
+            });
+        }
+    }
+    /**
+     * Save reputation data to storage
+     */
+    async saveReputationData() {
+        // Skip saving in test environment to prevent file system race conditions
+        const isTestEnvironment = process.env.NODE_ENV === 'test' || !!process.env.JEST_WORKER_ID;
+        if (isTestEnvironment) {
+            return;
+        }
+        try {
+            const reputationEntries = Array.from(this.reputationData.values());
+            // Save to storage manager if available
+            if (this.storageManager) {
+                await this.storageManager.set('/email/reputation/domain-reputation.json', JSON.stringify(reputationEntries, null, 2));
+                logger.log('debug', `Saved reputation data for ${reputationEntries.length} domains to StorageManager`);
+            }
+            else {
+                // No storage manager, use filesystem directly
+                const reputationDir = plugins.path.join(paths.dataDir, 'reputation');
+                plugins.smartfile.fs.ensureDirSync(reputationDir);
+                const dataFile = plugins.path.join(reputationDir, 'domain_reputation.json');
+                plugins.smartfile.memory.toFsSync(JSON.stringify(reputationEntries, null, 2), dataFile);
+                logger.log('debug', `Saved reputation data for ${reputationEntries.length} domains to filesystem`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to save reputation data: ${error.message}`, {
+                stack: error.stack
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.senderreputationmonitor.js","sourceRoot":"","sources":["../../../ts/deliverability/classes.senderreputationmonitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AA0ItC;;GAEG;AACH,MAAM,cAAc,GAAuC;IACzD,OAAO,EAAE,IAAI;IACb,OAAO,EAAE,EAAE;IACX,eAAe,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,QAAQ;IAC9C,WAAW,EAAE;QACX,SAAS,EAAE;YACT,kBAAkB;YAClB,gBAAgB;YAChB,iBAAiB;YACjB,wBAAwB;SACzB;QACD,qBAAqB,EAAE,IAAI;KAC5B;IACD,eAAe,EAAE;QACf,kBAAkB,EAAE,EAAE;QACtB,gBAAgB,EAAE,GAAG,EAAE,OAAO;QAC9B,aAAa,EAAE,CAAC,EAAE,KAAK;QACvB,WAAW,EAAE,EAAE,CAAC,MAAM;KACvB;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,OAAO,uBAAuB;IAQlC;;;;OAIG;IACH,YAAY,SAAmC,EAAE,EAAE,cAAoB;QAV/D,mBAAc,GAA0C,IAAI,GAAG,EAAE,CAAC;QAClE,gBAAW,GAAmB,IAAI,CAAC;QACnC,kBAAa,GAAY,KAAK,CAAC;QASrC,4BAA4B;QAC5B,IAAI,CAAC,MAAM,GAAG;YACZ,GAAG,cAAc;YACjB,GAAG,MAAM;YACT,WAAW,EAAE;gBACX,GAAG,cAAc,CAAC,WAAW;gBAC7B,GAAG,MAAM,CAAC,WAAW;aACtB;YACD,eAAe,EAAE;gBACf,GAAG,cAAc,CAAC,eAAe;gBACjC,GAAG,MAAM,CAAC,eAAe;aAC1B;SACF,CAAC;QAEF,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QAErC,8CAA8C;QAC9C,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,CAAC,GAAG,CAAC,MAAM,EACf,4EAA4E;gBAC5E,yDAAyD;gBACzD,+EAA+E,CAChF,CAAC;QACJ,CAAC;QAED,4EAA4E;QAC5E,IAAI,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;YAC9B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,iDAAiD,KAAK,CAAC,OAAO,EAAE,EAAE;gBACpF,KAAK,EAAE,KAAK,CAAC,KAAK;aACnB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,WAAW,CAAC,SAAmC,EAAE,EAAE,cAAoB;QACnF,IAAI,CAAC,uBAAuB,CAAC,QAAQ,EAAE,CAAC;YACtC,uBAAuB,CAAC,QAAQ,GAAG,IAAI,uBAAuB,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QACzF,CAAC;QACD,OAAO,uBAAuB,CAAC,QAAQ,CAAC;IAC1C,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,UAAU;QACtB,IAAI,IAAI,CAAC,aAAa;YAAE,OAAO;QAE/B,IAAI,CAAC;YACH,sDAAsD;YACtD,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;YAE1F,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,gCAAgC;gBAChC,MAAM,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAClC,CAAC;YAED,sCAAsC;YACtC,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBACzC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;oBACrC,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC;YAED,0DAA0D;YAC1D,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC9C,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,CAAC;YAED,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6CAA6C,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,UAAU,CAAC,CAAC;QACxG,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,mDAAmD,KAAK,CAAC,OAAO,EAAE,EAAE;gBACtF,KAAK,EAAE,KAAK,CAAC,KAAK;aACnB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,oBAAoB,CAAC,MAAc;QACzC,2DAA2D;QAC3D,MAAM,UAAU,GAA6B;YAC3C,MAAM;YACN,WAAW,EAAE,IAAI,IAAI,EAAE;YACvB,MAAM,EAAE;gBACN,IAAI,EAAE,CAAC;gBACP,SAAS,EAAE,CAAC;gBACZ,WAAW,EAAE,CAAC;gBACd,WAAW,EAAE,CAAC;gBACd,eAAe,EAAE,EAAE;aACpB;YACD,UAAU,EAAE;gBACV,KAAK,EAAE,CAAC;gBACR,MAAM,EAAE,CAAC;gBACT,QAAQ,EAAE,CAAC;gBACX,SAAS,EAAE,CAAC;gBACZ,eAAe,EAAE,CAAC;aACnB;YACD,UAAU,EAAE;gBACV,KAAK,EAAE,CAAC;gBACR,IAAI,EAAE,CAAC;gBACP,UAAU,EAAE,EAAE;aACf;YACD,cAAc,EAAE;gBACd,WAAW,EAAE,GAAG,EAAE,2BAA2B;gBAC7C,YAAY,EAAE,GAAG;gBACjB,aAAa,EAAE,GAAG;gBAClB,QAAQ,EAAE,EAAE;aACb;YACD,SAAS,EAAE;gBACT,MAAM,EAAE,KAAK;gBACb,cAAc,EAAE,EAAE;gBAClB,gBAAgB,EAAE,EAAE;aACrB;YACD,cAAc,EAAE;gBACd,OAAO,EAAE,EAAE,EAAE,iCAAiC;gBAC9C,SAAS,EAAE;oBACT,KAAK,EAAE,EAAE;oBACT,OAAO,EAAE,EAAE;oBACX,KAAK,EAAE,EAAE;oBACT,GAAG,EAAE,EAAE;oBACP,KAAK,EAAE,EAAE;iBACV;aACF;YACD,UAAU,EAAE;gBACV,gBAAgB,EAAE,EAAE;gBACpB,MAAM,EAAE;oBACN,QAAQ,EAAE,CAAC;oBACX,aAAa,EAAE,CAAC;oBAChB,UAAU,EAAE,CAAC;oBACb,YAAY,EAAE,CAAC;iBAChB;aACF;SACF,CAAC;QAEF,+CAA+C;QAC/C,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC;QACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5B,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;YAC7B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;YACjC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACjD,UAAU,CAAC,UAAU,CAAC,gBAAgB,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,qBAAqB;YAC3E,UAAU,CAAC,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACjD,CAAC;QAED,uBAAuB;QACvB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAC5C,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,0CAA0C,MAAM,EAAE,CAAC,CAAC;IACzE,CAAC;IAED;;OAEG;IACK,eAAe;QACrB,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACjC,CAAC;QAED,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,KAAK,IAAI,EAAE;YACvC,MAAM,IAAI,CAAC,sBAAsB,EAAE,CAAC;YACpC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,6BAA6B;QACvD,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QAEhC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,sCAAsC,IAAI,CAAC,MAAM,CAAC,eAAe,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;IACnH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,sBAAsB;QAClC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO;YAAE,OAAO;QAEjC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,oDAAoD,CAAC,CAAC;QAEzE,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACzC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;gBACvC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kCAAkC,MAAM,EAAE,CAAC,CAAC;YACjE,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,8BAA8B,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,EAAE;oBAC5E,KAAK,EAAE,KAAK,CAAC,KAAK;iBACnB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,wBAAwB;QACxB,MAAM,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAEhC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,qDAAqD,CAAC,CAAC;IAC5E,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,mBAAmB,CAAC,MAAc;QAC9C,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,uCAAuC,MAAM,EAAE,CAAC,CAAC;YACpE,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,gCAAgC;YAChC,OAAO,CAAC,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC;YAEjC,yBAAyB;YACzB,MAAM,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAEjD,yBAAyB;YACzB,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;YAEnC,qCAAqC;YACrC,MAAM,eAAe,GAAG,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC;YAE/D,mDAAmD;YACnD,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACrD,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,eAAe,CAAC;YAE7D,mBAAmB;YACnB,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;YAE9B,yBAAyB;YACzB,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,oCAAoC,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,EAAE;gBAClF,KAAK,EAAE,KAAK,CAAC,KAAK;aACnB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,oBAAoB,CAAC,MAAc,EAAE,OAAiC;QAClF,uCAAuC;QACvC,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;QAC1F,IAAI,iBAAiB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;YACpE,OAAO;QACT,CAAC;QAED,MAAM,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC;QAClD,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAEpF,2CAA2C;QAC3C,MAAM,eAAe,GAA+C,EAAE,CAAC;QAEvE,uBAAuB;QACvB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC;YACrD,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;gBAEjE,IAAI,QAAQ,EAAE,CAAC;oBACb,4EAA4E;oBAC5E,MAAM,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;oBACpF,IAAI,eAAe,EAAE,CAAC;wBACpB,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;oBACxC,CAAC;yBAAM,CAAC;wBACN,cAAc;wBACd,eAAe,CAAC,IAAI,CAAC;4BACnB,IAAI;4BACJ,WAAW,EAAE,IAAI,IAAI,EAAE;yBACxB,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kBAAkB,MAAM,iBAAiB,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACxF,CAAC;QACH,CAAC;QAED,yBAAyB;QACzB,OAAO,CAAC,SAAS,CAAC,cAAc,GAAG,eAAe,CAAC;QACnD,OAAO,CAAC,SAAS,CAAC,MAAM,GAAG,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC;QAEtD,uBAAuB;QACvB,IAAI,gBAAgB,EAAE,CAAC;YACrB,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YAElE,gEAAgE;YAChE,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBAC1C,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;oBAC/B,4DAA4D;oBAC5D,MAAM,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;oBAEpF,IAAI,eAAe,EAAE,CAAC;wBACpB,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,IAAI,CAAC;4BACtC,IAAI;4BACJ,UAAU,EAAE,eAAe,CAAC,WAAW;4BACvC,QAAQ,EAAE,IAAI,IAAI,EAAE;yBACrB,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,6CAA6C;YAC7C,MAAM,aAAa,GAAG,IAAI,IAAI,EAAE,CAAC;YACjC,aAAa,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC;YAEpD,OAAO,CAAC,SAAS,CAAC,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC,gBAAgB;iBACpE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,aAAa,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,sBAAsB,CAAC,MAAc,EAAE,IAAY;QAC/D,IAAI,CAAC;YACH,mDAAmD;YACnD,IAAI,IAAI,KAAK,kBAAkB,EAAE,CAAC;gBAChC,6DAA6D;gBAC7D,MAAM,SAAS,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;gBAE/D,IAAI,SAAS,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACtC,8BAA8B;oBAC9B,MAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;oBAEhF,kCAAkC;oBAClC,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;oBAE1D,qBAAqB;oBACrB,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBACnB,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;wBAClB,MAAM,UAAU,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;wBACrD,MAAM,YAAY,GAAG,GAAG,UAAU,IAAI,IAAI,EAAE,CAAC;wBAE7C,IAAI,CAAC;4BACH,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;4BACjD,OAAO,IAAI,CAAC,CAAC,SAAS;wBACxB,CAAC;wBAAC,OAAO,GAAG,EAAE,CAAC;4BACb,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;gCAC7B,OAAO,KAAK,CAAC,CAAC,aAAa;4BAC7B,CAAC;4BACD,MAAM,GAAG,CAAC,CAAC,cAAc;wBAC3B,CAAC;oBACH,CAAC;gBACH,CAAC;gBACD,OAAO,KAAK,CAAC;YACf,CAAC;iBAAM,CAAC;gBACN,8BAA8B;gBAC9B,MAAM,YAAY,GAAG,GAAG,MAAM,IAAI,IAAI,EAAE,CAAC;gBACzC,IAAI,CAAC;oBACH,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;oBACjD,OAAO,IAAI,CAAC,CAAC,SAAS;gBACxB,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;wBAC7B,OAAO,KAAK,CAAC,CAAC,aAAa;oBAC7B,CAAC;oBACD,MAAM,GAAG,CAAC,CAAC,cAAc;gBAC3B,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,uCAAuC,MAAM,OAAO,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACjG,OAAO,KAAK,CAAC,CAAC,6BAA6B;QAC7C,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,oBAAoB,CAAC,OAAiC;QAC5D,qCAAqC;QACrC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC;aAC3D,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,kBAAkB;QAEzD,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;YACtB,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACtC,MAAM,SAAS,GAA2B,EAAE,CAAC;YAE7C,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;gBAC7B,SAAS,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;YAC5D,CAAC;YAED,OAAO,CAAC,UAAU,CAAC,gBAAgB,GAAG,SAAS,CAAC;QAClD,CAAC;QAED,6BAA6B;QAC7B,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC;aAC5D,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;QAEtC,IAAI,WAAW,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;YAC5B,MAAM,UAAU,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC5C,MAAM,SAAS,GAA2B,EAAE,CAAC;YAE7C,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;gBAC7B,SAAS,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;YACvD,CAAC;YAED,OAAO,CAAC,MAAM,CAAC,eAAe,GAAG,SAAS,CAAC;QAC7C,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,wBAAwB,CAAC,OAAiC;QAChE,6BAA6B;QAC7B,MAAM,UAAU,GAA0B;YACxC,UAAU,EAAE,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC;YAClD,UAAU,EAAE,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC;YACjD,cAAc,EAAE,IAAI,CAAC,4BAA4B,CAAC,OAAO,CAAC;YAC1D,eAAe,EAAE,IAAI,CAAC,6BAA6B,CAAC,OAAO,CAAC;YAC5D,cAAc,EAAE,IAAI,CAAC,4BAA4B,CAAC,OAAO,CAAC;YAC1D,SAAS,EAAE,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC;SACjD,CAAC;QAEF,8BAA8B;QAC9B,MAAM,aAAa,GACjB,UAAU,CAAC,UAAU,GAAG,IAAI;YAC5B,UAAU,CAAC,UAAU,GAAG,IAAI;YAC5B,UAAU,CAAC,cAAc,GAAG,GAAG;YAC/B,UAAU,CAAC,eAAe,GAAG,GAAG;YAChC,UAAU,CAAC,cAAc,GAAG,GAAG;YAC/B,UAAU,CAAC,SAAS,GAAG,GAAG,CAAC;QAE7B,4BAA4B;QAC5B,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACK,wBAAwB,CAAC,OAAiC;QAChE,MAAM,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC;QAC7C,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC;QAE/C,iCAAiC;QACjC,qCAAqC;QACrC,iCAAiC;QACjC,8BAA8B;QAC9B,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;YACjB,SAAS,GAAG,QAAQ,GAAG,CAAC,CAAC,CAAC,aAAa;QACzC,CAAC;aAAM,IAAI,QAAQ,GAAG,EAAE,EAAE,CAAC;YACzB,SAAS,GAAG,EAAE,GAAG,CAAC,QAAQ,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,cAAc;QACrD,CAAC;aAAM,CAAC;YACN,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,QAAQ,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,eAAe;QACrE,CAAC;QAED,2BAA2B;QAC3B,IAAI,UAAU,GAAG,CAAC,CAAC;QACnB,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;YAClB,UAAU,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,aAAa;QAC5C,CAAC;aAAM,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;YACzB,UAAU,GAAG,EAAE,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,cAAc;QACxD,CAAC;aAAM,CAAC;YACN,UAAU,GAAG,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,eAAe;QACtE,CAAC;QAED,0DAA0D;QAC1D,OAAO,CAAC,SAAS,GAAG,GAAG,GAAG,UAAU,GAAG,GAAG,CAAC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACK,uBAAuB,CAAC,OAAiC;QAC/D,MAAM,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC;QAE9C,yDAAyD;QACzD,4BAA4B;QAC5B,+BAA+B;QAC/B,iCAAiC;QACjC,4BAA4B;QAE5B,IAAI,aAAa,KAAK,CAAC;YAAE,OAAO,GAAG,CAAC;QACpC,IAAI,aAAa,IAAI,CAAC;YAAE,OAAO,CAAC,CAAC;QAEjC,IAAI,aAAa,GAAG,GAAG,EAAE,CAAC;YACxB,wBAAwB;YACxB,OAAO,GAAG,GAAG,CAAC,aAAa,GAAG,GAAG,CAAC,GAAG,EAAE,CAAC;QAC1C,CAAC;aAAM,IAAI,aAAa,GAAG,GAAG,EAAE,CAAC;YAC/B,yBAAyB;YACzB,OAAO,EAAE,GAAG,CAAC,CAAC,aAAa,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE,CAAC;QACjD,CAAC;aAAM,CAAC;YACN,sBAAsB;YACtB,OAAO,EAAE,GAAG,CAAC,CAAC,aAAa,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE,CAAC;QACjD,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,4BAA4B,CAAC,OAAiC;QACpE,MAAM,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC,WAAW,CAAC;QACnD,MAAM,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC;QACrD,MAAM,SAAS,GAAG,OAAO,CAAC,cAAc,CAAC,aAAa,CAAC;QAEvD,8BAA8B;QAC9B,OAAO,CAAC,OAAO,GAAG,GAAG,GAAG,QAAQ,GAAG,GAAG,GAAG,SAAS,GAAG,GAAG,CAAC,CAAC;IAC5D,CAAC;IAED;;;;OAIG;IACK,6BAA6B,CAAC,OAAiC;QACrE,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QAE9D,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,GAAG,CAAC,CAAC,kBAAkB;QAEtD,oDAAoD;QACpD,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;QACrE,IAAI,IAAI,KAAK,CAAC;YAAE,OAAO,GAAG,CAAC,CAAC,sBAAsB;QAElD,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7F,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAClC,MAAM,EAAE,GAAG,KAAK,GAAG,IAAI,CAAC;QAExB,kDAAkD;QAClD,0CAA0C;QAC1C,oCAAoC;QACpC,+CAA+C;QAC/C,sCAAsC;QAEtC,IAAI,EAAE,GAAG,GAAG,EAAE,CAAC;YACb,OAAO,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,GAAG,EAAE,CAAC;QAClC,CAAC;aAAM,IAAI,EAAE,GAAG,GAAG,EAAE,CAAC;YACpB,OAAO,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE,CAAC;QAC1C,CAAC;aAAM,IAAI,EAAE,GAAG,GAAG,EAAE,CAAC;YACpB,OAAO,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,4BAA4B,CAAC,OAAiC;QACpE,6DAA6D;QAC7D,kBAAkB;QAClB,8BAA8B;QAC9B,sBAAsB;QACtB,2BAA2B;QAE3B,sCAAsC;QACtC,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;;OAIG;IACK,uBAAuB,CAAC,OAAiC;QAC/D,kEAAkE;QAClE,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;YAC7B,gDAAgD;YAChD,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC;YAC7D,IAAI,YAAY,IAAI,CAAC;gBAAE,OAAO,CAAC,CAAC,CAAC,+BAA+B;YAChE,IAAI,YAAY,KAAK,CAAC;gBAAE,OAAO,EAAE,CAAC,CAAC,4BAA4B;YAC/D,OAAO,EAAE,CAAC,CAAC,4BAA4B;QACzC,CAAC;QAED,mDAAmD;QACnD,IAAI,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClD,sCAAsC;YACtC,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,gBAAgB;iBAClD,MAAM,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,CAC5B,SAAS,CAAC,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EACzD,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAEjB,MAAM,kBAAkB,GAAG,IAAI,CAAC,KAAK,CACnC,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,UAAU,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAC/D,CAAC;YAEF,gDAAgD;YAChD,IAAI,kBAAkB,GAAG,CAAC;gBAAE,OAAO,EAAE,CAAC,CAAC,4BAA4B;YACnE,IAAI,kBAAkB,GAAG,EAAE;gBAAE,OAAO,EAAE,CAAC,CAAC,6BAA6B;YACrE,OAAO,EAAE,CAAC,CAAC,4BAA4B;QACzC,CAAC;QAED,eAAe;QACf,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;OAGG;IACK,eAAe,CAAC,OAAiC;QACvD,gCAAgC;QAChC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC;aAC3D,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;QAEtC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrB,6BAA6B;YAC7B,OAAO,CAAC,UAAU,CAAC,MAAM,GAAG;gBAC1B,QAAQ,EAAE,CAAC;gBACX,aAAa,EAAE,CAAC;gBAChB,UAAU,EAAE,CAAC;gBACb,YAAY,EAAE,CAAC;aAChB,CAAC;YACF,OAAO;QACT,CAAC;QAED,gEAAgE;QAChE,MAAM,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACvC,MAAM,aAAa,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAEzC,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,6BAA6B;YAC7B,OAAO;QACT,CAAC;QAED,qCAAqC;QACrC,MAAM,iBAAiB,GAAG,YAAY,CAAC,MAAM,CAC3C,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC,CAClE,GAAG,YAAY,CAAC,MAAM,CAAC;QAExB,MAAM,kBAAkB,GAAG,aAAa,CAAC,MAAM,CAC7C,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC,CAClE,GAAG,aAAa,CAAC,MAAM,CAAC;QAEzB,2BAA2B;QAC3B,MAAM,gBAAgB,GAAG,CAAC,CAAC,iBAAiB,GAAG,kBAAkB,CAAC,GAAG,kBAAkB,CAAC,GAAG,GAAG,CAAC;QAE/F,0EAA0E;QAC1E,qDAAqD;QACrD,OAAO,CAAC,UAAU,CAAC,MAAM,GAAG;YAC1B,QAAQ,EAAE,gBAAgB;YAC1B,aAAa,EAAE,CAAC,gBAAgB,EAAE,gDAAgD;YAClF,UAAU,EAAE,CAAC,gBAAgB,EAAE,0BAA0B;YACzD,YAAY,EAAE,CAAC,gBAAgB,CAAC,4BAA4B;SAC7D,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,oBAAoB,CAAC,OAAiC;QAC5D,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC;QAC/C,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACrD,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAEnE,yBAAyB;QACzB,IAAI,UAAU,GAAG,UAAU,CAAC,kBAAkB,EAAE,CAAC;YAC/C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,kBAAkB,EAAE;gBACjD,KAAK,EAAE,UAAU;gBACjB,SAAS,EAAE,UAAU,CAAC,kBAAkB;aACzC,CAAC,CAAC;QACL,CAAC;QAED,uBAAuB;QACvB,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,GAAG,UAAU,CAAC,gBAAgB,EAAE,CAAC;YAC1D,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,gBAAgB,EAAE;gBAC/C,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,IAAI;gBAC7B,SAAS,EAAE,UAAU,CAAC,gBAAgB;aACvC,CAAC,CAAC;QACL,CAAC;QAED,oBAAoB;QACpB,MAAM,UAAU,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC;YAC1E,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;QAEzC,IAAI,UAAU,GAAG,UAAU,CAAC,aAAa,EAAE,CAAC;YAC1C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE;gBAC5C,IAAI,EAAE,UAAU;gBAChB,SAAS,EAAE,UAAU,CAAC,aAAa;aACpC,CAAC,CAAC;QACL,CAAC;QAED,kBAAkB;QAClB,IAAI,OAAO,CAAC,UAAU,CAAC,QAAQ,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;YACzD,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE;gBAC1C,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,QAAQ;gBACjC,SAAS,EAAE,UAAU,CAAC,WAAW;aAClC,CAAC,CAAC;QACL,CAAC;QAED,yBAAyB;QACzB,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;YAC7B,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE;gBAC1C,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;aACzD,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,SAAS,CAAC,MAAc,EAAE,SAAiB,EAAE,IAAS;QAC5D,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,wBAAwB,MAAM,KAAK,SAAS,EAAE,EAAE,IAAI,CAAC,CAAC;QAEzE,+DAA+D;QAC/D,uCAAuC;IACzC,CAAC;IAED;;;;OAIG;IACI,eAAe,CAAC,MAAc,EAAE,KAKtC;QACC,yCAAyC;QACzC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YACrC,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;QACpC,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAChD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;QAC/B,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAErD,qCAAqC;QACrC,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;YACnB,KAAK,MAAM;gBACT,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,KAAK,CAAC;gBAC7B,2BAA2B;gBAC3B,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC;oBACnC,CAAC,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC;gBACvD,MAAM;YAER,KAAK,WAAW;gBACd,OAAO,CAAC,MAAM,CAAC,SAAS,IAAI,KAAK,CAAC;gBAClC,MAAM;YAER,KAAK,QAAQ;gBACX,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;oBACrB,OAAO,CAAC,MAAM,CAAC,WAAW,IAAI,KAAK,CAAC;gBACtC,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,MAAM,CAAC,WAAW,IAAI,KAAK,CAAC;gBACtC,CAAC;gBACD,MAAM;YAER,KAAK,WAAW;gBACd,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,KAAK,CAAC;gBAElC,4BAA4B;gBAC5B,IAAI,KAAK,CAAC,eAAe,EAAE,CAAC;oBAC1B,MAAM,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,SAAS,CACzD,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,eAAe,CACxC,CAAC;oBAEF,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;wBACrB,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,KAAK,IAAI,KAAK,CAAC;wBAC1D,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,IAAI;4BAC7C,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;oBACxF,CAAC;yBAAM,CAAC;wBACN,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC;4BACjC,MAAM,EAAE,KAAK,CAAC,eAAe;4BAC7B,KAAK;4BACL,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;yBAC/C,CAAC,CAAC;oBACL,CAAC;oBAED,gBAAgB;oBAChB,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;oBAEhE,mBAAmB;oBACnB,IAAI,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;wBAC9C,OAAO,CAAC,UAAU,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;oBAC7E,CAAC;gBACH,CAAC;gBAED,gCAAgC;gBAChC,OAAO,CAAC,UAAU,CAAC,IAAI;oBACrB,OAAO,CAAC,UAAU,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBAC9D,MAAM;YAER,KAAK,MAAM;gBACT,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,KAAK,CAAC;gBAClC,OAAO,CAAC,UAAU,CAAC,QAAQ;oBACzB,OAAO,CAAC,UAAU,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;gBACnE,MAAM;YAER,KAAK,OAAO;gBACV,OAAO,CAAC,UAAU,CAAC,MAAM,IAAI,KAAK,CAAC;gBACnC,OAAO,CAAC,UAAU,CAAC,SAAS;oBAC1B,OAAO,CAAC,UAAU,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;gBACpE,OAAO,CAAC,UAAU,CAAC,eAAe;oBAChC,OAAO,CAAC,UAAU,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;gBACpE,MAAM;QACV,CAAC;QAED,gCAAgC;QAChC,OAAO,CAAC,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC;QAEjC,wEAAwE;QACxE,2BAA2B;QAC3B,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;QAC1F,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,mCAAmC;YACnF,IAAI,CAAC,kBAAkB,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;gBACtC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,mCAAmC,KAAK,CAAC,OAAO,EAAE,EAAE;oBACtE,KAAK,EAAE,KAAK,CAAC,KAAK;iBACnB,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,iBAAiB,CAAC,MAAc;QACrC,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC;IACjD,CAAC;IAED;;;OAGG;IACI,oBAAoB;QAOzB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;aAC7C,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE;YACzB,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACrD,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAE9D,kCAAkC;YAClC,IAAI,MAA2D,CAAC;YAChE,IAAI,KAAK,IAAI,EAAE;gBAAE,MAAM,GAAG,WAAW,CAAC;iBACjC,IAAI,KAAK,IAAI,EAAE;gBAAE,MAAM,GAAG,MAAM,CAAC;iBACjC,IAAI,KAAK,IAAI,EAAE;gBAAE,MAAM,GAAG,MAAM,CAAC;iBACjC,IAAI,KAAK,IAAI,EAAE;gBAAE,MAAM,GAAG,MAAM,CAAC;;gBACjC,MAAM,GAAG,UAAU,CAAC;YAEzB,OAAO;gBACL,MAAM;gBACN,KAAK;gBACL,MAAM;gBACN,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,MAAM;gBAChC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,uCAAuC;aAClF,CAAC;QACJ,CAAC,CAAC;aACD,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,2BAA2B;IACnE,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,MAAc;QAC7B,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACzC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,MAAM,6BAA6B,CAAC,CAAC;YAClE,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACjC,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;QAClC,IAAI,CAAC,kBAAkB,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;YACtC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,uDAAuD,KAAK,CAAC,OAAO,EAAE,EAAE;gBAC1F,KAAK,EAAE,KAAK,CAAC,KAAK;aACnB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,MAAM,2BAA2B,CAAC,CAAC;IACjE,CAAC;IAED;;;OAGG;IACI,YAAY,CAAC,MAAc;QAChC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAClD,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,MAAM,yBAAyB,CAAC,CAAC;YAC9D,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QACrC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACnC,IAAI,CAAC,kBAAkB,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;YACtC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,yDAAyD,KAAK,CAAC,OAAO,EAAE,EAAE;gBAC5F,KAAK,EAAE,KAAK,CAAC,KAAK;aACnB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,MAAM,6BAA6B,CAAC,CAAC;IACrE,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,kBAAkB;QAC9B,0EAA0E;QAC1E,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;QAC1F,IAAI,iBAAiB,EAAE,CAAC;YACtB,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,yCAAyC;YACzC,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;gBACxB,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,0CAA0C,CAAC,CAAC;oBACvF,IAAI,IAAI,EAAE,CAAC;wBACT,MAAM,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;wBAE3C,KAAK,MAAM,KAAK,IAAI,iBAAiB,EAAE,CAAC;4BACtC,uBAAuB;4BACvB,KAAK,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;4BAEhD,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;gCACrD,OAAO,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;4BACtD,CAAC;4BAED,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC;gCACzD,SAAS,CAAC,UAAU,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;gCACtD,SAAS,CAAC,QAAQ,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;4BACpD,CAAC;4BAED,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;wBAC/C,CAAC;wBAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,8BAA8B,IAAI,CAAC,cAAc,CAAC,IAAI,8BAA8B,CAAC,CAAC;wBACzG,OAAO;oBACT,CAAC;gBACH,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,6CAA6C;gBAC/C,CAAC;gBAED,uEAAuE;gBACvE,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;gBACrE,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,wBAAwB,CAAC,CAAC;gBAE5E,IAAI,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACpC,MAAM,IAAI,GAAG,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;oBACvD,MAAM,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;oBAE3C,KAAK,MAAM,KAAK,IAAI,iBAAiB,EAAE,CAAC;wBACtC,uBAAuB;wBACvB,KAAK,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;wBAEhD,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;4BACrD,OAAO,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;wBACtD,CAAC;wBAED,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC;4BACzD,SAAS,CAAC,UAAU,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;4BACtD,SAAS,CAAC,QAAQ,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;wBACpD,CAAC;wBAED,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;oBAC/C,CAAC;oBAED,6BAA6B;oBAC7B,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iCAAiC,IAAI,CAAC,cAAc,CAAC,IAAI,4CAA4C,CAAC,CAAC;oBAC1H,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAC3B,0CAA0C,EAC1C,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAClE,CAAC;oBAEF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,2CAA2C,IAAI,CAAC,cAAc,CAAC,IAAI,UAAU,CAAC,CAAC;gBACpG,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,8CAA8C;gBAC9C,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;gBACrE,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;gBAElD,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,wBAAwB,CAAC,CAAC;gBAE5E,IAAI,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACpC,MAAM,IAAI,GAAG,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;oBACvD,MAAM,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;oBAE3C,KAAK,MAAM,KAAK,IAAI,iBAAiB,EAAE,CAAC;wBACtC,uBAAuB;wBACvB,KAAK,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;wBAEhD,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;4BACrD,OAAO,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;wBACtD,CAAC;wBAED,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC;4BACzD,SAAS,CAAC,UAAU,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;4BACtD,SAAS,CAAC,QAAQ,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;wBACpD,CAAC;wBAED,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;oBAC/C,CAAC;oBAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,8BAA8B,IAAI,CAAC,cAAc,CAAC,IAAI,0BAA0B,CAAC,CAAC;gBACvG,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,mCAAmC,KAAK,CAAC,OAAO,EAAE,EAAE;gBACtE,KAAK,EAAE,KAAK,CAAC,KAAK;aACnB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,kBAAkB;QAC9B,yEAAyE;QACzE,MAAM,iBAAiB,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;QAC1F,IAAI,iBAAiB,EAAE,CAAC;YACtB,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,MAAM,iBAAiB,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC;YAEnE,uCAAuC;YACvC,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;gBACxB,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAC3B,0CAA0C,EAC1C,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC,CAC3C,CAAC;gBACF,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,6BAA6B,iBAAiB,CAAC,MAAM,4BAA4B,CAAC,CAAC;YACzG,CAAC;iBAAM,CAAC;gBACN,8CAA8C;gBAC9C,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;gBACrE,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;gBAElD,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,wBAAwB,CAAC,CAAC;gBAE5E,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAC/B,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC,EAC1C,QAAQ,CACT,CAAC;gBAEF,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,6BAA6B,iBAAiB,CAAC,MAAM,wBAAwB,CAAC,CAAC;YACrG,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,mCAAmC,KAAK,CAAC,OAAO,EAAE,EAAE;gBACtE,KAAK,EAAE,KAAK,CAAC,KAAK;aACnB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;CACF"}