@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/delivery/smtpserver/starttls-handler.d.ts

@@ -0,0 +1,21 @@
+/**
+ * STARTTLS Implementation
+ * Provides an improved implementation for STARTTLS upgrades
+ */
+import * as plugins from '../../../plugins.js';
+import type { ISmtpSession, ISessionManager, IConnectionManager } from './interfaces.js';
+import { SmtpState } from '../interfaces.js';
+/**
+ * Enhanced STARTTLS handler for more reliable TLS upgrades
+ */
+export declare function performStartTLS(socket: plugins.net.Socket, options: {
+    key: string;
+    cert: string;
+    ca?: string;
+    session?: ISmtpSession;
+    sessionManager?: ISessionManager;
+    connectionManager?: IConnectionManager;
+    onSuccess?: (tlsSocket: plugins.tls.TLSSocket) => void;
+    onFailure?: (error: Error) => void;
+    updateSessionState?: (session: ISmtpSession, state: SmtpState) => void;
+}): Promise<plugins.tls.TLSSocket | undefined>;

package/dist_ts/ts/mail/delivery/smtpserver/starttls-handler.js

@@ -0,0 +1,207 @@
+/**
+ * STARTTLS Implementation
+ * Provides an improved implementation for STARTTLS upgrades
+ */
+import * as plugins from '../../../plugins.js';
+import { SmtpLogger } from './utils/logging.js';
+import { loadCertificatesFromString, createTlsOptions } from './certificate-utils.js';
+import { getSocketDetails } from './utils/helpers.js';
+import { SmtpState } from '../interfaces.js';
+/**
+ * Enhanced STARTTLS handler for more reliable TLS upgrades
+ */
+export async function performStartTLS(socket, options) {
+    return new Promise((resolve) => {
+        try {
+            const socketDetails = getSocketDetails(socket);
+            SmtpLogger.info('Starting enhanced STARTTLS upgrade process', {
+                remoteAddress: socketDetails.remoteAddress,
+                remotePort: socketDetails.remotePort
+            });
+            // Create a proper socket cleanup function
+            const cleanupSocket = () => {
+                // Remove all listeners to prevent memory leaks
+                socket.removeAllListeners('data');
+                socket.removeAllListeners('error');
+                socket.removeAllListeners('close');
+                socket.removeAllListeners('end');
+                socket.removeAllListeners('drain');
+            };
+            // Prepare the socket for TLS upgrade
+            socket.setNoDelay(true);
+            // Critical: make sure there's no pending data before TLS handshake
+            socket.pause();
+            // Add error handling for the base socket
+            const handleSocketError = (err) => {
+                SmtpLogger.error(`Socket error during STARTTLS preparation: ${err.message}`, {
+                    remoteAddress: socketDetails.remoteAddress,
+                    remotePort: socketDetails.remotePort,
+                    error: err,
+                    stack: err.stack
+                });
+                if (options.onFailure) {
+                    options.onFailure(err);
+                }
+                // Resolve with undefined to indicate failure
+                resolve(undefined);
+            };
+            socket.once('error', handleSocketError);
+            // Load certificates
+            let certificates;
+            try {
+                certificates = loadCertificatesFromString({
+                    key: options.key,
+                    cert: options.cert,
+                    ca: options.ca
+                });
+            }
+            catch (certError) {
+                SmtpLogger.error(`Certificate error during STARTTLS: ${certError instanceof Error ? certError.message : String(certError)}`);
+                if (options.onFailure) {
+                    options.onFailure(certError instanceof Error ? certError : new Error(String(certError)));
+                }
+                resolve(undefined);
+                return;
+            }
+            // Create TLS options optimized for STARTTLS
+            const tlsOptions = createTlsOptions(certificates, true);
+            // Create secure context
+            let secureContext;
+            try {
+                secureContext = plugins.tls.createSecureContext(tlsOptions);
+            }
+            catch (contextError) {
+                SmtpLogger.error(`Failed to create secure context: ${contextError instanceof Error ? contextError.message : String(contextError)}`);
+                if (options.onFailure) {
+                    options.onFailure(contextError instanceof Error ? contextError : new Error(String(contextError)));
+                }
+                resolve(undefined);
+                return;
+            }
+            // Log STARTTLS upgrade attempt
+            SmtpLogger.debug('Attempting TLS socket upgrade with options', {
+                minVersion: tlsOptions.minVersion,
+                maxVersion: tlsOptions.maxVersion,
+                handshakeTimeout: tlsOptions.handshakeTimeout
+            });
+            // Use a safer approach to create the TLS socket
+            const handshakeTimeout = 30000; // 30 seconds timeout for TLS handshake
+            let handshakeTimeoutId;
+            // Create the TLS socket using a conservative approach for STARTTLS
+            const tlsSocket = new plugins.tls.TLSSocket(socket, {
+                isServer: true,
+                secureContext,
+                // Server-side options (simpler is more reliable for STARTTLS)
+                requestCert: false,
+                rejectUnauthorized: false
+            });
+            // Set up error handling for the TLS socket
+            tlsSocket.once('error', (err) => {
+                if (handshakeTimeoutId) {
+                    clearTimeout(handshakeTimeoutId);
+                }
+                SmtpLogger.error(`TLS error during STARTTLS: ${err.message}`, {
+                    remoteAddress: socketDetails.remoteAddress,
+                    remotePort: socketDetails.remotePort,
+                    error: err,
+                    stack: err.stack
+                });
+                // Clean up socket listeners
+                cleanupSocket();
+                if (options.onFailure) {
+                    options.onFailure(err);
+                }
+                // Destroy the socket to ensure we don't have hanging connections
+                tlsSocket.destroy();
+                resolve(undefined);
+            });
+            // Set up handshake timeout manually for extra safety
+            handshakeTimeoutId = setTimeout(() => {
+                SmtpLogger.error('TLS handshake timed out', {
+                    remoteAddress: socketDetails.remoteAddress,
+                    remotePort: socketDetails.remotePort
+                });
+                // Clean up socket listeners
+                cleanupSocket();
+                if (options.onFailure) {
+                    options.onFailure(new Error('TLS handshake timed out'));
+                }
+                // Destroy the socket to ensure we don't have hanging connections
+                tlsSocket.destroy();
+                resolve(undefined);
+            }, handshakeTimeout);
+            // Set up handler for successful TLS negotiation
+            tlsSocket.once('secure', () => {
+                if (handshakeTimeoutId) {
+                    clearTimeout(handshakeTimeoutId);
+                }
+                const protocol = tlsSocket.getProtocol();
+                const cipher = tlsSocket.getCipher();
+                SmtpLogger.info('TLS upgrade successful via STARTTLS', {
+                    remoteAddress: socketDetails.remoteAddress,
+                    remotePort: socketDetails.remotePort,
+                    protocol: protocol || 'unknown',
+                    cipher: cipher?.name || 'unknown'
+                });
+                // Update socket mapping in session manager
+                if (options.sessionManager) {
+                    const socketReplaced = options.sessionManager.replaceSocket(socket, tlsSocket);
+                    if (!socketReplaced) {
+                        SmtpLogger.error('Failed to replace socket in session manager after STARTTLS', {
+                            remoteAddress: socketDetails.remoteAddress,
+                            remotePort: socketDetails.remotePort
+                        });
+                    }
+                }
+                // Re-attach event handlers from connection manager
+                if (options.connectionManager) {
+                    try {
+                        options.connectionManager.setupSocketEventHandlers(tlsSocket);
+                        SmtpLogger.debug('Successfully re-attached connection manager event handlers to TLS socket', {
+                            remoteAddress: socketDetails.remoteAddress,
+                            remotePort: socketDetails.remotePort
+                        });
+                    }
+                    catch (handlerError) {
+                        SmtpLogger.error('Failed to re-attach event handlers to TLS socket after STARTTLS', {
+                            remoteAddress: socketDetails.remoteAddress,
+                            remotePort: socketDetails.remotePort,
+                            error: handlerError instanceof Error ? handlerError : new Error(String(handlerError))
+                        });
+                    }
+                }
+                // Update session if provided
+                if (options.session) {
+                    // Update session properties to indicate TLS is active
+                    options.session.useTLS = true;
+                    options.session.secure = true;
+                    // Reset session state as required by RFC 3207
+                    // After STARTTLS, client must issue a new EHLO
+                    if (options.updateSessionState) {
+                        options.updateSessionState(options.session, SmtpState.GREETING);
+                    }
+                }
+                // Call success callback if provided
+                if (options.onSuccess) {
+                    options.onSuccess(tlsSocket);
+                }
+                // Success - return the TLS socket
+                resolve(tlsSocket);
+            });
+            // Resume the socket after we've set up all handlers
+            // This allows the TLS handshake to proceed
+            socket.resume();
+        }
+        catch (error) {
+            SmtpLogger.error(`Unexpected error in STARTTLS: ${error instanceof Error ? error.message : String(error)}`, {
+                error: error instanceof Error ? error : new Error(String(error)),
+                stack: error instanceof Error ? error.stack : 'No stack trace available'
+            });
+            if (options.onFailure) {
+                options.onFailure(error instanceof Error ? error : new Error(String(error)));
+            }
+            resolve(undefined);
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"starttls-handler.js","sourceRoot":"","sources":["../../../../../ts/mail/delivery/smtpserver/starttls-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts/mail/delivery/smtpserver/tls-handler.d.ts

@@ -0,0 +1,66 @@
+/**
+ * SMTP TLS Handler
+ * Responsible for handling TLS-related SMTP functionality
+ */
+import * as plugins from '../../../plugins.js';
+import type { ITlsHandler, ISmtpServer, ISmtpSession } from './interfaces.js';
+/**
+ * Handles TLS functionality for SMTP server
+ */
+export declare class TlsHandler implements ITlsHandler {
+    /**
+     * Reference to the SMTP server instance
+     */
+    private smtpServer;
+    /**
+     * Certificate data
+     */
+    private certificates;
+    /**
+     * TLS options
+     */
+    private options;
+    /**
+     * Creates a new TLS handler
+     * @param smtpServer - SMTP server instance
+     */
+    constructor(smtpServer: ISmtpServer);
+    /**
+     * Handle STARTTLS command
+     * @param socket - Client socket
+     */
+    handleStartTls(socket: plugins.net.Socket, session: ISmtpSession): Promise<plugins.tls.TLSSocket | null>;
+    /**
+     * Upgrade a connection to TLS
+     * @param socket - Client socket
+     */
+    startTLS(socket: plugins.net.Socket): Promise<plugins.tls.TLSSocket>;
+    /**
+     * Create a secure server
+     * @returns TLS server instance or undefined if TLS is not enabled
+     */
+    createSecureServer(): plugins.tls.Server | undefined;
+    /**
+     * Check if TLS is enabled
+     * @returns Whether TLS is enabled
+     */
+    isTlsEnabled(): boolean;
+    /**
+     * Send a response to the client
+     * @param socket - Client socket
+     * @param response - Response message
+     */
+    private sendResponse;
+    /**
+     * Check if TLS is available (interface requirement)
+     */
+    isTlsAvailable(): boolean;
+    /**
+     * Get TLS options (interface requirement)
+     */
+    getTlsOptions(): plugins.tls.TlsOptions;
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+}

package/dist_ts/ts/mail/delivery/smtpserver/tls-handler.js

@@ -0,0 +1,261 @@
+/**
+ * SMTP TLS Handler
+ * Responsible for handling TLS-related SMTP functionality
+ */
+import * as plugins from '../../../plugins.js';
+import { SmtpResponseCode, SecurityEventType, SecurityLogLevel } from './constants.js';
+import { SmtpLogger } from './utils/logging.js';
+import { getSocketDetails, getTlsDetails } from './utils/helpers.js';
+import { loadCertificatesFromString, generateSelfSignedCertificates, createTlsOptions } from './certificate-utils.js';
+import { SmtpState } from '../interfaces.js';
+/**
+ * Handles TLS functionality for SMTP server
+ */
+export class TlsHandler {
+    /**
+     * Creates a new TLS handler
+     * @param smtpServer - SMTP server instance
+     */
+    constructor(smtpServer) {
+        this.smtpServer = smtpServer;
+        // Initialize certificates
+        const serverOptions = this.smtpServer.getOptions();
+        try {
+            // Try to load certificates from provided options
+            this.certificates = loadCertificatesFromString({
+                key: serverOptions.key,
+                cert: serverOptions.cert,
+                ca: serverOptions.ca
+            });
+            SmtpLogger.info('Successfully loaded TLS certificates');
+        }
+        catch (error) {
+            SmtpLogger.warn(`Failed to load certificates from options, using self-signed: ${error instanceof Error ? error.message : String(error)}`);
+            // Fall back to self-signed certificates for testing
+            this.certificates = generateSelfSignedCertificates();
+        }
+        // Initialize TLS options
+        this.options = createTlsOptions(this.certificates);
+    }
+    /**
+     * Handle STARTTLS command
+     * @param socket - Client socket
+     */
+    async handleStartTls(socket, session) {
+        // Check if already using TLS
+        if (session.useTLS) {
+            this.sendResponse(socket, `${SmtpResponseCode.BAD_SEQUENCE} TLS already active`);
+            return null;
+        }
+        // Check if we have the necessary TLS certificates
+        if (!this.isTlsEnabled()) {
+            this.sendResponse(socket, `${SmtpResponseCode.TLS_UNAVAILABLE_TEMP} TLS not available`);
+            return null;
+        }
+        // Send ready for TLS response
+        this.sendResponse(socket, `${SmtpResponseCode.SERVICE_READY} Ready to start TLS`);
+        // Upgrade the connection to TLS
+        try {
+            const tlsSocket = await this.startTLS(socket);
+            return tlsSocket;
+        }
+        catch (error) {
+            SmtpLogger.error(`STARTTLS negotiation failed: ${error instanceof Error ? error.message : String(error)}`, {
+                sessionId: session.id,
+                remoteAddress: session.remoteAddress,
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+            // Log security event
+            SmtpLogger.logSecurityEvent(SecurityLogLevel.ERROR, SecurityEventType.TLS_NEGOTIATION, 'STARTTLS negotiation failed', { error: error instanceof Error ? error.message : String(error) }, session.remoteAddress);
+            return null;
+        }
+    }
+    /**
+     * Upgrade a connection to TLS
+     * @param socket - Client socket
+     */
+    async startTLS(socket) {
+        // Get the session for this socket
+        const session = this.smtpServer.getSessionManager().getSession(socket);
+        try {
+            // Import the enhanced STARTTLS handler
+            // This uses a more robust approach to TLS upgrades
+            const { performStartTLS } = await import('./starttls-handler.js');
+            SmtpLogger.info('Using enhanced STARTTLS implementation');
+            // Use the enhanced STARTTLS handler with better error handling and socket management
+            const serverOptions = this.smtpServer.getOptions();
+            const tlsSocket = await performStartTLS(socket, {
+                key: serverOptions.key,
+                cert: serverOptions.cert,
+                ca: serverOptions.ca,
+                session: session,
+                sessionManager: this.smtpServer.getSessionManager(),
+                connectionManager: this.smtpServer.getConnectionManager(),
+                // Callback for successful upgrade
+                onSuccess: (secureSocket) => {
+                    SmtpLogger.info('TLS connection successfully established via enhanced STARTTLS', {
+                        remoteAddress: secureSocket.remoteAddress,
+                        remotePort: secureSocket.remotePort,
+                        protocol: secureSocket.getProtocol() || 'unknown',
+                        cipher: secureSocket.getCipher()?.name || 'unknown'
+                    });
+                    // Log security event
+                    SmtpLogger.logSecurityEvent(SecurityLogLevel.INFO, SecurityEventType.TLS_NEGOTIATION, 'STARTTLS successful with enhanced implementation', {
+                        protocol: secureSocket.getProtocol(),
+                        cipher: secureSocket.getCipher()?.name
+                    }, secureSocket.remoteAddress, undefined, true);
+                },
+                // Callback for failed upgrade
+                onFailure: (error) => {
+                    SmtpLogger.error(`Enhanced STARTTLS failed: ${error.message}`, {
+                        sessionId: session?.id,
+                        remoteAddress: socket.remoteAddress,
+                        error
+                    });
+                    // Log security event
+                    SmtpLogger.logSecurityEvent(SecurityLogLevel.ERROR, SecurityEventType.TLS_NEGOTIATION, 'Enhanced STARTTLS failed', { error: error.message }, socket.remoteAddress, undefined, false);
+                },
+                // Function to update session state
+                updateSessionState: this.smtpServer.getSessionManager().updateSessionState?.bind(this.smtpServer.getSessionManager())
+            });
+            // If STARTTLS failed with the enhanced implementation, log the error
+            if (!tlsSocket) {
+                SmtpLogger.warn('Enhanced STARTTLS implementation failed to create TLS socket', {
+                    sessionId: session?.id,
+                    remoteAddress: socket.remoteAddress
+                });
+                throw new Error('Failed to create TLS socket');
+            }
+            return tlsSocket;
+        }
+        catch (error) {
+            // Log STARTTLS failure
+            SmtpLogger.error(`Failed to upgrade connection to TLS: ${error instanceof Error ? error.message : String(error)}`, {
+                remoteAddress: socket.remoteAddress,
+                remotePort: socket.remotePort,
+                error: error instanceof Error ? error : new Error(String(error)),
+                stack: error instanceof Error ? error.stack : 'No stack trace available'
+            });
+            // Log security event
+            SmtpLogger.logSecurityEvent(SecurityLogLevel.ERROR, SecurityEventType.TLS_NEGOTIATION, 'Failed to upgrade connection to TLS', {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : 'No stack trace available'
+            }, socket.remoteAddress, undefined, false);
+            // Destroy the socket on error
+            socket.destroy();
+            throw error;
+        }
+    }
+    /**
+     * Create a secure server
+     * @returns TLS server instance or undefined if TLS is not enabled
+     */
+    createSecureServer() {
+        if (!this.isTlsEnabled()) {
+            return undefined;
+        }
+        try {
+            SmtpLogger.info('Creating secure TLS server');
+            // Log certificate info
+            SmtpLogger.debug('Using certificates for secure server', {
+                keyLength: this.certificates.key.length,
+                certLength: this.certificates.cert.length,
+                caLength: this.certificates.ca ? this.certificates.ca.length : 0
+            });
+            // Create TLS options using our certificate utilities
+            // This ensures proper PEM format handling and protocol negotiation
+            const tlsOptions = createTlsOptions(this.certificates, true); // Use server options
+            SmtpLogger.info('Creating TLS server with options', {
+                minVersion: tlsOptions.minVersion,
+                maxVersion: tlsOptions.maxVersion,
+                handshakeTimeout: tlsOptions.handshakeTimeout
+            });
+            // Create a server with wider TLS compatibility
+            const server = new plugins.tls.Server(tlsOptions);
+            // Add error handling
+            server.on('error', (err) => {
+                SmtpLogger.error(`TLS server error: ${err.message}`, {
+                    error: err,
+                    stack: err.stack
+                });
+            });
+            // Log TLS details for each connection
+            server.on('secureConnection', (socket) => {
+                SmtpLogger.info('New secure connection established', {
+                    protocol: socket.getProtocol(),
+                    cipher: socket.getCipher()?.name,
+                    remoteAddress: socket.remoteAddress,
+                    remotePort: socket.remotePort
+                });
+            });
+            return server;
+        }
+        catch (error) {
+            SmtpLogger.error(`Failed to create secure server: ${error instanceof Error ? error.message : String(error)}`, {
+                error: error instanceof Error ? error : new Error(String(error)),
+                stack: error instanceof Error ? error.stack : 'No stack trace available'
+            });
+            return undefined;
+        }
+    }
+    /**
+     * Check if TLS is enabled
+     * @returns Whether TLS is enabled
+     */
+    isTlsEnabled() {
+        const options = this.smtpServer.getOptions();
+        return !!(options.key && options.cert);
+    }
+    /**
+     * Send a response to the client
+     * @param socket - Client socket
+     * @param response - Response message
+     */
+    sendResponse(socket, response) {
+        // Check if socket is still writable before attempting to write
+        if (socket.destroyed || socket.readyState !== 'open' || !socket.writable) {
+            SmtpLogger.debug(`Skipping response to closed/destroyed socket: ${response}`, {
+                remoteAddress: socket.remoteAddress,
+                remotePort: socket.remotePort,
+                destroyed: socket.destroyed,
+                readyState: socket.readyState,
+                writable: socket.writable
+            });
+            return;
+        }
+        try {
+            socket.write(`${response}\r\n`);
+            SmtpLogger.logResponse(response, socket);
+        }
+        catch (error) {
+            SmtpLogger.error(`Error sending response: ${error instanceof Error ? error.message : String(error)}`, {
+                response,
+                remoteAddress: socket.remoteAddress,
+                remotePort: socket.remotePort,
+                error: error instanceof Error ? error : new Error(String(error))
+            });
+            socket.destroy();
+        }
+    }
+    /**
+     * Check if TLS is available (interface requirement)
+     */
+    isTlsAvailable() {
+        return this.isTlsEnabled();
+    }
+    /**
+     * Get TLS options (interface requirement)
+     */
+    getTlsOptions() {
+        return this.options;
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        // Clear any cached certificates or TLS contexts
+        // TlsHandler doesn't have timers but may have cached resources
+        SmtpLogger.debug('TlsHandler destroyed');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tls-handler.js","sourceRoot":"","sources":["../../../../../ts/mail/delivery/smtpserver/tls-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAE/C,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvF,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,EACL,0BAA0B,EAC1B,8BAA8B,EAC9B,gBAAgB,EAEjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C;;GAEG;AACH,MAAM,OAAO,UAAU;IAgBrB;;;OAGG;IACH,YAAY,UAAuB;QACjC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAE7B,0BAA0B;QAC1B,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;QACnD,IAAI,CAAC;YACH,iDAAiD;YACjD,IAAI,CAAC,YAAY,GAAG,0BAA0B,CAAC;gBAC7C,GAAG,EAAE,aAAa,CAAC,GAAG;gBACtB,IAAI,EAAE,aAAa,CAAC,IAAI;gBACxB,EAAE,EAAE,aAAa,CAAC,EAAE;aACrB,CAAC,CAAC;YAEH,UAAU,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;QAC1D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,UAAU,CAAC,IAAI,CAAC,gEAAgE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAE1I,oDAAoD;YACpD,IAAI,CAAC,YAAY,GAAG,8BAA8B,EAAE,CAAC;QACvD,CAAC;QAED,yBAAyB;QACzB,IAAI,CAAC,OAAO,GAAG,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,cAAc,CAAC,MAA0B,EAAE,OAAqB;QAE3E,6BAA6B;QAC7B,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,GAAG,gBAAgB,CAAC,YAAY,qBAAqB,CAAC,CAAC;YACjF,OAAO,IAAI,CAAC;QACd,CAAC;QAED,kDAAkD;QAClD,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,GAAG,gBAAgB,CAAC,oBAAoB,oBAAoB,CAAC,CAAC;YACxF,OAAO,IAAI,CAAC;QACd,CAAC;QAED,8BAA8B;QAC9B,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,GAAG,gBAAgB,CAAC,aAAa,qBAAqB,CAAC,CAAC;QAElF,gCAAgC;QAChC,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YAC9C,OAAO,SAAS,CAAC;QACnB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,UAAU,CAAC,KAAK,CAAC,gCAAgC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE;gBACzG,SAAS,EAAE,OAAO,CAAC,EAAE;gBACrB,aAAa,EAAE,OAAO,CAAC,aAAa;gBACpC,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;aACjE,CAAC,CAAC;YAEH,qBAAqB;YACrB,UAAU,CAAC,gBAAgB,CACzB,gBAAgB,CAAC,KAAK,EACtB,iBAAiB,CAAC,eAAe,EACjC,6BAA6B,EAC7B,EAAE,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EACjE,OAAO,CAAC,aAAa,CACtB,CAAC;YAEF,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,QAAQ,CAAC,MAA0B;QAC9C,kCAAkC;QAClC,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAEvE,IAAI,CAAC;YACH,uCAAuC;YACvC,mDAAmD;YACnD,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,MAAM,CAAC,uBAAuB,CAAC,CAAC;YAElE,UAAU,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;YAE1D,qFAAqF;YACrF,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;YACnD,MAAM,SAAS,GAAG,MAAM,eAAe,CAAC,MAAM,EAAE;gBAC9C,GAAG,EAAE,aAAa,CAAC,GAAG;gBACtB,IAAI,EAAE,aAAa,CAAC,IAAI;gBACxB,EAAE,EAAE,aAAa,CAAC,EAAE;gBACpB,OAAO,EAAE,OAAO;gBAChB,cAAc,EAAE,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE;gBACnD,iBAAiB,EAAE,IAAI,CAAC,UAAU,CAAC,oBAAoB,EAAE;gBACzD,kCAAkC;gBAClC,SAAS,EAAE,CAAC,YAAY,EAAE,EAAE;oBAC1B,UAAU,CAAC,IAAI,CAAC,+DAA+D,EAAE;wBAC/E,aAAa,EAAE,YAAY,CAAC,aAAa;wBACzC,UAAU,EAAE,YAAY,CAAC,UAAU;wBACnC,QAAQ,EAAE,YAAY,CAAC,WAAW,EAAE,IAAI,SAAS;wBACjD,MAAM,EAAE,YAAY,CAAC,SAAS,EAAE,EAAE,IAAI,IAAI,SAAS;qBACpD,CAAC,CAAC;oBAEH,qBAAqB;oBACrB,UAAU,CAAC,gBAAgB,CACzB,gBAAgB,CAAC,IAAI,EACrB,iBAAiB,CAAC,eAAe,EACjC,kDAAkD,EAClD;wBACE,QAAQ,EAAE,YAAY,CAAC,WAAW,EAAE;wBACpC,MAAM,EAAE,YAAY,CAAC,SAAS,EAAE,EAAE,IAAI;qBACvC,EACD,YAAY,CAAC,aAAa,EAC1B,SAAS,EACT,IAAI,CACL,CAAC;gBACJ,CAAC;gBACD,8BAA8B;gBAC9B,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE;oBACnB,UAAU,CAAC,KAAK,CAAC,6BAA6B,KAAK,CAAC,OAAO,EAAE,EAAE;wBAC7D,SAAS,EAAE,OAAO,EAAE,EAAE;wBACtB,aAAa,EAAE,MAAM,CAAC,aAAa;wBACnC,KAAK;qBACN,CAAC,CAAC;oBAEH,qBAAqB;oBACrB,UAAU,CAAC,gBAAgB,CACzB,gBAAgB,CAAC,KAAK,EACtB,iBAAiB,CAAC,eAAe,EACjC,0BAA0B,EAC1B,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,EACxB,MAAM,CAAC,aAAa,EACpB,SAAS,EACT,KAAK,CACN,CAAC;gBACJ,CAAC;gBACD,mCAAmC;gBACnC,kBAAkB,EAAE,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;aACtH,CAAC,CAAC;YAEH,qEAAqE;YACrE,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,UAAU,CAAC,IAAI,CAAC,8DAA8D,EAAE;oBAC9E,SAAS,EAAE,OAAO,EAAE,EAAE;oBACtB,aAAa,EAAE,MAAM,CAAC,aAAa;iBACpC,CAAC,CAAC;gBACH,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;YACjD,CAAC;YAED,OAAO,SAAS,CAAC;QACnB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,uBAAuB;YACvB,UAAU,CAAC,KAAK,CAAC,wCAAwC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE;gBACjH,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAChE,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,0BAA0B;aACzE,CAAC,CAAC;YAEH,qBAAqB;YACrB,UAAU,CAAC,gBAAgB,CACzB,gBAAgB,CAAC,KAAK,EACtB,iBAAiB,CAAC,eAAe,EACjC,qCAAqC,EACrC;gBACE,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;gBAC7D,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,0BAA0B;aACzE,EACD,MAAM,CAAC,aAAa,EACpB,SAAS,EACT,KAAK,CACN,CAAC;YAEF,8BAA8B;YAC9B,MAAM,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,kBAAkB;QACvB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;YACzB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,IAAI,CAAC;YACH,UAAU,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC;YAE9C,uBAAuB;YACvB,UAAU,CAAC,KAAK,CAAC,sCAAsC,EAAE;gBACvD,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM;gBACvC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM;gBACzC,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;aACjE,CAAC,CAAC;YAEH,qDAAqD;YACrD,mEAAmE;YACnE,MAAM,UAAU,GAAG,gBAAgB,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,qBAAqB;YAEnF,UAAU,CAAC,IAAI,CAAC,kCAAkC,EAAE;gBAClD,UAAU,EAAE,UAAU,CAAC,UAAU;gBACjC,UAAU,EAAE,UAAU,CAAC,UAAU;gBACjC,gBAAgB,EAAE,UAAU,CAAC,gBAAgB;aAC9C,CAAC,CAAC;YAEH,+CAA+C;YAC/C,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAElD,qBAAqB;YACrB,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;gBACzB,UAAU,CAAC,KAAK,CAAC,qBAAqB,GAAG,CAAC,OAAO,EAAE,EAAE;oBACnD,KAAK,EAAE,GAAG;oBACV,KAAK,EAAE,GAAG,CAAC,KAAK;iBACjB,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAEH,sCAAsC;YACtC,MAAM,CAAC,EAAE,CAAC,kBAAkB,EAAE,CAAC,MAAM,EAAE,EAAE;gBACvC,UAAU,CAAC,IAAI,CAAC,mCAAmC,EAAE;oBACnD,QAAQ,EAAE,MAAM,CAAC,WAAW,EAAE;oBAC9B,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,EAAE,IAAI;oBAChC,aAAa,EAAE,MAAM,CAAC,aAAa;oBACnC,UAAU,EAAE,MAAM,CAAC,UAAU;iBAC9B,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAEH,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,UAAU,CAAC,KAAK,CAAC,mCAAmC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE;gBAC5G,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAChE,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,0BAA0B;aACzE,CAAC,CAAC;YAEH,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,YAAY;QACjB,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;QAC7C,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACK,YAAY,CAAC,MAAkD,EAAE,QAAgB;QACvF,+DAA+D;QAC/D,IAAI,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,UAAU,KAAK,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACzE,UAAU,CAAC,KAAK,CAAC,iDAAiD,QAAQ,EAAE,EAAE;gBAC5E,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,QAAQ,EAAE,MAAM,CAAC,QAAQ;aAC1B,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,MAAM,CAAC,KAAK,CAAC,GAAG,QAAQ,MAAM,CAAC,CAAC;YAChC,UAAU,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAC3C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,UAAU,CAAC,KAAK,CAAC,2BAA2B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE;gBACpG,QAAQ;gBACR,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;aACjE,CAAC,CAAC;YAEH,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC;IACH,CAAC;IAED;;OAEG;IACI,cAAc;QACnB,OAAO,IAAI,CAAC,YAAY,EAAE,CAAC;IAC7B,CAAC;IAED;;OAEG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,gDAAgD;QAChD,+DAA+D;QAC/D,UAAU,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAC3C,CAAC;CACF"}