@push.rocks/smartmta 5.1.2 → 5.2.0

package/dist_ts/mail/delivery/classes.delivery.queue.d.ts

@@ -0,0 +1,163 @@
+import { EventEmitter } from 'node:events';
+import { type EmailProcessingMode } from './interfaces.js';
+import type { IEmailRoute } from '../routing/interfaces.js';
+/**
+ * Queue item status
+ */
+export type QueueItemStatus = 'pending' | 'processing' | 'delivered' | 'failed' | 'deferred';
+/**
+ * Queue item interface
+ */
+export interface IQueueItem {
+    id: string;
+    processingMode: EmailProcessingMode;
+    processingResult: any;
+    route: IEmailRoute;
+    status: QueueItemStatus;
+    attempts: number;
+    nextAttempt: Date;
+    lastError?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    deliveredAt?: Date;
+}
+/**
+ * Queue options interface
+ */
+export interface IQueueOptions {
+    storageType?: 'memory' | 'disk';
+    persistentPath?: string;
+    checkInterval?: number;
+    maxQueueSize?: number;
+    maxPerDestination?: number;
+    maxRetries?: number;
+    baseRetryDelay?: number;
+    maxRetryDelay?: number;
+}
+/**
+ * Queue statistics interface
+ */
+export interface IQueueStats {
+    queueSize: number;
+    status: {
+        pending: number;
+        processing: number;
+        delivered: number;
+        failed: number;
+        deferred: number;
+    };
+    modes: {
+        forward: number;
+        mta: number;
+        process: number;
+    };
+    oldestItem?: Date;
+    newestItem?: Date;
+    averageAttempts: number;
+    totalProcessed: number;
+    processingActive: boolean;
+}
+/**
+ * A unified queue for all email modes
+ */
+export declare class UnifiedDeliveryQueue extends EventEmitter {
+    private options;
+    private queue;
+    private checkTimer?;
+    private stats;
+    private processing;
+    private totalProcessed;
+    /**
+     * Create a new unified delivery queue
+     * @param options Queue options
+     */
+    constructor(options: IQueueOptions);
+    /**
+     * Initialize the queue
+     */
+    initialize(): Promise<void>;
+    /**
+     * Start queue processing
+     */
+    private startProcessing;
+    /**
+     * Stop queue processing
+     */
+    private stopProcessing;
+    /**
+     * Check for items that need to be processed
+     */
+    private processQueue;
+    /**
+     * Add an item to the queue
+     * @param processingResult Processing result to queue
+     * @param mode Processing mode
+     * @param route Email route
+     */
+    enqueue(processingResult: any, mode: EmailProcessingMode, route: IEmailRoute): Promise<string>;
+    /**
+     * Get an item from the queue
+     * @param id Item ID
+     */
+    getItem(id: string): IQueueItem | undefined;
+    /**
+     * Mark an item as being processed
+     * @param id Item ID
+     */
+    markProcessing(id: string): Promise<boolean>;
+    /**
+     * Mark an item as delivered
+     * @param id Item ID
+     */
+    markDelivered(id: string): Promise<boolean>;
+    /**
+     * Mark an item as failed
+     * @param id Item ID
+     * @param error Error message
+     */
+    markFailed(id: string, error: string): Promise<boolean>;
+    /**
+     * Remove an item from the queue
+     * @param id Item ID
+     */
+    removeItem(id: string): Promise<boolean>;
+    /**
+     * Persist an item to disk
+     * @param item Item to persist
+     */
+    private persistItem;
+    /**
+     * Remove an item from disk
+     * @param id Item ID
+     */
+    private removeItemFromDisk;
+    /**
+     * Load queue items from disk
+     */
+    private loadFromDisk;
+    /**
+     * Update queue statistics
+     */
+    private updateStats;
+    /**
+     * Get queue statistics
+     */
+    getStats(): IQueueStats;
+    /**
+     * Pause queue processing
+     */
+    pause(): void;
+    /**
+     * Resume queue processing
+     */
+    resume(): void;
+    /**
+     * Clean up old delivered and failed items
+     * @param maxAge Maximum age in milliseconds (default: 7 days)
+     */
+    cleanupOldItems(maxAge?: number): Promise<number>;
+    /**
+     * Shutdown the queue
+     */
+    shutdown(): Promise<void>;
+}

