986 lines
80 KiB
JavaScript
986 lines
80 KiB
JavaScript
import * as plugins from '../../plugins.js';
|
|
import { logger } from '../../logger.js';
|
|
import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
|
|
import { MtaConnectionError, MtaAuthenticationError, MtaDeliveryError, MtaConfigurationError, MtaTimeoutError, MtaProtocolError } from '../../errors/index.js';
|
|
import { Email } from '../core/classes.email.js';
|
|
/**
|
|
* SMTP client for sending emails to remote mail servers
|
|
*/
|
|
export class SmtpClient {
|
|
options;
|
|
connected = false;
|
|
socket;
|
|
supportedExtensions = new Set();
|
|
/**
|
|
* Create a new SMTP client instance
|
|
* @param options SMTP client connection options
|
|
*/
|
|
constructor(options) {
|
|
// Set default options
|
|
this.options = {
|
|
...options,
|
|
connectionTimeout: options.connectionTimeout || 30000, // 30 seconds
|
|
socketTimeout: options.socketTimeout || 60000, // 60 seconds
|
|
commandTimeout: options.commandTimeout || 30000, // 30 seconds
|
|
secure: options.secure || false,
|
|
domain: options.domain || 'localhost',
|
|
tls: {
|
|
rejectUnauthorized: options.tls?.rejectUnauthorized !== false, // Default to true
|
|
minVersion: options.tls?.minVersion || 'TLSv1.2'
|
|
}
|
|
};
|
|
}
|
|
/**
|
|
* Connect to the SMTP server
|
|
*/
|
|
async connect() {
|
|
if (this.connected && this.socket) {
|
|
return;
|
|
}
|
|
try {
|
|
logger.log('info', `Connecting to SMTP server ${this.options.host}:${this.options.port}`);
|
|
// Create socket
|
|
const socket = new plugins.net.Socket();
|
|
// Set timeouts
|
|
socket.setTimeout(this.options.socketTimeout);
|
|
// Connect to the server
|
|
await new Promise((resolve, reject) => {
|
|
// Handle connection events
|
|
socket.once('connect', () => {
|
|
logger.log('debug', `Connected to ${this.options.host}:${this.options.port}`);
|
|
resolve();
|
|
});
|
|
socket.once('timeout', () => {
|
|
reject(MtaConnectionError.timeout(this.options.host, this.options.port, this.options.connectionTimeout));
|
|
});
|
|
socket.once('error', (err) => {
|
|
if (err.code === 'ECONNREFUSED') {
|
|
reject(MtaConnectionError.refused(this.options.host, this.options.port));
|
|
}
|
|
else if (err.code === 'ENOTFOUND') {
|
|
reject(MtaConnectionError.dnsError(this.options.host, err));
|
|
}
|
|
else {
|
|
reject(new MtaConnectionError(`Connection error to ${this.options.host}:${this.options.port}: ${err.message}`, {
|
|
data: {
|
|
host: this.options.host,
|
|
port: this.options.port,
|
|
error: err.message,
|
|
code: err.code
|
|
}
|
|
}));
|
|
}
|
|
});
|
|
// Connect to the server
|
|
const connectOptions = {
|
|
host: this.options.host,
|
|
port: this.options.port
|
|
};
|
|
// For direct TLS connections
|
|
if (this.options.secure) {
|
|
const tlsSocket = plugins.tls.connect({
|
|
...connectOptions,
|
|
rejectUnauthorized: this.options.tls.rejectUnauthorized,
|
|
minVersion: this.options.tls.minVersion,
|
|
ca: this.options.tls.ca ? [this.options.tls.ca] : undefined
|
|
});
|
|
tlsSocket.once('secureConnect', () => {
|
|
logger.log('debug', `Secure connection established to ${this.options.host}:${this.options.port}`);
|
|
this.socket = tlsSocket;
|
|
resolve();
|
|
});
|
|
tlsSocket.once('error', (err) => {
|
|
reject(new MtaConnectionError(`TLS connection error to ${this.options.host}:${this.options.port}: ${err.message}`, {
|
|
data: {
|
|
host: this.options.host,
|
|
port: this.options.port,
|
|
error: err.message,
|
|
code: err.code
|
|
}
|
|
}));
|
|
});
|
|
tlsSocket.setTimeout(this.options.socketTimeout);
|
|
tlsSocket.once('timeout', () => {
|
|
reject(MtaConnectionError.timeout(this.options.host, this.options.port, this.options.connectionTimeout));
|
|
});
|
|
}
|
|
else {
|
|
socket.connect(connectOptions);
|
|
this.socket = socket;
|
|
}
|
|
});
|
|
// Wait for server greeting
|
|
const greeting = await this.readResponse();
|
|
if (!greeting.startsWith('220')) {
|
|
throw new MtaConnectionError(`Unexpected greeting from server: ${greeting}`, {
|
|
data: {
|
|
host: this.options.host,
|
|
port: this.options.port,
|
|
greeting
|
|
}
|
|
});
|
|
}
|
|
// Send EHLO
|
|
await this.sendEhlo();
|
|
// Start TLS if not secure and supported
|
|
if (!this.options.secure && this.supportedExtensions.has('STARTTLS')) {
|
|
await this.startTls();
|
|
// Send EHLO again after STARTTLS
|
|
await this.sendEhlo();
|
|
}
|
|
// Authenticate if credentials provided
|
|
if (this.options.auth) {
|
|
await this.authenticate();
|
|
}
|
|
this.connected = true;
|
|
logger.log('info', `Successfully connected to SMTP server ${this.options.host}:${this.options.port}`);
|
|
// Set up error handling for the socket
|
|
this.socket.on('error', (err) => {
|
|
logger.log('error', `Socket error: ${err.message}`);
|
|
this.connected = false;
|
|
this.socket = undefined;
|
|
});
|
|
this.socket.on('close', () => {
|
|
logger.log('debug', 'Socket closed');
|
|
this.connected = false;
|
|
this.socket = undefined;
|
|
});
|
|
this.socket.on('timeout', () => {
|
|
logger.log('error', 'Socket timeout');
|
|
this.connected = false;
|
|
if (this.socket) {
|
|
this.socket.destroy();
|
|
this.socket = undefined;
|
|
}
|
|
});
|
|
}
|
|
catch (error) {
|
|
// Clean up socket if connection failed
|
|
if (this.socket) {
|
|
this.socket.destroy();
|
|
this.socket = undefined;
|
|
}
|
|
logger.log('error', `Failed to connect to SMTP server: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Send EHLO command to the server
|
|
*/
|
|
async sendEhlo() {
|
|
// Clear previous extensions
|
|
this.supportedExtensions.clear();
|
|
// Send EHLO - don't allow pipelining for this command
|
|
const response = await this.sendCommand(`EHLO ${this.options.domain}`, false);
|
|
// Parse supported extensions
|
|
const lines = response.split('\r\n');
|
|
for (let i = 1; i < lines.length; i++) {
|
|
const line = lines[i];
|
|
if (line.startsWith('250-') || line.startsWith('250 ')) {
|
|
const extension = line.substring(4).split(' ')[0];
|
|
this.supportedExtensions.add(extension);
|
|
}
|
|
}
|
|
// Check if server supports pipelining
|
|
this.supportsPipelining = this.supportedExtensions.has('PIPELINING');
|
|
logger.log('debug', `Server supports extensions: ${Array.from(this.supportedExtensions).join(', ')}`);
|
|
if (this.supportsPipelining) {
|
|
logger.log('info', 'Server supports PIPELINING - will use for improved performance');
|
|
}
|
|
}
|
|
/**
|
|
* Start TLS negotiation
|
|
*/
|
|
async startTls() {
|
|
logger.log('debug', 'Starting TLS negotiation');
|
|
// Send STARTTLS command
|
|
const response = await this.sendCommand('STARTTLS');
|
|
if (!response.startsWith('220')) {
|
|
throw new MtaConnectionError(`Failed to start TLS: ${response}`, {
|
|
data: {
|
|
host: this.options.host,
|
|
port: this.options.port,
|
|
response
|
|
}
|
|
});
|
|
}
|
|
if (!this.socket) {
|
|
throw new MtaConnectionError('No socket available for TLS upgrade', {
|
|
data: {
|
|
host: this.options.host,
|
|
port: this.options.port
|
|
}
|
|
});
|
|
}
|
|
// Upgrade socket to TLS
|
|
const currentSocket = this.socket;
|
|
this.socket = await this.upgradeTls(currentSocket);
|
|
}
|
|
/**
|
|
* Upgrade socket to TLS
|
|
* @param socket Original socket
|
|
*/
|
|
async upgradeTls(socket) {
|
|
return new Promise((resolve, reject) => {
|
|
const tlsOptions = {
|
|
socket,
|
|
servername: this.options.host,
|
|
rejectUnauthorized: this.options.tls.rejectUnauthorized,
|
|
minVersion: this.options.tls.minVersion,
|
|
ca: this.options.tls.ca ? [this.options.tls.ca] : undefined
|
|
};
|
|
const tlsSocket = plugins.tls.connect(tlsOptions);
|
|
tlsSocket.once('secureConnect', () => {
|
|
logger.log('debug', 'TLS negotiation successful');
|
|
resolve(tlsSocket);
|
|
});
|
|
tlsSocket.once('error', (err) => {
|
|
reject(new MtaConnectionError(`TLS error: ${err.message}`, {
|
|
data: {
|
|
host: this.options.host,
|
|
port: this.options.port,
|
|
error: err.message,
|
|
code: err.code
|
|
}
|
|
}));
|
|
});
|
|
tlsSocket.setTimeout(this.options.socketTimeout);
|
|
tlsSocket.once('timeout', () => {
|
|
reject(MtaTimeoutError.commandTimeout('STARTTLS', this.options.host, this.options.socketTimeout));
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Authenticate with the server
|
|
*/
|
|
async authenticate() {
|
|
if (!this.options.auth) {
|
|
return;
|
|
}
|
|
const { user, pass, method = 'LOGIN' } = this.options.auth;
|
|
logger.log('debug', `Authenticating as ${user} using ${method}`);
|
|
try {
|
|
switch (method) {
|
|
case 'PLAIN':
|
|
await this.authPlain(user, pass);
|
|
break;
|
|
case 'LOGIN':
|
|
await this.authLogin(user, pass);
|
|
break;
|
|
case 'OAUTH2':
|
|
await this.authOAuth2(user, pass);
|
|
break;
|
|
default:
|
|
throw new MtaAuthenticationError(`Authentication method ${method} not supported by client`, {
|
|
data: {
|
|
method
|
|
}
|
|
});
|
|
}
|
|
logger.log('info', `Successfully authenticated as ${user}`);
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Authentication failed: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Authenticate using PLAIN method
|
|
* @param user Username
|
|
* @param pass Password
|
|
*/
|
|
async authPlain(user, pass) {
|
|
// PLAIN authentication format: \0username\0password
|
|
const authString = Buffer.from(`\0${user}\0${pass}`).toString('base64');
|
|
const response = await this.sendCommand(`AUTH PLAIN ${authString}`);
|
|
if (!response.startsWith('235')) {
|
|
throw MtaAuthenticationError.invalidCredentials(this.options.host, user);
|
|
}
|
|
}
|
|
/**
|
|
* Authenticate using LOGIN method
|
|
* @param user Username
|
|
* @param pass Password
|
|
*/
|
|
async authLogin(user, pass) {
|
|
// Start LOGIN authentication
|
|
const response = await this.sendCommand('AUTH LOGIN');
|
|
if (!response.startsWith('334')) {
|
|
throw new MtaAuthenticationError(`Server did not accept AUTH LOGIN: ${response}`, {
|
|
data: {
|
|
host: this.options.host,
|
|
response
|
|
}
|
|
});
|
|
}
|
|
// Send username (base64)
|
|
const userResponse = await this.sendCommand(Buffer.from(user).toString('base64'));
|
|
if (!userResponse.startsWith('334')) {
|
|
throw MtaAuthenticationError.invalidCredentials(this.options.host, user);
|
|
}
|
|
// Send password (base64)
|
|
const passResponse = await this.sendCommand(Buffer.from(pass).toString('base64'));
|
|
if (!passResponse.startsWith('235')) {
|
|
throw MtaAuthenticationError.invalidCredentials(this.options.host, user);
|
|
}
|
|
}
|
|
/**
|
|
* Authenticate using OAuth2 method
|
|
* @param user Username
|
|
* @param token OAuth2 token
|
|
*/
|
|
async authOAuth2(user, token) {
|
|
// XOAUTH2 format
|
|
const authString = `user=${user}\x01auth=Bearer ${token}\x01\x01`;
|
|
const response = await this.sendCommand(`AUTH XOAUTH2 ${Buffer.from(authString).toString('base64')}`);
|
|
if (!response.startsWith('235')) {
|
|
throw MtaAuthenticationError.invalidCredentials(this.options.host, user);
|
|
}
|
|
}
|
|
/**
|
|
* Send an email through the SMTP client
|
|
* @param email Email to send
|
|
* @param processingMode Optional processing mode
|
|
*/
|
|
async sendMail(email, processingMode) {
|
|
// Ensure we're connected
|
|
if (!this.connected || !this.socket) {
|
|
await this.connect();
|
|
}
|
|
const startTime = Date.now();
|
|
const result = {
|
|
success: false,
|
|
acceptedRecipients: [],
|
|
rejectedRecipients: [],
|
|
timestamp: startTime,
|
|
secure: this.options.secure || this.socket instanceof plugins.tls.TLSSocket,
|
|
authenticated: !!this.options.auth
|
|
};
|
|
try {
|
|
logger.log('info', `Sending email to ${email.getAllRecipients().join(', ')}`);
|
|
// Apply DKIM signing if configured
|
|
if (this.options.dkim?.enabled) {
|
|
await this.applyDkimSignature(email);
|
|
result.dkimSigned = true;
|
|
}
|
|
// Get envelope and recipients
|
|
const envelope_from = email.getEnvelopeFrom() || email.from;
|
|
const recipients = email.getAllRecipients();
|
|
// Check if we can use pipelining for MAIL FROM and RCPT TO commands
|
|
if (this.supportsPipelining && recipients.length > 0) {
|
|
logger.log('debug', 'Using SMTP pipelining for sending');
|
|
// Send MAIL FROM command first (always needed)
|
|
const mailFromCmd = `MAIL FROM:<${envelope_from}> SIZE=${this.getEmailSize(email)}`;
|
|
let mailFromResponse;
|
|
try {
|
|
mailFromResponse = await this.sendCommand(mailFromCmd);
|
|
if (!mailFromResponse.startsWith('250')) {
|
|
throw new MtaDeliveryError(`MAIL FROM command failed: ${mailFromResponse}`, {
|
|
data: {
|
|
command: mailFromCmd,
|
|
response: mailFromResponse
|
|
}
|
|
});
|
|
}
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `MAIL FROM failed: ${error.message}`);
|
|
throw error;
|
|
}
|
|
// Pipeline all RCPT TO commands
|
|
const rcptPromises = recipients.map(recipient => {
|
|
return this.sendCommand(`RCPT TO:<${recipient}>`)
|
|
.then(response => {
|
|
if (response.startsWith('250')) {
|
|
result.acceptedRecipients.push(recipient);
|
|
return { recipient, accepted: true, response };
|
|
}
|
|
else {
|
|
result.rejectedRecipients.push(recipient);
|
|
logger.log('warn', `Recipient ${recipient} rejected: ${response}`);
|
|
return { recipient, accepted: false, response };
|
|
}
|
|
})
|
|
.catch(error => {
|
|
result.rejectedRecipients.push(recipient);
|
|
logger.log('warn', `Recipient ${recipient} rejected with error: ${error.message}`);
|
|
return { recipient, accepted: false, error: error.message };
|
|
});
|
|
});
|
|
// Wait for all RCPT TO commands to complete
|
|
await Promise.all(rcptPromises);
|
|
}
|
|
else {
|
|
// Fall back to sequential commands if pipelining not supported
|
|
logger.log('debug', 'Using sequential SMTP commands for sending');
|
|
// Send MAIL FROM
|
|
await this.sendCommand(`MAIL FROM:<${envelope_from}> SIZE=${this.getEmailSize(email)}`);
|
|
// Send RCPT TO for each recipient
|
|
for (const recipient of recipients) {
|
|
try {
|
|
await this.sendCommand(`RCPT TO:<${recipient}>`);
|
|
result.acceptedRecipients.push(recipient);
|
|
}
|
|
catch (error) {
|
|
logger.log('warn', `Recipient ${recipient} rejected: ${error.message}`);
|
|
result.rejectedRecipients.push(recipient);
|
|
}
|
|
}
|
|
}
|
|
// Check if at least one recipient was accepted
|
|
if (result.acceptedRecipients.length === 0) {
|
|
throw new MtaDeliveryError('All recipients were rejected', {
|
|
data: {
|
|
recipients,
|
|
rejectedRecipients: result.rejectedRecipients
|
|
}
|
|
});
|
|
}
|
|
// Send DATA
|
|
const dataResponse = await this.sendCommand('DATA');
|
|
if (!dataResponse.startsWith('354')) {
|
|
throw new MtaProtocolError(`Failed to start DATA phase: ${dataResponse}`, {
|
|
data: {
|
|
response: dataResponse
|
|
}
|
|
});
|
|
}
|
|
// Format email content efficiently
|
|
const emailContent = await this.getFormattedEmail(email);
|
|
// Send email content
|
|
const finalResponse = await this.sendCommand(emailContent + '\r\n.');
|
|
// Extract message ID if available
|
|
const messageIdMatch = finalResponse.match(/\[(.*?)\]/);
|
|
if (messageIdMatch) {
|
|
result.messageId = messageIdMatch[1];
|
|
}
|
|
result.success = true;
|
|
result.response = finalResponse;
|
|
logger.log('info', `Email sent successfully to ${result.acceptedRecipients.join(', ')}`);
|
|
// Log security event
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.INFO,
|
|
type: SecurityEventType.EMAIL_DELIVERY,
|
|
message: 'Email sent successfully',
|
|
details: {
|
|
recipients: result.acceptedRecipients,
|
|
rejectedRecipients: result.rejectedRecipients,
|
|
messageId: result.messageId,
|
|
secure: result.secure,
|
|
authenticated: result.authenticated,
|
|
server: `${this.options.host}:${this.options.port}`,
|
|
dkimSigned: result.dkimSigned
|
|
},
|
|
success: true
|
|
});
|
|
return result;
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to send email: ${error.message}`);
|
|
// Format error for result
|
|
result.error = error.message;
|
|
// Extract SMTP code if available
|
|
if (error.context?.data?.statusCode) {
|
|
result.responseCode = error.context.data.statusCode;
|
|
}
|
|
// Log security event
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.ERROR,
|
|
type: SecurityEventType.EMAIL_DELIVERY,
|
|
message: 'Email delivery failed',
|
|
details: {
|
|
error: error.message,
|
|
server: `${this.options.host}:${this.options.port}`,
|
|
recipients: email.getAllRecipients(),
|
|
acceptedRecipients: result.acceptedRecipients,
|
|
rejectedRecipients: result.rejectedRecipients,
|
|
secure: result.secure,
|
|
authenticated: result.authenticated
|
|
},
|
|
success: false
|
|
});
|
|
return result;
|
|
}
|
|
}
|
|
/**
|
|
* Apply DKIM signature to email
|
|
* @param email Email to sign
|
|
*/
|
|
async applyDkimSignature(email) {
|
|
if (!this.options.dkim?.enabled || !this.options.dkim?.privateKey) {
|
|
return;
|
|
}
|
|
try {
|
|
logger.log('debug', `Signing email with DKIM for domain ${this.options.dkim.domain}`);
|
|
// Format email for DKIM signing
|
|
const { dkimSign } = plugins;
|
|
const emailContent = await this.getFormattedEmail(email);
|
|
// Sign email
|
|
const signOptions = {
|
|
signingDomain: this.options.dkim.domain,
|
|
selector: this.options.dkim.selector,
|
|
privateKey: this.options.dkim.privateKey,
|
|
canonicalization: 'relaxed/relaxed',
|
|
algorithm: 'rsa-sha256',
|
|
signTime: new Date(),
|
|
signatureData: [
|
|
{
|
|
signingDomain: this.options.dkim.domain,
|
|
selector: this.options.dkim.selector,
|
|
privateKey: this.options.dkim.privateKey,
|
|
algorithm: 'rsa-sha256',
|
|
canonicalization: 'relaxed/relaxed',
|
|
}
|
|
]
|
|
};
|
|
const signResult = await dkimSign(emailContent, signOptions);
|
|
// Add DKIM-Signature header from the signing result
|
|
if (signResult.signatures) {
|
|
const dkimHeader = signResult.signatures.split('\r\n')
|
|
.find(line => line.startsWith('DKIM-Signature: '));
|
|
if (dkimHeader) {
|
|
email.addHeader('DKIM-Signature', dkimHeader.substring('DKIM-Signature: '.length));
|
|
}
|
|
}
|
|
logger.log('debug', 'DKIM signature applied successfully');
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Failed to apply DKIM signature: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
/**
|
|
* Format email for SMTP transmission
|
|
* @param email Email to format
|
|
*/
|
|
async getFormattedEmail(email) {
|
|
// This is a simplified implementation
|
|
// In a full implementation, this would use proper MIME formatting
|
|
let content = '';
|
|
// Add headers
|
|
content += `From: ${email.from}\r\n`;
|
|
content += `To: ${email.to.join(', ')}\r\n`;
|
|
content += `Subject: ${email.subject}\r\n`;
|
|
content += `Date: ${new Date().toUTCString()}\r\n`;
|
|
content += `Message-ID: <${plugins.uuid.v4()}@${this.options.domain}>\r\n`;
|
|
// Add additional headers
|
|
for (const [name, value] of Object.entries(email.headers || {})) {
|
|
content += `${name}: ${value}\r\n`;
|
|
}
|
|
// Add content type for multipart
|
|
if (email.attachments && email.attachments.length > 0) {
|
|
const boundary = `----_=_NextPart_${Math.random().toString(36).substr(2)}`;
|
|
content += `MIME-Version: 1.0\r\n`;
|
|
content += `Content-Type: multipart/mixed; boundary="${boundary}"\r\n`;
|
|
content += `\r\n`;
|
|
// Add text part
|
|
content += `--${boundary}\r\n`;
|
|
content += `Content-Type: text/plain; charset="UTF-8"\r\n`;
|
|
content += `\r\n`;
|
|
content += `${email.text}\r\n`;
|
|
// Add HTML part if present
|
|
if (email.html) {
|
|
content += `--${boundary}\r\n`;
|
|
content += `Content-Type: text/html; charset="UTF-8"\r\n`;
|
|
content += `\r\n`;
|
|
content += `${email.html}\r\n`;
|
|
}
|
|
// Add attachments
|
|
for (const attachment of email.attachments) {
|
|
content += `--${boundary}\r\n`;
|
|
content += `Content-Type: ${attachment.contentType || 'application/octet-stream'}; name="${attachment.filename}"\r\n`;
|
|
content += `Content-Disposition: attachment; filename="${attachment.filename}"\r\n`;
|
|
content += `Content-Transfer-Encoding: base64\r\n`;
|
|
content += `\r\n`;
|
|
// Add base64 encoded content
|
|
const base64Content = attachment.content.toString('base64');
|
|
// Split into lines of 76 characters
|
|
for (let i = 0; i < base64Content.length; i += 76) {
|
|
content += base64Content.substring(i, i + 76) + '\r\n';
|
|
}
|
|
}
|
|
// End boundary
|
|
content += `--${boundary}--\r\n`;
|
|
}
|
|
else {
|
|
// Simple email with just text
|
|
content += `Content-Type: text/plain; charset="UTF-8"\r\n`;
|
|
content += `\r\n`;
|
|
content += `${email.text}\r\n`;
|
|
}
|
|
return content;
|
|
}
|
|
/**
|
|
* Get size of email in bytes
|
|
* @param email Email to measure
|
|
*/
|
|
getEmailSize(email) {
|
|
// Simplified size estimation
|
|
let size = 0;
|
|
// Headers
|
|
size += `From: ${email.from}\r\n`.length;
|
|
size += `To: ${email.to.join(', ')}\r\n`.length;
|
|
size += `Subject: ${email.subject}\r\n`.length;
|
|
// Body
|
|
size += (email.text?.length || 0) + 2; // +2 for CRLF
|
|
// HTML part if present
|
|
if (email.html) {
|
|
size += email.html.length + 2;
|
|
}
|
|
// Attachments
|
|
for (const attachment of email.attachments || []) {
|
|
size += attachment.content.length;
|
|
}
|
|
// Add overhead for MIME boundaries and headers
|
|
const overhead = email.attachments?.length ? 1000 + (email.attachments.length * 200) : 200;
|
|
return size + overhead;
|
|
}
|
|
/**
|
|
* Send SMTP command and wait for response
|
|
* @param command SMTP command to send
|
|
*/
|
|
// Queue for command pipelining
|
|
commandQueue = [];
|
|
// Flag to indicate if we're currently processing commands
|
|
processingCommands = false;
|
|
// Flag to indicate if server supports pipelining
|
|
supportsPipelining = false;
|
|
/**
|
|
* Send an SMTP command and wait for response
|
|
* @param command SMTP command to send
|
|
* @param allowPipelining Whether this command can be pipelined
|
|
*/
|
|
async sendCommand(command, allowPipelining = true) {
|
|
if (!this.socket) {
|
|
throw new MtaConnectionError('Not connected to server', {
|
|
data: {
|
|
host: this.options.host,
|
|
port: this.options.port
|
|
}
|
|
});
|
|
}
|
|
// Log command if not sensitive
|
|
if (!command.startsWith('AUTH')) {
|
|
logger.log('debug', `> ${command}`);
|
|
}
|
|
else {
|
|
logger.log('debug', '> AUTH ***');
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
// Set up timeout for command
|
|
const timeout = setTimeout(() => {
|
|
// Remove this command from the queue if it times out
|
|
const index = this.commandQueue.findIndex(item => item.command === command);
|
|
if (index !== -1) {
|
|
this.commandQueue.splice(index, 1);
|
|
}
|
|
reject(MtaTimeoutError.commandTimeout(command.split(' ')[0], this.options.host, this.options.commandTimeout));
|
|
}, this.options.commandTimeout);
|
|
// Add command to the queue
|
|
this.commandQueue.push({
|
|
command,
|
|
resolve,
|
|
reject,
|
|
timeout
|
|
});
|
|
// Process command queue if we can pipeline or if not currently processing commands
|
|
if ((this.supportsPipelining && allowPipelining) || !this.processingCommands) {
|
|
this.processCommandQueue();
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Process the command queue - either one by one or pipelined if supported
|
|
*/
|
|
processCommandQueue() {
|
|
if (this.processingCommands || this.commandQueue.length === 0 || !this.socket) {
|
|
return;
|
|
}
|
|
this.processingCommands = true;
|
|
try {
|
|
// If pipelining is supported, send all commands at once
|
|
if (this.supportsPipelining) {
|
|
// Send all commands in queue at once
|
|
const commands = this.commandQueue.map(item => item.command).join('\r\n') + '\r\n';
|
|
this.socket.write(commands, (err) => {
|
|
if (err) {
|
|
// Handle write error for all commands
|
|
const error = new MtaConnectionError(`Failed to send commands: ${err.message}`, {
|
|
data: {
|
|
error: err.message
|
|
}
|
|
});
|
|
// Fail all pending commands
|
|
while (this.commandQueue.length > 0) {
|
|
const item = this.commandQueue.shift();
|
|
clearTimeout(item.timeout);
|
|
item.reject(error);
|
|
}
|
|
this.processingCommands = false;
|
|
}
|
|
});
|
|
// Process responses one by one in order
|
|
this.processResponses();
|
|
}
|
|
else {
|
|
// Process commands one by one if pipelining not supported
|
|
this.processNextCommand();
|
|
}
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Error processing command queue: ${error.message}`);
|
|
this.processingCommands = false;
|
|
}
|
|
}
|
|
/**
|
|
* Process the next command in the queue (non-pipelined mode)
|
|
*/
|
|
processNextCommand() {
|
|
if (this.commandQueue.length === 0 || !this.socket) {
|
|
this.processingCommands = false;
|
|
return;
|
|
}
|
|
const currentCommand = this.commandQueue[0];
|
|
this.socket.write(currentCommand.command + '\r\n', (err) => {
|
|
if (err) {
|
|
// Handle write error
|
|
const error = new MtaConnectionError(`Failed to send command: ${err.message}`, {
|
|
data: {
|
|
command: currentCommand.command.split(' ')[0],
|
|
error: err.message
|
|
}
|
|
});
|
|
// Remove from queue
|
|
this.commandQueue.shift();
|
|
clearTimeout(currentCommand.timeout);
|
|
currentCommand.reject(error);
|
|
// Continue with next command
|
|
this.processNextCommand();
|
|
return;
|
|
}
|
|
// Read response
|
|
this.readResponse()
|
|
.then((response) => {
|
|
// Remove from queue and resolve
|
|
this.commandQueue.shift();
|
|
clearTimeout(currentCommand.timeout);
|
|
currentCommand.resolve(response);
|
|
// Process next command
|
|
this.processNextCommand();
|
|
})
|
|
.catch((err) => {
|
|
// Remove from queue and reject
|
|
this.commandQueue.shift();
|
|
clearTimeout(currentCommand.timeout);
|
|
currentCommand.reject(err);
|
|
// Process next command
|
|
this.processNextCommand();
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Process responses for pipelined commands
|
|
*/
|
|
async processResponses() {
|
|
try {
|
|
// Process responses for each command in order
|
|
while (this.commandQueue.length > 0) {
|
|
const currentCommand = this.commandQueue[0];
|
|
try {
|
|
// Wait for response
|
|
const response = await this.readResponse();
|
|
// Remove from queue and resolve
|
|
this.commandQueue.shift();
|
|
clearTimeout(currentCommand.timeout);
|
|
currentCommand.resolve(response);
|
|
}
|
|
catch (error) {
|
|
// Remove from queue and reject
|
|
this.commandQueue.shift();
|
|
clearTimeout(currentCommand.timeout);
|
|
currentCommand.reject(error);
|
|
// Stop processing if this is a critical error
|
|
if (error instanceof MtaConnectionError &&
|
|
(error.message.includes('Connection closed') || error.message.includes('Not connected'))) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (error) {
|
|
logger.log('error', `Error processing responses: ${error.message}`);
|
|
}
|
|
finally {
|
|
this.processingCommands = false;
|
|
}
|
|
}
|
|
/**
|
|
* Read response from the server
|
|
*/
|
|
async readResponse() {
|
|
if (!this.socket) {
|
|
throw new MtaConnectionError('Not connected to server', {
|
|
data: {
|
|
host: this.options.host,
|
|
port: this.options.port
|
|
}
|
|
});
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
// Use an array to collect response chunks instead of string concatenation
|
|
const responseChunks = [];
|
|
// Single function to clean up all listeners
|
|
const cleanupListeners = () => {
|
|
if (!this.socket)
|
|
return;
|
|
this.socket.removeListener('data', onData);
|
|
this.socket.removeListener('error', onError);
|
|
this.socket.removeListener('close', onClose);
|
|
this.socket.removeListener('end', onEnd);
|
|
};
|
|
const onData = (data) => {
|
|
// Store buffer directly, avoiding unnecessary string conversion
|
|
responseChunks.push(data);
|
|
// Convert to string only for response checking
|
|
const responseData = Buffer.concat(responseChunks).toString();
|
|
// Check if this is a complete response
|
|
if (this.isCompleteResponse(responseData)) {
|
|
// Clean up listeners
|
|
cleanupListeners();
|
|
const trimmedResponse = responseData.trim();
|
|
logger.log('debug', `< ${trimmedResponse}`);
|
|
// Check if this is an error response
|
|
if (this.isErrorResponse(responseData)) {
|
|
const code = responseData.substring(0, 3);
|
|
reject(this.createErrorFromResponse(trimmedResponse, code));
|
|
}
|
|
else {
|
|
resolve(trimmedResponse);
|
|
}
|
|
}
|
|
};
|
|
const onError = (err) => {
|
|
cleanupListeners();
|
|
reject(new MtaConnectionError(`Socket error while waiting for response: ${err.message}`, {
|
|
data: {
|
|
error: err.message
|
|
}
|
|
}));
|
|
};
|
|
const onClose = () => {
|
|
cleanupListeners();
|
|
const responseData = Buffer.concat(responseChunks).toString();
|
|
reject(new MtaConnectionError('Connection closed while waiting for response', {
|
|
data: {
|
|
partialResponse: responseData
|
|
}
|
|
}));
|
|
};
|
|
const onEnd = () => {
|
|
cleanupListeners();
|
|
const responseData = Buffer.concat(responseChunks).toString();
|
|
reject(new MtaConnectionError('Connection ended while waiting for response', {
|
|
data: {
|
|
partialResponse: responseData
|
|
}
|
|
}));
|
|
};
|
|
// Set up listeners
|
|
this.socket.on('data', onData);
|
|
this.socket.once('error', onError);
|
|
this.socket.once('close', onClose);
|
|
this.socket.once('end', onEnd);
|
|
});
|
|
}
|
|
/**
|
|
* Check if the response is complete
|
|
* @param response Response to check
|
|
*/
|
|
isCompleteResponse(response) {
|
|
// Check if it's a multi-line response
|
|
const lines = response.split('\r\n');
|
|
const lastLine = lines[lines.length - 2]; // Second to last because of the trailing CRLF
|
|
// Check if the last line starts with a code followed by a space
|
|
// If it does, this is a complete response
|
|
if (lastLine && /^\d{3} /.test(lastLine)) {
|
|
return true;
|
|
}
|
|
// For single line responses
|
|
if (lines.length === 2 && lines[0].length >= 3 && /^\d{3} /.test(lines[0])) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
/**
|
|
* Check if the response is an error
|
|
* @param response Response to check
|
|
*/
|
|
isErrorResponse(response) {
|
|
// Get the status code (first 3 characters)
|
|
const code = response.substring(0, 3);
|
|
// 4xx and 5xx are error codes
|
|
return code.startsWith('4') || code.startsWith('5');
|
|
}
|
|
/**
|
|
* Create appropriate error from response
|
|
* @param response Error response
|
|
* @param code SMTP status code
|
|
*/
|
|
createErrorFromResponse(response, code) {
|
|
// Extract message part
|
|
const message = response.substring(4).trim();
|
|
switch (code.charAt(0)) {
|
|
case '4': // Temporary errors
|
|
return MtaDeliveryError.temporary(message, 'recipient', code, response);
|
|
case '5': // Permanent errors
|
|
return MtaDeliveryError.permanent(message, 'recipient', code, response);
|
|
default:
|
|
return new MtaDeliveryError(`Unexpected error response: ${response}`, {
|
|
data: {
|
|
response,
|
|
code
|
|
}
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Close the connection to the server
|
|
*/
|
|
async close() {
|
|
if (!this.connected || !this.socket) {
|
|
return;
|
|
}
|
|
try {
|
|
// Send QUIT
|
|
await this.sendCommand('QUIT');
|
|
}
|
|
catch (error) {
|
|
logger.log('warn', `Error sending QUIT command: ${error.message}`);
|
|
}
|
|
finally {
|
|
// Close socket
|
|
this.socket.destroy();
|
|
this.socket = undefined;
|
|
this.connected = false;
|
|
logger.log('info', 'SMTP connection closed');
|
|
}
|
|
}
|
|
/**
|
|
* Checks if the connection is active
|
|
*/
|
|
isConnected() {
|
|
return this.connected && !!this.socket;
|
|
}
|
|
/**
|
|
* Update SMTP client options
|
|
* @param options New options
|
|
*/
|
|
updateOptions(options) {
|
|
this.options = {
|
|
...this.options,
|
|
...options
|
|
};
|
|
logger.log('info', 'SMTP client options updated');
|
|
}
|
|
}
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.smtp.client.legacy.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.smtp.client.legacy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAkLjD;;GAEG;AACH,MAAM,OAAO,UAAU;IACb,OAAO,CAAqB;IAC5B,SAAS,GAAY,KAAK,CAAC;IAC3B,MAAM,CAA8C;IACpD,mBAAmB,GAAgB,IAAI,GAAG,EAAE,CAAC;IAErD;;;OAGG;IACH,YAAY,OAA2B;QACrC,sBAAsB;QACtB,IAAI,CAAC,OAAO,GAAG;YACb,GAAG,OAAO;YACV,iBAAiB,EAAE,OAAO,CAAC,iBAAiB,IAAI,KAAK,EAAE,aAAa;YACpE,aAAa,EAAE,OAAO,CAAC,aAAa,IAAI,KAAK,EAAE,aAAa;YAC5D,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,KAAK,EAAE,aAAa;YAC9D,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,KAAK;YAC/B,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,WAAW;YACrC,GAAG,EAAE;gBACH,kBAAkB,EAAE,OAAO,CAAC,GAAG,EAAE,kBAAkB,KAAK,KAAK,EAAE,kBAAkB;gBACjF,UAAU,EAAE,OAAO,CAAC,GAAG,EAAE,UAAU,IAAI,SAAS;aACjD;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,OAAO;QAClB,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAClC,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6BAA6B,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;YAE1F,gBAAgB;YAChB,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC;YAExC,eAAe;YACf,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;YAE9C,wBAAwB;YACxB,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBAC1C,2BAA2B;gBAC3B,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE;oBAC1B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,gBAAgB,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;oBAC9E,OAAO,EAAE,CAAC;gBACZ,CAAC,CAAC,CAAC;gBAEH,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE;oBAC1B,MAAM,CAAC,kBAAkB,CAAC,OAAO,CAC/B,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAC/B,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;gBAEH,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAqB,EAAE,EAAE;oBAC7C,IAAI,GAAG,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;wBAChC,MAAM,CAAC,kBAAkB,CAAC,OAAO,CAC/B,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CAAC,OAAO,CAAC,IAAI,CAClB,CAAC,CAAC;oBACL,CAAC;yBAAM,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;wBACpC,MAAM,CAAC,kBAAkB,CAAC,QAAQ,CAChC,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,GAAG,CACJ,CAAC,CAAC;oBACL,CAAC;yBAAM,CAAC;wBACN,MAAM,CAAC,IAAI,kBAAkB,CAC3B,uBAAuB,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,GAAG,CAAC,OAAO,EAAE,EAC/E;4BACE,IAAI,EAAE;gCACJ,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;gCACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;gCACvB,KAAK,EAAE,GAAG,CAAC,OAAO;gCAClB,IAAI,EAAE,GAAG,CAAC,IAAI;6BACf;yBACF,CACF,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC,CAAC,CAAC;gBAEH,wBAAwB;gBACxB,MAAM,cAAc,GAAG;oBACrB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;oBACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;iBACxB,CAAC;gBAEF,6BAA6B;gBAC7B,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;oBACxB,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC;wBACpC,GAAG,cAAc;wBACjB,kBAAkB,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB;wBACvD,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAiB;wBAC9C,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS;qBAC3B,CAAC,CAAC;oBAEpC,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE;wBACnC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,oCAAoC,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;wBAClG,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;wBACxB,OAAO,EAAE,CAAC;oBACZ,CAAC,CAAC,CAAC;oBAEH,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAqB,EAAE,EAAE;wBAChD,MAAM,CAAC,IAAI,kBAAkB,CAC3B,2BAA2B,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,GAAG,CAAC,OAAO,EAAE,EACnF;4BACE,IAAI,EAAE;gCACJ,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;gCACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;gCACvB,KAAK,EAAE,GAAG,CAAC,OAAO;gCAClB,IAAI,EAAE,GAAG,CAAC,IAAI;6BACf;yBACF,CACF,CAAC,CAAC;oBACL,CAAC,CAAC,CAAC;oBAEH,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;oBAEjD,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE;wBAC7B,MAAM,CAAC,kBAAkB,CAAC,OAAO,CAC/B,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAC/B,CAAC,CAAC;oBACL,CAAC,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;oBAC/B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;gBACvB,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,2BAA2B;YAC3B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;YAE3C,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;gBAChC,MAAM,IAAI,kBAAkB,CAC1B,oCAAoC,QAAQ,EAAE,EAC9C;oBACE,IAAI,EAAE;wBACJ,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;wBACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;wBACvB,QAAQ;qBACT;iBACF,CACF,CAAC;YACJ,CAAC;YAED,YAAY;YACZ,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;YAEtB,wCAAwC;YACxC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBACrE,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAEtB,iCAAiC;gBACjC,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;YACxB,CAAC;YAED,uCAAuC;YACvC,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;gBACtB,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5B,CAAC;YAED,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,yCAAyC,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;YAEtG,uCAAuC;YACvC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;gBAC9B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,iBAAiB,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;gBACpD,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;gBACvB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;YAC1B,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;gBAC3B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;gBACrC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;gBACvB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;YAC1B,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;gBAC7B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;gBACtC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;gBACvB,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;oBAChB,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;oBACtB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;gBAC1B,CAAC;YACH,CAAC,CAAC,CAAC;QAEL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,uCAAuC;YACvC,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;gBAChB,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBACtB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;YAC1B,CAAC;YAED,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,qCAAqC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC1E,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,QAAQ;QACpB,4BAA4B;QAC5B,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,CAAC;QAEjC,sDAAsD;QACtD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,KAAK,CAAC,CAAC;QAE9E,6BAA6B;QAC7B,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACrC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACtB,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;gBACvD,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBAClD,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAC1C,CAAC;QACH,CAAC;QAED,sCAAsC;QACtC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAErE,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,+BAA+B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACtG,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,gEAAgE,CAAC,CAAC;QACvF,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,QAAQ;QACpB,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,0BAA0B,CAAC,CAAC;QAEhD,wBAAwB;QACxB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;QAEpD,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,MAAM,IAAI,kBAAkB,CAC1B,wBAAwB,QAAQ,EAAE,EAClC;gBACE,IAAI,EAAE;oBACJ,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;oBACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;oBACvB,QAAQ;iBACT;aACF,CACF,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAM,IAAI,kBAAkB,CAC1B,qCAAqC,EACrC;gBACE,IAAI,EAAE;oBACJ,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;oBACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;iBACxB;aACF,CACF,CAAC;QACJ,CAAC;QAED,wBAAwB;QACxB,MAAM,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC;QAClC,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,UAAU,CAAC,MAA0B;QACjD,OAAO,IAAI,OAAO,CAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC5D,MAAM,UAAU,GAAkC;gBAChD,MAAM;gBACN,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;gBAC7B,kBAAkB,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB;gBACvD,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAiB;gBAC9C,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS;aAC5D,CAAC;YAEF,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAElD,SAAS,CAAC,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE;gBACnC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,4BAA4B,CAAC,CAAC;gBAClD,OAAO,CAAC,SAAS,CAAC,CAAC;YACrB,CAAC,CAAC,CAAC;YAEH,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAqB,EAAE,EAAE;gBAChD,MAAM,CAAC,IAAI,kBAAkB,CAC3B,cAAc,GAAG,CAAC,OAAO,EAAE,EAC3B;oBACE,IAAI,EAAE;wBACJ,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;wBACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;wBACvB,KAAK,EAAE,GAAG,CAAC,OAAO;wBAClB,IAAI,EAAE,GAAG,CAAC,IAAI;qBACf;iBACF,CACF,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAEH,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;YAEjD,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE;gBAC7B,MAAM,CAAC,eAAe,CAAC,cAAc,CACnC,UAAU,EACV,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CAAC,OAAO,CAAC,aAAa,CAC3B,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY;QACxB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QAED,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;QAE3D,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,qBAAqB,IAAI,UAAU,MAAM,EAAE,CAAC,CAAC;QAEjE,IAAI,CAAC;YACH,QAAQ,MAAM,EAAE,CAAC;gBACf,KAAK,OAAO;oBACV,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;oBACjC,MAAM;gBAER,KAAK,OAAO;oBACV,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;oBACjC,MAAM;gBAER,KAAK,QAAQ;oBACX,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;oBAClC,MAAM;gBAER;oBACE,MAAM,IAAI,sBAAsB,CAC9B,yBAAyB,MAAM,0BAA0B,EACzD;wBACE,IAAI,EAAE;4BACJ,MAAM;yBACP;qBACF,CACF,CAAC;YACN,CAAC;YAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iCAAiC,IAAI,EAAE,CAAC,CAAC;QAC9D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,0BAA0B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC/D,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,SAAS,CAAC,IAAY,EAAE,IAAY;QAChD,oDAAoD;QACpD,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,KAAK,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACxE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,UAAU,EAAE,CAAC,CAAC;QAEpE,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,MAAM,sBAAsB,CAAC,kBAAkB,CAC7C,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CACL,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,SAAS,CAAC,IAAY,EAAE,IAAY;QAChD,6BAA6B;QAC7B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;QAEtD,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,MAAM,IAAI,sBAAsB,CAC9B,qCAAqC,QAAQ,EAAE,EAC/C;gBACE,IAAI,EAAE;oBACJ,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;oBACvB,QAAQ;iBACT;aACF,CACF,CAAC;QACJ,CAAC;QAED,yBAAyB;QACzB,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QAElF,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YACpC,MAAM,sBAAsB,CAAC,kBAAkB,CAC7C,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CACL,CAAC;QACJ,CAAC;QAED,yBAAyB;QACzB,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;QAElF,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YACpC,MAAM,sBAAsB,CAAC,kBAAkB,CAC7C,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CACL,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,UAAU,CAAC,IAAY,EAAE,KAAa;QAClD,iBAAiB;QACjB,MAAM,UAAU,GAAG,QAAQ,IAAI,mBAAmB,KAAK,UAAU,CAAC;QAClE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,gBAAgB,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAEtG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,MAAM,sBAAsB,CAAC,kBAAkB,CAC7C,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CACL,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,QAAQ,CAAC,KAAY,EAAE,cAAoC;QACtE,yBAAyB;QACzB,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACpC,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACvB,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAwB;YAClC,OAAO,EAAE,KAAK;YACd,kBAAkB,EAAE,EAAE;YACtB,kBAAkB,EAAE,EAAE;YACtB,SAAS,EAAE,SAAS;YACpB,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,YAAY,OAAO,CAAC,GAAG,CAAC,SAAS;YAC3E,aAAa,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI;SACnC,CAAC;QAEF,IAAI,CAAC;YACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,oBAAoB,KAAK,CAAC,gBAAgB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAE9E,mCAAmC;YACnC,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC;gBAC/B,MAAM,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;gBACrC,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC;YAC3B,CAAC;YAED,8BAA8B;YAC9B,MAAM,aAAa,GAAG,KAAK,CAAC,eAAe,EAAE,IAAI,KAAK,CAAC,IAAI,CAAC;YAC5D,MAAM,UAAU,GAAG,KAAK,CAAC,gBAAgB,EAAE,CAAC;YAE5C,oEAAoE;YACpE,IAAI,IAAI,CAAC,kBAAkB,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrD,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,mCAAmC,CAAC,CAAC;gBAEzD,+CAA+C;gBAC/C,MAAM,WAAW,GAAG,cAAc,aAAa,UAAU,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;gBACpF,IAAI,gBAAwB,CAAC;gBAE7B,IAAI,CAAC;oBACH,gBAAgB,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;oBAEvD,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;wBACxC,MAAM,IAAI,gBAAgB,CACxB,6BAA6B,gBAAgB,EAAE,EAC/C;4BACE,IAAI,EAAE;gCACJ,OAAO,EAAE,WAAW;gCACpB,QAAQ,EAAE,gBAAgB;6BAC3B;yBACF,CACF,CAAC;oBACJ,CAAC;gBACH,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,qBAAqB,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;oBAC1D,MAAM,KAAK,CAAC;gBACd,CAAC;gBAED,gCAAgC;gBAChC,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;oBAC9C,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,SAAS,GAAG,CAAC;yBAC9C,IAAI,CAAC,QAAQ,CAAC,EAAE;wBACf,IAAI,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;4BAC/B,MAAM,CAAC,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;4BAC1C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;wBACjD,CAAC;6BAAM,CAAC;4BACN,MAAM,CAAC,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;4BAC1C,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,SAAS,cAAc,QAAQ,EAAE,CAAC,CAAC;4BACnE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;wBAClD,CAAC;oBACH,CAAC,CAAC;yBACD,KAAK,CAAC,KAAK,CAAC,EAAE;wBACb,MAAM,CAAC,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;wBAC1C,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,SAAS,yBAAyB,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;wBACnF,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;oBAC9D,CAAC,CAAC,CAAC;gBACP,CAAC,CAAC,CAAC;gBAEH,4CAA4C;gBAC5C,MAAM,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YAClC,CAAC;iBAAM,CAAC;gBACN,+DAA+D;gBAC/D,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,4CAA4C,CAAC,CAAC;gBAElE,iBAAiB;gBACjB,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,aAAa,UAAU,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBAExF,kCAAkC;gBAClC,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;oBACnC,IAAI,CAAC;wBACH,MAAM,IAAI,CAAC,WAAW,CAAC,YAAY,SAAS,GAAG,CAAC,CAAC;wBACjD,MAAM,CAAC,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBAC5C,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,SAAS,cAAc,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;wBACxE,MAAM,CAAC,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBAC5C,CAAC;gBACH,CAAC;YACH,CAAC;YAED,+CAA+C;YAC/C,IAAI,MAAM,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC3C,MAAM,IAAI,gBAAgB,CACxB,8BAA8B,EAC9B;oBACE,IAAI,EAAE;wBACJ,UAAU;wBACV,kBAAkB,EAAE,MAAM,CAAC,kBAAkB;qBAC9C;iBACF,CACF,CAAC;YACJ,CAAC;YAED,YAAY;YACZ,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YAEpD,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;gBACpC,MAAM,IAAI,gBAAgB,CACxB,+BAA+B,YAAY,EAAE,EAC7C;oBACE,IAAI,EAAE;wBACJ,QAAQ,EAAE,YAAY;qBACvB;iBACF,CACF,CAAC;YACJ,CAAC;YAED,mCAAmC;YACnC,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;YAEzD,qBAAqB;YACrB,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,YAAY,GAAG,OAAO,CAAC,CAAC;YAErE,kCAAkC;YAClC,MAAM,cAAc,GAAG,aAAa,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YACxD,IAAI,cAAc,EAAE,CAAC;gBACnB,MAAM,CAAC,SAAS,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;YACvC,CAAC;YAED,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;YACtB,MAAM,CAAC,QAAQ,GAAG,aAAa,CAAC;YAEhC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,8BAA8B,MAAM,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAEzF,qBAAqB;YACrB,cAAc,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC;gBACpC,KAAK,EAAE,gBAAgB,CAAC,IAAI;gBAC5B,IAAI,EAAE,iBAAiB,CAAC,cAAc;gBACtC,OAAO,EAAE,yBAAyB;gBAClC,OAAO,EAAE;oBACP,UAAU,EAAE,MAAM,CAAC,kBAAkB;oBACrC,kBAAkB,EAAE,MAAM,CAAC,kBAAkB;oBAC7C,SAAS,EAAE,MAAM,CAAC,SAAS;oBAC3B,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,aAAa,EAAE,MAAM,CAAC,aAAa;oBACnC,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;oBACnD,UAAU,EAAE,MAAM,CAAC,UAAU;iBAC9B;gBACD,OAAO,EAAE,IAAI;aACd,CAAC,CAAC;YAEH,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,yBAAyB,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAE9D,0BAA0B;YAC1B,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC;YAE7B,iCAAiC;YACjC,IAAI,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;gBACpC,MAAM,CAAC,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC;YACtD,CAAC;YAED,qBAAqB;YACrB,cAAc,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC;gBACpC,KAAK,EAAE,gBAAgB,CAAC,KAAK;gBAC7B,IAAI,EAAE,iBAAiB,CAAC,cAAc;gBACtC,OAAO,EAAE,uBAAuB;gBAChC,OAAO,EAAE;oBACP,KAAK,EAAE,KAAK,CAAC,OAAO;oBACpB,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;oBACnD,UAAU,EAAE,KAAK,CAAC,gBAAgB,EAAE;oBACpC,kBAAkB,EAAE,MAAM,CAAC,kBAAkB;oBAC7C,kBAAkB,EAAE,MAAM,CAAC,kBAAkB;oBAC7C,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,aAAa,EAAE,MAAM,CAAC,aAAa;iBACpC;gBACD,OAAO,EAAE,KAAK;aACf,CAAC,CAAC;YAEH,OAAO,MAAM,CAAC;QAChB,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,kBAAkB,CAAC,KAAY;QAC3C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC;YAClE,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,sCAAsC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAEtF,gCAAgC;YAChC,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;YAC7B,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;YAEzD,aAAa;YACb,MAAM,WAAW,GAAG;gBAClB,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM;gBACvC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ;gBACpC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU;gBACxC,gBAAgB,EAAE,iBAA0B;gBAC5C,SAAS,EAAE,YAAqB;gBAChC,QAAQ,EAAE,IAAI,IAAI,EAAE;gBACpB,aAAa,EAAE;oBACb;wBACE,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM;wBACvC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ;wBACpC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU;wBACxC,SAAS,EAAE,YAAY;wBACvB,gBAAgB,EAAE,iBAAiB;qBACpC;iBACF;aACF,CAAC;YAEF,MAAM,UAAU,GAAG,MAAM,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;YAE7D,oDAAoD;YACpD,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;gBAC1B,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC;qBACnD,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC;gBAErD,IAAI,UAAU,EAAE,CAAC;oBACf,KAAK,CAAC,SAAS,CAAC,gBAAgB,EAAE,UAAU,CAAC,SAAS,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC;gBACrF,CAAC;YACH,CAAC;YAED,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,qCAAqC,CAAC,CAAC;QAC7D,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;;;OAGG;IACK,KAAK,CAAC,iBAAiB,CAAC,KAAY;QAC1C,sCAAsC;QACtC,kEAAkE;QAElE,IAAI,OAAO,GAAG,EAAE,CAAC;QAEjB,cAAc;QACd,OAAO,IAAI,SAAS,KAAK,CAAC,IAAI,MAAM,CAAC;QACrC,OAAO,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;QAC5C,OAAO,IAAI,YAAY,KAAK,CAAC,OAAO,MAAM,CAAC;QAC3C,OAAO,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC;QACnD,OAAO,IAAI,gBAAgB,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,OAAO,CAAC;QAE3E,yBAAyB;QACzB,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC,EAAE,CAAC;YAChE,OAAO,IAAI,GAAG,IAAI,KAAK,KAAK,MAAM,CAAC;QACrC,CAAC;QAED,iCAAiC;QACjC,IAAI,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACtD,MAAM,QAAQ,GAAG,mBAAmB,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3E,OAAO,IAAI,uBAAuB,CAAC;YACnC,OAAO,IAAI,4CAA4C,QAAQ,OAAO,CAAC;YACvE,OAAO,IAAI,MAAM,CAAC;YAElB,gBAAgB;YAChB,OAAO,IAAI,KAAK,QAAQ,MAAM,CAAC;YAC/B,OAAO,IAAI,+CAA+C,CAAC;YAC3D,OAAO,IAAI,MAAM,CAAC;YAClB,OAAO,IAAI,GAAG,KAAK,CAAC,IAAI,MAAM,CAAC;YAE/B,2BAA2B;YAC3B,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;gBACf,OAAO,IAAI,KAAK,QAAQ,MAAM,CAAC;gBAC/B,OAAO,IAAI,8CAA8C,CAAC;gBAC1D,OAAO,IAAI,MAAM,CAAC;gBAClB,OAAO,IAAI,GAAG,KAAK,CAAC,IAAI,MAAM,CAAC;YACjC,CAAC;YAED,kBAAkB;YAClB,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;gBAC3C,OAAO,IAAI,KAAK,QAAQ,MAAM,CAAC;gBAC/B,OAAO,IAAI,iBAAiB,UAAU,CAAC,WAAW,IAAI,0BAA0B,WAAW,UAAU,CAAC,QAAQ,OAAO,CAAC;gBACtH,OAAO,IAAI,8CAA8C,UAAU,CAAC,QAAQ,OAAO,CAAC;gBACpF,OAAO,IAAI,uCAAuC,CAAC;gBACnD,OAAO,IAAI,MAAM,CAAC;gBAElB,6BAA6B;gBAC7B,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;gBAE5D,oCAAoC;gBACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC;oBAClD,OAAO,IAAI,aAAa,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC;gBACzD,CAAC;YACH,CAAC;YAED,eAAe;YACf,OAAO,IAAI,KAAK,QAAQ,QAAQ,CAAC;QACnC,CAAC;aAAM,CAAC;YACN,8BAA8B;YAC9B,OAAO,IAAI,+CAA+C,CAAC;YAC3D,OAAO,IAAI,MAAM,CAAC;YAClB,OAAO,IAAI,GAAG,KAAK,CAAC,IAAI,MAAM,CAAC;QACjC,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;OAGG;IACK,YAAY,CAAC,KAAY;QAC/B,6BAA6B;QAC7B,IAAI,IAAI,GAAG,CAAC,CAAC;QAEb,UAAU;QACV,IAAI,IAAI,SAAS,KAAK,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC;QACzC,IAAI,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;QAChD,IAAI,IAAI,YAAY,KAAK,CAAC,OAAO,MAAM,CAAC,MAAM,CAAC;QAE/C,OAAO;QACP,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,cAAc;QAErD,uBAAuB;QACvB,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;YACf,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QAChC,CAAC;QAED,cAAc;QACd,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,WAAW,IAAI,EAAE,EAAE,CAAC;YACjD,IAAI,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC;QACpC,CAAC;QAED,+CAA+C;QAC/C,MAAM,QAAQ,GAAG,KAAK,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;QAE3F,OAAO,IAAI,GAAG,QAAQ,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,+BAA+B;IACvB,YAAY,GAKf,EAAE,CAAC;IAER,0DAA0D;IAClD,kBAAkB,GAAG,KAAK,CAAC;IAEnC,iDAAiD;IACzC,kBAAkB,GAAG,KAAK,CAAC;IAEnC;;;;OAIG;IACK,KAAK,CAAC,WAAW,CAAC,OAAe,EAAE,eAAe,GAAG,IAAI;QAC/D,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAM,IAAI,kBAAkB,CAC1B,yBAAyB,EACzB;gBACE,IAAI,EAAE;oBACJ,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;oBACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;iBACxB;aACF,CACF,CAAC;QACJ,CAAC;QAED,+BAA+B;QAC/B,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAChC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,OAAO,EAAE,CAAC,CAAC;QACtC,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC7C,6BAA6B;YAC7B,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC9B,qDAAqD;gBACrD,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC;gBAC5E,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;oBACjB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gBACrC,CAAC;gBAED,MAAM,CAAC,eAAe,CAAC,cAAc,CACnC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EACrB,IAAI,CAAC,OAAO,CAAC,IAAI,EACjB,IAAI,CAAC,OAAO,CAAC,cAAc,CAC5B,CAAC,CAAC;YACL,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;YAEhC,2BAA2B;YAC3B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;gBACrB,OAAO;gBACP,OAAO;gBACP,MAAM;gBACN,OAAO;aACR,CAAC,CAAC;YAEH,mFAAmF;YACnF,IAAI,CAAC,IAAI,CAAC,kBAAkB,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC7E,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC7B,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,mBAAmB;QACzB,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YAC9E,OAAO;QACT,CAAC;QAED,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAE/B,IAAI,CAAC;YACH,wDAAwD;YACxD,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC5B,qCAAqC;gBACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;gBAEnF,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE;oBAClC,IAAI,GAAG,EAAE,CAAC;wBACR,sCAAsC;wBACtC,MAAM,KAAK,GAAG,IAAI,kBAAkB,CAClC,4BAA4B,GAAG,CAAC,OAAO,EAAE,EACzC;4BACE,IAAI,EAAE;gCACJ,KAAK,EAAE,GAAG,CAAC,OAAO;6BACnB;yBACF,CACF,CAAC;wBAEF,4BAA4B;wBAC5B,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;4BACpC,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;4BACvC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;4BAC3B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;wBACrB,CAAC;wBAED,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;oBAClC,CAAC;gBACH,CAAC,CAAC,CAAC;gBAEH,wCAAwC;gBACxC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,CAAC;iBAAM,CAAC;gBACN,0DAA0D;gBAC1D,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,mCAAmC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACxE,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAClC,CAAC;IACH,CAAC;IAED;;OAEG;IACK,kBAAkB;QACxB,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACnD,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;YAChC,OAAO;QACT,CAAC;QAED,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAE5C,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,GAAG,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE;YACzD,IAAI,GAAG,EAAE,CAAC;gBACR,qBAAqB;gBACrB,MAAM,KAAK,GAAG,IAAI,kBAAkB,CAClC,2BAA2B,GAAG,CAAC,OAAO,EAAE,EACxC;oBACE,IAAI,EAAE;wBACJ,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;wBAC7C,KAAK,EAAE,GAAG,CAAC,OAAO;qBACnB;iBACF,CACF,CAAC;gBAEF,oBAAoB;gBACpB,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;gBAC1B,YAAY,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;gBACrC,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAE7B,6BAA6B;gBAC7B,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC1B,OAAO;YACT,CAAC;YAED,gBAAgB;YAChB,IAAI,CAAC,YAAY,EAAE;iBAChB,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACjB,gCAAgC;gBAChC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;gBAC1B,YAAY,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;gBACrC,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAEjC,uBAAuB;gBACvB,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,CAAC,CAAC;iBACD,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;gBACb,+BAA+B;gBAC/B,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;gBAC1B,YAAY,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;gBACrC,cAAc,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAE3B,uBAAuB;gBACvB,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,gBAAgB;QAC5B,IAAI,CAAC;YACH,8CAA8C;YAC9C,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpC,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;gBAE5C,IAAI,CAAC;oBACH,oBAAoB;oBACpB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;oBAE3C,gCAAgC;oBAChC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;oBAC1B,YAAY,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;oBACrC,cAAc,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;gBACnC,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,+BAA+B;oBAC/B,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;oBAC1B,YAAY,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;oBACrC,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBAE7B,8CAA8C;oBAC9C,IACE,KAAK,YAAY,kBAAkB;wBACnC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,EACxF,CAAC;wBACD,MAAM;oBACR,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,+BAA+B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACtE,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAClC,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY;QACxB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAM,IAAI,kBAAkB,CAC1B,yBAAyB,EACzB;gBACE,IAAI,EAAE;oBACJ,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;oBACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;iBACxB;aACF,CACF,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC7C,0EAA0E;YAC1E,MAAM,cAAc,GAAa,EAAE,CAAC;YAEpC,4CAA4C;YAC5C,MAAM,gBAAgB,GAAG,GAAG,EAAE;gBAC5B,IAAI,CAAC,IAAI,CAAC,MAAM;oBAAE,OAAO;gBACzB,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAC3C,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;gBAC7C,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;gBAC7C,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAC3C,CAAC,CAAC;YAEF,MAAM,MAAM,GAAG,CAAC,IAAY,EAAE,EAAE;gBAC9B,gEAAgE;gBAChE,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAE1B,+CAA+C;gBAC/C,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAE9D,uCAAuC;gBACvC,IAAI,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE,CAAC;oBAC1C,qBAAqB;oBACrB,gBAAgB,EAAE,CAAC;oBAEnB,MAAM,eAAe,GAAG,YAAY,CAAC,IAAI,EAAE,CAAC;oBAC5C,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,eAAe,EAAE,CAAC,CAAC;oBAE5C,qCAAqC;oBACrC,IAAI,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,CAAC;wBACvC,MAAM,IAAI,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;wBAC1C,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,CAAC;oBAC9D,CAAC;yBAAM,CAAC;wBACN,OAAO,CAAC,eAAe,CAAC,CAAC;oBAC3B,CAAC;gBACH,CAAC;YACH,CAAC,CAAC;YAEF,MAAM,OAAO,GAAG,CAAC,GAAU,EAAE,EAAE;gBAC7B,gBAAgB,EAAE,CAAC;gBAEnB,MAAM,CAAC,IAAI,kBAAkB,CAC3B,4CAA4C,GAAG,CAAC,OAAO,EAAE,EACzD;oBACE,IAAI,EAAE;wBACJ,KAAK,EAAE,GAAG,CAAC,OAAO;qBACnB;iBACF,CACF,CAAC,CAAC;YACL,CAAC,CAAC;YAEF,MAAM,OAAO,GAAG,GAAG,EAAE;gBACnB,gBAAgB,EAAE,CAAC;gBAEnB,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAC9D,MAAM,CAAC,IAAI,kBAAkB,CAC3B,8CAA8C,EAC9C;oBACE,IAAI,EAAE;wBACJ,eAAe,EAAE,YAAY;qBAC9B;iBACF,CACF,CAAC,CAAC;YACL,CAAC,CAAC;YAEF,MAAM,KAAK,GAAG,GAAG,EAAE;gBACjB,gBAAgB,EAAE,CAAC;gBAEnB,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAC9D,MAAM,CAAC,IAAI,kBAAkB,CAC3B,6CAA6C,EAC7C;oBACE,IAAI,EAAE;wBACJ,eAAe,EAAE,YAAY;qBAC9B;iBACF,CACF,CAAC,CAAC;YACL,CAAC,CAAC;YAEF,mBAAmB;YACnB,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YACnC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YACnC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,kBAAkB,CAAC,QAAgB;QACzC,sCAAsC;QACtC,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACrC,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,8CAA8C;QAExF,gEAAgE;QAChE,0CAA0C;QAC1C,IAAI,QAAQ,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,4BAA4B;QAC5B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3E,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACK,eAAe,CAAC,QAAgB;QACtC,2CAA2C;QAC3C,MAAM,IAAI,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAEtC,8BAA8B;QAC9B,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IACtD,CAAC;IAED;;;;OAIG;IACK,uBAAuB,CAAC,QAAgB,EAAE,IAAY;QAC5D,uBAAuB;QACvB,MAAM,OAAO,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAE7C,QAAQ,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YACvB,KAAK,GAAG,EAAE,mBAAmB;gBAC3B,OAAO,gBAAgB,CAAC,SAAS,CAC/B,OAAO,EACP,WAAW,EACX,IAAI,EACJ,QAAQ,CACT,CAAC;YAEJ,KAAK,GAAG,EAAE,mBAAmB;gBAC3B,OAAO,gBAAgB,CAAC,SAAS,CAC/B,OAAO,EACP,WAAW,EACX,IAAI,EACJ,QAAQ,CACT,CAAC;YAEJ;gBACE,OAAO,IAAI,gBAAgB,CACzB,8BAA8B,QAAQ,EAAE,EACxC;oBACE,IAAI,EAAE;wBACJ,QAAQ;wBACR,IAAI;qBACL;iBACF,CACF,CAAC;QACN,CAAC;IACH,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,KAAK;QAChB,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACpC,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,YAAY;YACZ,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QACjC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,+BAA+B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACrE,CAAC;gBAAS,CAAC;YACT,eAAe;YACf,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;YACxB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,OAAO,IAAI,CAAC,SAAS,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;IACzC,CAAC;IAED;;;OAGG;IACI,aAAa,CAAC,OAAoC;QACvD,IAAI,CAAC,OAAO,GAAG;YACb,GAAG,IAAI,CAAC,OAAO;YACf,GAAG,OAAO;SACX,CAAC;QAEF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6BAA6B,CAAC,CAAC;IACpD,CAAC;CACF"}
|