package/dist_ts/mail/delivery/classes.delivery.queue.js

@@ -0,0 +1,488 @@
+import * as plugins from '../../plugins.js';
+import { EventEmitter } from 'node:events';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { logger } from '../../logger.js';
+import {} from './interfaces.js';
+/**
+ * A unified queue for all email modes
+ */
+export class UnifiedDeliveryQueue extends EventEmitter {
+    options;
+    queue = new Map();
+    checkTimer;
+    stats;
+    processing = false;
+    totalProcessed = 0;
+    /**
+     * Create a new unified delivery queue
+     * @param options Queue options
+     */
+    constructor(options) {
+        super();
+        // Set default options
+        this.options = {
+            storageType: options.storageType || 'memory',
+            persistentPath: options.persistentPath || path.join(process.cwd(), 'email-queue'),
+            checkInterval: options.checkInterval || 30000, // 30 seconds
+            maxQueueSize: options.maxQueueSize || 10000,
+            maxPerDestination: options.maxPerDestination || 100,
+            maxRetries: options.maxRetries || 5,
+            baseRetryDelay: options.baseRetryDelay || 60000, // 1 minute
+            maxRetryDelay: options.maxRetryDelay || 3600000 // 1 hour
+        };
+        // Initialize statistics
+        this.stats = {
+            queueSize: 0,
+            status: {
+                pending: 0,
+                processing: 0,
+                delivered: 0,
+                failed: 0,
+                deferred: 0
+            },
+            modes: {
+                forward: 0,
+                mta: 0,
+                process: 0
+            },
+            averageAttempts: 0,
+            totalProcessed: 0,
+            processingActive: false
+        };
+    }
+    /**
+     * Initialize the queue
+     */
+    async initialize() {
+        logger.log('info', 'Initializing UnifiedDeliveryQueue');
+        try {
+            // Create persistent storage directory if using disk storage
+            if (this.options.storageType === 'disk') {
+                if (!fs.existsSync(this.options.persistentPath)) {
+                    fs.mkdirSync(this.options.persistentPath, { recursive: true });
+                }
+                // Load existing items from disk
+                await this.loadFromDisk();
+            }
+            // Start the queue processing timer
+            this.startProcessing();
+            // Emit initialized event
+            this.emit('initialized');
+            logger.log('info', 'UnifiedDeliveryQueue initialized successfully');
+        }
+        catch (error) {
+            logger.log('error', `Failed to initialize queue: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Start queue processing
+     */
+    startProcessing() {
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+        }
+        this.checkTimer = setInterval(() => this.processQueue(), this.options.checkInterval);
+        this.processing = true;
+        this.stats.processingActive = true;
+        this.emit('processingStarted');
+        logger.log('info', 'Queue processing started');
+    }
+    /**
+     * Stop queue processing
+     */
+    stopProcessing() {
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = undefined;
+        }
+        this.processing = false;
+        this.stats.processingActive = false;
+        this.emit('processingStopped');
+        logger.log('info', 'Queue processing stopped');
+    }
+    /**
+     * Check for items that need to be processed
+     */
+    async processQueue() {
+        try {
+            const now = new Date();
+            let readyItems = [];
+            // Find items ready for processing
+            for (const item of this.queue.values()) {
+                if (item.status === 'pending' || (item.status === 'deferred' && item.nextAttempt <= now)) {
+                    readyItems.push(item);
+                }
+            }
+            if (readyItems.length === 0) {
+                return;
+            }
+            // Sort by oldest first
+            readyItems.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+            // Emit event for ready items
+            this.emit('itemsReady', readyItems);
+            logger.log('info', `Found ${readyItems.length} items ready for processing`);
+            // Update statistics
+            this.updateStats();
+        }
+        catch (error) {
+            logger.log('error', `Error processing queue: ${error.message}`);
+            this.emit('error', error);
+        }
+    }
+    /**
+     * Add an item to the queue
+     * @param processingResult Processing result to queue
+     * @param mode Processing mode
+     * @param route Email route
+     */
+    async enqueue(processingResult, mode, route) {
+        // Check if queue is full
+        if (this.queue.size >= this.options.maxQueueSize) {
+            throw new Error('Queue is full');
+        }
+        // Generate a unique ID
+        const id = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+        // Create queue item
+        const item = {
+            id,
+            processingMode: mode,
+            processingResult,
+            route,
+            status: 'pending',
+            attempts: 0,
+            nextAttempt: new Date(),
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+        // Add to queue
+        this.queue.set(id, item);
+        // Persist to disk if using disk storage
+        if (this.options.storageType === 'disk') {
+            await this.persistItem(item);
+        }
+        // Update statistics
+        this.updateStats();
+        // Emit event
+        this.emit('itemEnqueued', item);
+        logger.log('info', `Item enqueued with ID ${id}, mode: ${mode}`);
+        return id;
+    }
+    /**
+     * Get an item from the queue
+     * @param id Item ID
+     */
+    getItem(id) {
+        return this.queue.get(id);
+    }
+    /**
+     * Mark an item as being processed
+     * @param id Item ID
+     */
+    async markProcessing(id) {
+        const item = this.queue.get(id);
+        if (!item) {
+            return false;
+        }
+        // Update status
+        item.status = 'processing';
+        item.attempts++;
+        item.updatedAt = new Date();
+        // Persist changes if using disk storage
+        if (this.options.storageType === 'disk') {
+            await this.persistItem(item);
+        }
+        // Update statistics
+        this.updateStats();
+        // Emit event
+        this.emit('itemProcessing', item);
+        logger.log('info', `Item ${id} marked as processing, attempt ${item.attempts}`);
+        return true;
+    }
+    /**
+     * Mark an item as delivered
+     * @param id Item ID
+     */
+    async markDelivered(id) {
+        const item = this.queue.get(id);
+        if (!item) {
+            return false;
+        }
+        // Update status
+        item.status = 'delivered';
+        item.updatedAt = new Date();
+        item.deliveredAt = new Date();
+        // Persist changes if using disk storage
+        if (this.options.storageType === 'disk') {
+            await this.persistItem(item);
+        }
+        // Update statistics
+        this.totalProcessed++;
+        this.updateStats();
+        // Emit event
+        this.emit('itemDelivered', item);
+        logger.log('info', `Item ${id} marked as delivered after ${item.attempts} attempts`);
+        return true;
+    }
+    /**
+     * Mark an item as failed
+     * @param id Item ID
+     * @param error Error message
+     */
+    async markFailed(id, error) {
+        const item = this.queue.get(id);
+        if (!item) {
+            return false;
+        }
+        // Determine if we should retry
+        if (item.attempts < this.options.maxRetries) {
+            // Calculate next retry time with exponential backoff
+            const delay = Math.min(this.options.baseRetryDelay * Math.pow(2, item.attempts - 1), this.options.maxRetryDelay);
+            // Update status
+            item.status = 'deferred';
+            item.lastError = error;
+            item.nextAttempt = new Date(Date.now() + delay);
+            item.updatedAt = new Date();
+            // Persist changes if using disk storage
+            if (this.options.storageType === 'disk') {
+                await this.persistItem(item);
+            }
+            // Emit event
+            this.emit('itemDeferred', item);
+            logger.log('info', `Item ${id} deferred for ${delay}ms, attempt ${item.attempts}, error: ${error}`);
+        }
+        else {
+            // Mark as permanently failed
+            item.status = 'failed';
+            item.lastError = error;
+            item.updatedAt = new Date();
+            // Persist changes if using disk storage
+            if (this.options.storageType === 'disk') {
+                await this.persistItem(item);
+            }
+            // Update statistics
+            this.totalProcessed++;
+            // Emit event
+            this.emit('itemFailed', item);
+            logger.log('warn', `Item ${id} permanently failed after ${item.attempts} attempts, error: ${error}`);
+        }
+        // Update statistics
+        this.updateStats();
+        return true;
+    }
+    /**
+     * Remove an item from the queue
+     * @param id Item ID
+     */
+    async removeItem(id) {
+        const item = this.queue.get(id);
+        if (!item) {
+            return false;
+        }
+        // Remove from queue
+        this.queue.delete(id);
+        // Remove from disk if using disk storage
+        if (this.options.storageType === 'disk') {
+            await this.removeItemFromDisk(id);
+        }
+        // Update statistics
+        this.updateStats();
+        // Emit event
+        this.emit('itemRemoved', item);
+        logger.log('info', `Item ${id} removed from queue`);
+        return true;
+    }
+    /**
+     * Persist an item to disk
+     * @param item Item to persist
+     */
+    async persistItem(item) {
+        try {
+            const filePath = path.join(this.options.persistentPath, `${item.id}.json`);
+            await fs.promises.writeFile(filePath, JSON.stringify(item, null, 2), 'utf8');
+        }
+        catch (error) {
+            logger.log('error', `Failed to persist item ${item.id}: ${error.message}`);
+            this.emit('error', error);
+        }
+    }
+    /**
+     * Remove an item from disk
+     * @param id Item ID
+     */
+    async removeItemFromDisk(id) {
+        try {
+            const filePath = path.join(this.options.persistentPath, `${id}.json`);
+            if (fs.existsSync(filePath)) {
+                await fs.promises.unlink(filePath);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to remove item ${id} from disk: ${error.message}`);
+            this.emit('error', error);
+        }
+    }
+    /**
+     * Load queue items from disk
+     */
+    async loadFromDisk() {
+        try {
+            // Check if directory exists
+            if (!fs.existsSync(this.options.persistentPath)) {
+                return;
+            }
+            // Get all JSON files
+            const files = fs.readdirSync(this.options.persistentPath).filter(file => file.endsWith('.json'));
+            // Load each file
+            for (const file of files) {
+                try {
+                    const filePath = path.join(this.options.persistentPath, file);
+                    const data = await fs.promises.readFile(filePath, 'utf8');
+                    const item = JSON.parse(data);
+                    // Convert date strings to Date objects
+                    item.createdAt = new Date(item.createdAt);
+                    item.updatedAt = new Date(item.updatedAt);
+                    item.nextAttempt = new Date(item.nextAttempt);
+                    if (item.deliveredAt) {
+                        item.deliveredAt = new Date(item.deliveredAt);
+                    }
+                    // Add to queue
+                    this.queue.set(item.id, item);
+                }
+                catch (error) {
+                    logger.log('error', `Failed to load item from ${file}: ${error.message}`);
+                }
+            }
+            // Update statistics
+            this.updateStats();
+            logger.log('info', `Loaded ${this.queue.size} items from disk`);
+        }
+        catch (error) {
+            logger.log('error', `Failed to load items from disk: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Update queue statistics
+     */
+    updateStats() {
+        // Reset counters
+        this.stats.queueSize = this.queue.size;
+        this.stats.status = {
+            pending: 0,
+            processing: 0,
+            delivered: 0,
+            failed: 0,
+            deferred: 0
+        };
+        this.stats.modes = {
+            forward: 0,
+            mta: 0,
+            process: 0
+        };
+        let totalAttempts = 0;
+        let oldestTime = Date.now();
+        let newestTime = 0;
+        // Count by status and mode
+        for (const item of this.queue.values()) {
+            // Count by status
+            this.stats.status[item.status]++;
+            // Count by mode
+            this.stats.modes[item.processingMode]++;
+            // Track total attempts
+            totalAttempts += item.attempts;
+            // Track oldest and newest
+            const itemTime = item.createdAt.getTime();
+            if (itemTime < oldestTime) {
+                oldestTime = itemTime;
+            }
+            if (itemTime > newestTime) {
+                newestTime = itemTime;
+            }
+        }
+        // Calculate average attempts
+        this.stats.averageAttempts = this.queue.size > 0 ? totalAttempts / this.queue.size : 0;
+        // Set oldest and newest
+        this.stats.oldestItem = this.queue.size > 0 ? new Date(oldestTime) : undefined;
+        this.stats.newestItem = this.queue.size > 0 ? new Date(newestTime) : undefined;
+        // Set total processed
+        this.stats.totalProcessed = this.totalProcessed;
+        // Set processing active
+        this.stats.processingActive = this.processing;
+        // Emit statistics event
+        this.emit('statsUpdated', this.stats);
+    }
+    /**
+     * Get queue statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Pause queue processing
+     */
+    pause() {
+        if (this.processing) {
+            this.stopProcessing();
+            logger.log('info', 'Queue processing paused');
+        }
+    }
+    /**
+     * Resume queue processing
+     */
+    resume() {
+        if (!this.processing) {
+            this.startProcessing();
+            logger.log('info', 'Queue processing resumed');
+        }
+    }
+    /**
+     * Clean up old delivered and failed items
+     * @param maxAge Maximum age in milliseconds (default: 7 days)
+     */
+    async cleanupOldItems(maxAge = 7 * 24 * 60 * 60 * 1000) {
+        const cutoff = new Date(Date.now() - maxAge);
+        let removedCount = 0;
+        // Find old items
+        for (const item of this.queue.values()) {
+            if (['delivered', 'failed'].includes(item.status) && item.updatedAt < cutoff) {
+                // Remove item
+                await this.removeItem(item.id);
+                removedCount++;
+            }
+        }
+        logger.log('info', `Cleaned up ${removedCount} old items`);
+        return removedCount;
+    }
+    /**
+     * Shutdown the queue
+     */
+    async shutdown() {
+        logger.log('info', 'Shutting down UnifiedDeliveryQueue');
+        // Stop processing
+        this.stopProcessing();
+        // Clear the check timer to prevent memory leaks
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = undefined;
+        }
+        // If using disk storage, make sure all items are persisted
+        if (this.options.storageType === 'disk') {
+            const pendingWrites = [];
+            for (const item of this.queue.values()) {
+                pendingWrites.push(this.persistItem(item));
+            }
+            // Wait for all writes to complete
+            await Promise.all(pendingWrites);
+        }
+        // Clear the queue (memory only)
+        this.queue.clear();
+        // Update statistics
+        this.updateStats();
+        // Emit shutdown event
+        this.emit('shutdown');
+        logger.log('info', 'UnifiedDeliveryQueue shut down successfully');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.delivery.queue.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.delivery.queue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAA4B,MAAM,iBAAiB,CAAC;AAoE3D;;GAEG;AACH,MAAM,OAAO,oBAAqB,SAAQ,YAAY;IAC5C,OAAO,CAA0B;IACjC,KAAK,GAA4B,IAAI,GAAG,EAAE,CAAC;IAC3C,UAAU,CAAkB;IAC5B,KAAK,CAAc;IACnB,UAAU,GAAY,KAAK,CAAC;IAC5B,cAAc,GAAW,CAAC,CAAC;IAEnC;;;OAGG;IACH,YAAY,OAAsB;QAChC,KAAK,EAAE,CAAC;QAER,sBAAsB;QACtB,IAAI,CAAC,OAAO,GAAG;YACb,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,QAAQ;YAC5C,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,aAAa,CAAC;YACjF,aAAa,EAAE,OAAO,CAAC,aAAa,IAAI,KAAK,EAAE,aAAa;YAC5D,YAAY,EAAE,OAAO,CAAC,YAAY,IAAI,KAAK;YAC3C,iBAAiB,EAAE,OAAO,CAAC,iBAAiB,IAAI,GAAG;YACnD,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,CAAC;YACnC,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,KAAK,EAAE,WAAW;YAC5D,aAAa,EAAE,OAAO,CAAC,aAAa,IAAI,OAAO,CAAC,SAAS;SAC1D,CAAC;QAEF,wBAAwB;QACxB,IAAI,CAAC,KAAK,GAAG;YACX,SAAS,EAAE,CAAC;YACZ,MAAM,EAAE;gBACN,OAAO,EAAE,CAAC;gBACV,UAAU,EAAE,CAAC;gBACb,SAAS,EAAE,CAAC;gBACZ,MAAM,EAAE,CAAC;gBACT,QAAQ,EAAE,CAAC;aACZ;YACD,KAAK,EAAE;gBACL,OAAO,EAAE,CAAC;gBACV,GAAG,EAAE,CAAC;gBACN,OAAO,EAAE,CAAC;aACX;YACD,eAAe,EAAE,CAAC;YAClB,cAAc,EAAE,CAAC;YACjB,gBAAgB,EAAE,KAAK;SACxB,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,UAAU;QACrB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,mCAAmC,CAAC,CAAC;QAExD,IAAI,CAAC;YACH,4DAA4D;YAC5D,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;gBACxC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;oBAChD,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;gBACjE,CAAC;gBAED,gCAAgC;gBAChC,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5B,CAAC;YAED,mCAAmC;YACnC,IAAI,CAAC,eAAe,EAAE,CAAC;YAEvB,yBAAyB;YACzB,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACzB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,+CAA+C,CAAC,CAAC;QACtE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,+BAA+B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACpE,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,eAAe;QACrB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACjC,CAAC;QAED,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QACrF,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC;QACnC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;IACjD,CAAC;IAED;;OAEG;IACK,cAAc;QACpB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC/B,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC9B,CAAC;QAED,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,gBAAgB,GAAG,KAAK,CAAC;QACpC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;IACjD,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY;QACxB,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,IAAI,UAAU,GAAiB,EAAE,CAAC;YAElC,kCAAkC;YAClC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;gBACvC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,UAAU,IAAI,IAAI,CAAC,WAAW,IAAI,GAAG,CAAC,EAAE,CAAC;oBACzF,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACxB,CAAC;YACH,CAAC;YAED,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC5B,OAAO;YACT,CAAC;YAED,uBAAuB;YACvB,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;YAEzE,6BAA6B;YAC7B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;YACpC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,UAAU,CAAC,MAAM,6BAA6B,CAAC,CAAC;YAE5E,oBAAoB;YACpB,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,2BAA2B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAChE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,OAAO,CAAC,gBAAqB,EAAE,IAAyB,EAAE,KAAkB;QACvF,yBAAyB;QACzB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;QACnC,CAAC;QAED,uBAAuB;QACvB,MAAM,EAAE,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QAE1E,oBAAoB;QACpB,MAAM,IAAI,GAAe;YACvB,EAAE;YACF,cAAc,EAAE,IAAI;YACpB,gBAAgB;YAChB,KAAK;YACL,MAAM,EAAE,SAAS;YACjB,QAAQ,EAAE,CAAC;YACX,WAAW,EAAE,IAAI,IAAI,EAAE;YACvB,SAAS,EAAE,IAAI,IAAI,EAAE;YACrB,SAAS,EAAE,IAAI,IAAI,EAAE;SACtB,CAAC;QAEF,eAAe;QACf,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QAEzB,wCAAwC;QACxC,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;YACxC,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;QAED,oBAAoB;QACpB,IAAI,CAAC,WAAW,EAAE,CAAC;QAEnB,aAAa;QACb,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;QAChC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,yBAAyB,EAAE,WAAW,IAAI,EAAE,CAAC,CAAC;QAEjE,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;OAGG;IACI,OAAO,CAAC,EAAU;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,cAAc,CAAC,EAAU;QACpC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAEhC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,KAAK,CAAC;QACf,CAAC;QAED,gBAAgB;QAChB,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC;QAC3B,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;QAE5B,wCAAwC;QACxC,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;YACxC,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;QAED,oBAAoB;QACpB,IAAI,CAAC,WAAW,EAAE,CAAC;QAEnB,aAAa;QACb,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC;QAClC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,kCAAkC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAEhF,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,aAAa,CAAC,EAAU;QACnC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAEhC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,KAAK,CAAC;QACf,CAAC;QAED,gBAAgB;QAChB,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC;QAC1B,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;QAC5B,IAAI,CAAC,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC;QAE9B,wCAAwC;QACxC,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;YACxC,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;QAED,oBAAoB;QACpB,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,WAAW,EAAE,CAAC;QAEnB,aAAa;QACb,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;QACjC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,8BAA8B,IAAI,CAAC,QAAQ,WAAW,CAAC,CAAC;QAErF,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,UAAU,CAAC,EAAU,EAAE,KAAa;QAC/C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAEhC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,KAAK,CAAC;QACf,CAAC;QAED,+BAA+B;QAC/B,IAAI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;YAC5C,qDAAqD;YACrD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CACpB,IAAI,CAAC,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,EAC5D,IAAI,CAAC,OAAO,CAAC,aAAa,CAC3B,CAAC;YAEF,gBAAgB;YAChB,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC;YACzB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC;YAChD,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;YAE5B,wCAAwC;YACxC,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;gBACxC,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAC/B,CAAC;YAED,aAAa;YACb,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;YAChC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,iBAAiB,KAAK,eAAe,IAAI,CAAC,QAAQ,YAAY,KAAK,EAAE,CAAC,CAAC;QACtG,CAAC;aAAM,CAAC;YACN,6BAA6B;YAC7B,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC;YACvB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;YAE5B,wCAAwC;YACxC,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;gBACxC,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAC/B,CAAC;YAED,oBAAoB;YACpB,IAAI,CAAC,cAAc,EAAE,CAAC;YAEtB,aAAa;YACb,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;YAC9B,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,6BAA6B,IAAI,CAAC,QAAQ,qBAAqB,KAAK,EAAE,CAAC,CAAC;QACvG,CAAC;QAED,oBAAoB;QACpB,IAAI,CAAC,WAAW,EAAE,CAAC;QAEnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,UAAU,CAAC,EAAU;QAChC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAEhC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,KAAK,CAAC;QACf,CAAC;QAED,oBAAoB;QACpB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAEtB,yCAAyC;QACzC,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;YACxC,MAAM,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC;QACpC,CAAC;QAED,oBAAoB;QACpB,IAAI,CAAC,WAAW,EAAE,CAAC;QAEnB,aAAa;QACb,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,qBAAqB,CAAC,CAAC;QAEpD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,WAAW,CAAC,IAAgB;QACxC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,GAAG,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;YAC3E,MAAM,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;QAC/E,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,0BAA0B,IAAI,CAAC,EAAE,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC3E,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,kBAAkB,CAAC,EAAU;QACzC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC;YAEtE,IAAI,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC5B,MAAM,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACrC,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,yBAAyB,EAAE,eAAe,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC/E,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY;QACxB,IAAI,CAAC;YACH,4BAA4B;YAC5B,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;gBAChD,OAAO;YACT,CAAC;YAED,qBAAqB;YACrB,MAAM,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;YAEjG,iBAAiB;YACjB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,IAAI,CAAC;oBACH,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;oBAC9D,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;oBAC1D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAe,CAAC;oBAE5C,uCAAuC;oBACvC,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBAC1C,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBAC1C,IAAI,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;oBAC9C,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;wBACrB,IAAI,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;oBAChD,CAAC;oBAED,eAAe;oBACf,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;gBAChC,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,4BAA4B,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;gBAC5E,CAAC;YACH,CAAC;YAED,oBAAoB;YACpB,IAAI,CAAC,WAAW,EAAE,CAAC;YAEnB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,IAAI,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,CAAC;QAClE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,mCAAmC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACxE,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,WAAW;QACjB,iBAAiB;QACjB,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;QACvC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG;YAClB,OAAO,EAAE,CAAC;YACV,UAAU,EAAE,CAAC;YACb,SAAS,EAAE,CAAC;YACZ,MAAM,EAAE,CAAC;YACT,QAAQ,EAAE,CAAC;SACZ,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG;YACjB,OAAO,EAAE,CAAC;YACV,GAAG,EAAE,CAAC;YACN,OAAO,EAAE,CAAC;SACX,CAAC;QAEF,IAAI,aAAa,GAAG,CAAC,CAAC;QACtB,IAAI,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC5B,IAAI,UAAU,GAAG,CAAC,CAAC;QAEnB,2BAA2B;QAC3B,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;YACvC,kBAAkB;YAClB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAEjC,gBAAgB;YAChB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;YAExC,uBAAuB;YACvB,aAAa,IAAI,IAAI,CAAC,QAAQ,CAAC;YAE/B,0BAA0B;YAC1B,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;YAC1C,IAAI,QAAQ,GAAG,UAAU,EAAE,CAAC;gBAC1B,UAAU,GAAG,QAAQ,CAAC;YACxB,CAAC;YACD,IAAI,QAAQ,GAAG,UAAU,EAAE,CAAC;gBAC1B,UAAU,GAAG,QAAQ,CAAC;YACxB,CAAC;QACH,CAAC;QAED,6BAA6B;QAC7B,IAAI,CAAC,KAAK,CAAC,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAEvF,wBAAwB;QACxB,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC/E,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAE/E,sBAAsB;QACtB,IAAI,CAAC,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;QAEhD,wBAAwB;QACxB,IAAI,CAAC,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC,UAAU,CAAC;QAE9C,wBAAwB;QACxB,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACI,QAAQ;QACb,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACI,KAAK;QACV,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED;;OAEG;IACI,MAAM;QACX,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,eAAe,CAAC,SAAiB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI;QACnE,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC;QAC7C,IAAI,YAAY,GAAG,CAAC,CAAC;QAErB,iBAAiB;QACjB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;YACvC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,SAAS,GAAG,MAAM,EAAE,CAAC;gBAC7E,cAAc;gBACd,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAC/B,YAAY,EAAE,CAAC;YACjB,CAAC;QACH,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,YAAY,YAAY,CAAC,CAAC;QAC3D,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,QAAQ;QACnB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,oCAAoC,CAAC,CAAC;QAEzD,kBAAkB;QAClB,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,gDAAgD;QAChD,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC/B,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC9B,CAAC;QAED,2DAA2D;QAC3D,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;YACxC,MAAM,aAAa,GAAoB,EAAE,CAAC;YAE1C,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;gBACvC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;YAC7C,CAAC;YAED,kCAAkC;YAClC,MAAM,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACnC,CAAC;QAED,gCAAgC;QAChC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QAEnB,oBAAoB;QACpB,IAAI,CAAC,WAAW,EAAE,CAAC;QAEnB,sBAAsB;QACtB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACtB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6CAA6C,CAAC,CAAC;IACpE,CAAC;CACF"}