claude-flow-novice 1.0.0

package/dist/src/quality-gates/automated-review-system.js

@@ -0,0 +1,645 @@
+import { EventEmitter } from 'events';
+import { promises as fs } from 'fs';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class AutomatedReviewSystem extends EventEmitter {
+    reviewHistory = [];
+    activeReviews = new Map();
+    config;
+    reviewers = new Map();
+    constructor(config = {}){
+        super();
+        this.config = this.mergeWithDefaults(config);
+        this.initializeReviewers();
+    }
+    mergeWithDefaults(config) {
+        return {
+            stages: {
+                preCommit: {
+                    enabled: true,
+                    blocksProgression: true,
+                    requiredChecks: [
+                        'lint',
+                        'format',
+                        'types'
+                    ],
+                    reviewers: [],
+                    autoApprove: true,
+                    timeoutMinutes: 5
+                },
+                prReview: {
+                    enabled: true,
+                    blocksProgression: true,
+                    requiredChecks: [
+                        'lint',
+                        'test',
+                        'security',
+                        'complexity'
+                    ],
+                    reviewers: [
+                        'automated-reviewer',
+                        'senior-developer'
+                    ],
+                    autoApprove: false,
+                    timeoutMinutes: 240
+                },
+                preDeployment: {
+                    enabled: true,
+                    blocksProgression: true,
+                    requiredChecks: [
+                        'test',
+                        'security',
+                        'performance',
+                        'integration'
+                    ],
+                    reviewers: [
+                        'deployment-manager',
+                        'tech-lead'
+                    ],
+                    autoApprove: false,
+                    timeoutMinutes: 60
+                },
+                postDeployment: {
+                    enabled: true,
+                    blocksProgression: false,
+                    requiredChecks: [
+                        'monitoring',
+                        'performance',
+                        'health'
+                    ],
+                    reviewers: [
+                        'sre-team'
+                    ],
+                    autoApprove: true,
+                    timeoutMinutes: 30
+                },
+                ...config.stages
+            },
+            tools: {
+                linting: {
+                    eslint: true,
+                    prettier: true,
+                    typescript: true,
+                    customRules: []
+                },
+                security: {
+                    auditDependencies: true,
+                    secretScanning: true,
+                    codeAnalysis: true,
+                    licenseCheck: true
+                },
+                testing: {
+                    unitTests: true,
+                    integrationTests: true,
+                    e2eTests: true,
+                    coverageThreshold: 80,
+                    performanceTests: false
+                },
+                performance: {
+                    bundleSize: true,
+                    loadTime: true,
+                    memoryUsage: false,
+                    cpuUsage: false
+                },
+                ...config.tools
+            }
+        };
+    }
+    initializeReviewers() {
+        // Initialize automated reviewers with different specializations
+        this.reviewers.set('automated-reviewer', {
+            type: 'automated',
+            specializations: [
+                'general',
+                'style',
+                'complexity'
+            ],
+            weight: 1.0
+        });
+        this.reviewers.set('security-reviewer', {
+            type: 'automated',
+            specializations: [
+                'security',
+                'vulnerability-analysis'
+            ],
+            weight: 1.0
+        });
+        this.reviewers.set('performance-reviewer', {
+            type: 'automated',
+            specializations: [
+                'performance',
+                'optimization'
+            ],
+            weight: 0.8
+        });
+        this.reviewers.set('test-reviewer', {
+            type: 'automated',
+            specializations: [
+                'testing',
+                'coverage'
+            ],
+            weight: 0.9
+        });
+    }
+    async startReview(filePaths, stage, metadata = {}) {
+        const reviewId = `review_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const stageConfig = this.config.stages[stage];
+        if (!stageConfig.enabled) {
+            throw new Error(`Quality gate stage ${stage} is disabled`);
+        }
+        const review = {
+            id: reviewId,
+            timestamp: new Date(),
+            filePath: filePaths[0],
+            metrics: {
+                complexity: 0,
+                maintainability: 0,
+                duplications: 0,
+                testCoverage: 0,
+                securityScore: 0,
+                performanceScore: 0,
+                linesOfCode: 0,
+                technicalDebt: 0
+            },
+            criteria: this.getReviewCriteria(stage),
+            passed: false,
+            issues: [],
+            suggestions: [],
+            autoFixable: false,
+            blocksDeployment: stageConfig.blocksProgression,
+            reviewerComments: []
+        };
+        this.activeReviews.set(reviewId, review);
+        this.emit('review:started', {
+            reviewId,
+            stage,
+            filePaths,
+            metadata
+        });
+        // Run parallel checks based on stage requirements
+        const checkPromises = stageConfig.requiredChecks.map((check)=>this.runQualityCheck(check, filePaths, review));
+        try {
+            await Promise.all(checkPromises);
+            // Analyze results and make final decision
+            review.passed = this.evaluateReviewResults(review);
+            review.autoFixable = review.issues.every((issue)=>issue.fixable);
+            this.reviewHistory.push(review);
+            this.activeReviews.delete(reviewId);
+            this.emit('review:completed', {
+                review,
+                stage
+            });
+            if (!review.passed && review.blocksDeployment) {
+                this.emit('review:blocked', {
+                    review,
+                    stage
+                });
+            }
+            return reviewId;
+        } catch (error) {
+            review.passed = false;
+            review.issues.push({
+                type: 'maintainability',
+                severity: 'critical',
+                line: 0,
+                column: 0,
+                message: `Review failed: ${error instanceof Error ? error.message : String(error)}`,
+                rule: 'review-system',
+                fixable: false
+            });
+            this.emit('review:failed', {
+                reviewId,
+                error,
+                stage
+            });
+            return reviewId;
+        }
+    }
+    getReviewCriteria(stage) {
+        const baseThresholds = {
+            preCommit: {
+                minComplexity: 10,
+                minMaintainability: 60,
+                maxDuplications: 5,
+                minTestCoverage: 0,
+                minSecurityScore: 70,
+                minPerformanceScore: 70,
+                maxTechnicalDebt: 30
+            },
+            prReview: {
+                minComplexity: 15,
+                minMaintainability: 70,
+                maxDuplications: 3,
+                minTestCoverage: 80,
+                minSecurityScore: 80,
+                minPerformanceScore: 75,
+                maxTechnicalDebt: 20
+            },
+            preDeployment: {
+                minComplexity: 20,
+                minMaintainability: 80,
+                maxDuplications: 2,
+                minTestCoverage: 85,
+                minSecurityScore: 90,
+                minPerformanceScore: 80,
+                maxTechnicalDebt: 15
+            },
+            postDeployment: {
+                minComplexity: 25,
+                minMaintainability: 85,
+                maxDuplications: 1,
+                minTestCoverage: 90,
+                minSecurityScore: 95,
+                minPerformanceScore: 85,
+                maxTechnicalDebt: 10
+            }
+        };
+        const thresholds = baseThresholds[stage];
+        return {
+            ...thresholds,
+            requiredChecks: this.config.stages[stage].requiredChecks
+        };
+    }
+    async runQualityCheck(checkType, filePaths, review) {
+        switch(checkType){
+            case 'lint':
+                await this.runLinting(filePaths, review);
+                break;
+            case 'format':
+                await this.runFormatting(filePaths, review);
+                break;
+            case 'types':
+                await this.runTypeChecking(filePaths, review);
+                break;
+            case 'test':
+                await this.runTestAnalysis(filePaths, review);
+                break;
+            case 'security':
+                await this.runSecurityAnalysis(filePaths, review);
+                break;
+            case 'performance':
+                await this.runPerformanceAnalysis(filePaths, review);
+                break;
+            case 'complexity':
+                await this.runComplexityAnalysis(filePaths, review);
+                break;
+            case 'integration':
+                await this.runIntegrationChecks(filePaths, review);
+                break;
+            case 'monitoring':
+                await this.runMonitoringChecks(filePaths, review);
+                break;
+            case 'health':
+                await this.runHealthChecks(filePaths, review);
+                break;
+            default:
+                console.warn(`Unknown check type: ${checkType}`);
+        }
+    }
+    async runLinting(filePaths, review) {
+        if (!this.config.tools.linting.eslint) return;
+        try {
+            const { stdout, stderr } = await execAsync(`npx eslint ${filePaths.join(' ')} --format json`);
+            const lintResults = JSON.parse(stdout);
+            for (const result of lintResults){
+                for (const message of result.messages){
+                    review.issues.push({
+                        type: this.mapEslintRuleType(message.ruleId),
+                        severity: this.mapEslintSeverity(message.severity),
+                        line: message.line,
+                        column: message.column,
+                        message: message.message,
+                        rule: message.ruleId || 'unknown',
+                        fixable: message.fix !== undefined
+                    });
+                }
+            }
+        } catch (error) {
+            // ESLint returns non-zero exit code for lint errors, parse the output anyway
+            if (error instanceof Error && 'stdout' in error) {
+                try {
+                    const lintResults = JSON.parse(error.stdout);
+                // Process results as above
+                } catch (parseError) {
+                    review.issues.push({
+                        type: 'style',
+                        severity: 'major',
+                        line: 0,
+                        column: 0,
+                        message: `Linting failed: ${error.message}`,
+                        rule: 'eslint-error',
+                        fixable: false
+                    });
+                }
+            }
+        }
+    }
+    async runFormatting(filePaths, review) {
+        if (!this.config.tools.linting.prettier) return;
+        try {
+            const { stdout } = await execAsync(`npx prettier --check ${filePaths.join(' ')}`);
+            // If no output, formatting is correct
+            if (!stdout.trim()) {
+                return;
+            }
+        } catch (error) {
+            review.issues.push({
+                type: 'style',
+                severity: 'minor',
+                line: 0,
+                column: 0,
+                message: 'Code formatting issues detected',
+                rule: 'prettier',
+                fixable: true,
+                suggestion: 'Run: npx prettier --write <files>'
+            });
+        }
+    }
+    async runTypeChecking(filePaths, review) {
+        if (!this.config.tools.linting.typescript) return;
+        try {
+            const { stdout, stderr } = await execAsync('npx tsc --noEmit');
+            if (stderr) {
+                const typeErrors = stderr.split('\n').filter((line)=>line.includes('error TS') && filePaths.some((path)=>line.includes(path)));
+                for (const error of typeErrors){
+                    const match = error.match(/(.+?)\((\d+),(\d+)\): error TS(\d+): (.+)/);
+                    if (match) {
+                        review.issues.push({
+                            type: 'maintainability',
+                            severity: 'major',
+                            line: parseInt(match[2]),
+                            column: parseInt(match[3]),
+                            message: match[5],
+                            rule: `TS${match[4]}`,
+                            fixable: false
+                        });
+                    }
+                }
+            }
+        } catch (error) {
+        // TypeScript errors are expected in stderr
+        }
+    }
+    async runTestAnalysis(filePaths, review) {
+        try {
+            // Run test coverage analysis
+            const { stdout } = await execAsync('npm run test:coverage -- --reporter=json');
+            const coverageData = JSON.parse(stdout);
+            if (coverageData.total) {
+                review.metrics.testCoverage = coverageData.total.lines.pct;
+                if (review.metrics.testCoverage < review.criteria.minTestCoverage) {
+                    review.issues.push({
+                        type: 'testing',
+                        severity: 'major',
+                        line: 0,
+                        column: 0,
+                        message: `Test coverage (${review.metrics.testCoverage}%) below threshold (${review.criteria.minTestCoverage}%)`,
+                        rule: 'coverage-threshold',
+                        fixable: false,
+                        suggestion: 'Add more tests to improve coverage'
+                    });
+                }
+            }
+        } catch (error) {
+            review.issues.push({
+                type: 'testing',
+                severity: 'major',
+                line: 0,
+                column: 0,
+                message: 'Failed to analyze test coverage',
+                rule: 'test-analysis',
+                fixable: false
+            });
+        }
+    }
+    async runSecurityAnalysis(filePaths, review) {
+        if (!this.config.tools.security.auditDependencies) return;
+        try {
+            const { stdout } = await execAsync('npm audit --json');
+            const auditData = JSON.parse(stdout);
+            if (auditData.vulnerabilities) {
+                for (const [name, vuln] of Object.entries(auditData.vulnerabilities)){
+                    const vulnData = vuln;
+                    review.issues.push({
+                        type: 'security',
+                        severity: this.mapAuditSeverity(vulnData.severity),
+                        line: 0,
+                        column: 0,
+                        message: `Security vulnerability in ${name}: ${vulnData.title}`,
+                        rule: 'npm-audit',
+                        fixable: vulnData.fixAvailable !== false
+                    });
+                }
+            }
+            // Calculate security score based on vulnerabilities
+            const criticalCount = Object.values(auditData.vulnerabilities || {}).filter((v)=>v.severity === 'critical').length;
+            const highCount = Object.values(auditData.vulnerabilities || {}).filter((v)=>v.severity === 'high').length;
+            review.metrics.securityScore = Math.max(0, 100 - (criticalCount * 25 + highCount * 10));
+        } catch (error) {
+            review.metrics.securityScore = 50; // Unknown security status
+        }
+    }
+    async runPerformanceAnalysis(filePaths, review) {
+        // Simplified performance analysis
+        try {
+            let totalSize = 0;
+            for (const filePath of filePaths){
+                const stats = await fs.stat(filePath);
+                totalSize += stats.size;
+                review.metrics.linesOfCode += (await fs.readFile(filePath, 'utf-8')).split('\n').length;
+            }
+            // Simple performance score based on file size and complexity
+            review.metrics.performanceScore = Math.max(0, 100 - Math.floor(totalSize / 10000) * 5);
+            if (totalSize > 100000) {
+                // 100KB threshold
+                review.issues.push({
+                    type: 'performance',
+                    severity: 'minor',
+                    line: 0,
+                    column: 0,
+                    message: `Large file size (${Math.round(totalSize / 1024)}KB) may impact performance`,
+                    rule: 'file-size',
+                    fixable: false,
+                    suggestion: 'Consider code splitting or optimization'
+                });
+            }
+        } catch (error) {
+            review.metrics.performanceScore = 70; // Default score
+        }
+    }
+    async runComplexityAnalysis(filePaths, review) {
+        // Simplified complexity analysis
+        let totalComplexity = 0;
+        let fileCount = 0;
+        for (const filePath of filePaths){
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const complexity = this.calculateCyclomaticComplexity(content);
+                totalComplexity += complexity;
+                fileCount++;
+                if (complexity > 20) {
+                    review.issues.push({
+                        type: 'complexity',
+                        severity: 'major',
+                        line: 0,
+                        column: 0,
+                        message: `High cyclomatic complexity (${complexity})`,
+                        rule: 'complexity-threshold',
+                        fixable: false,
+                        suggestion: 'Consider breaking down complex functions'
+                    });
+                }
+            } catch (error) {
+            // Skip files that can't be read
+            }
+        }
+        review.metrics.complexity = fileCount > 0 ? totalComplexity / fileCount : 0;
+        review.metrics.maintainability = Math.max(0, 100 - review.metrics.complexity * 2);
+    }
+    calculateCyclomaticComplexity(code) {
+        // Simplified cyclomatic complexity calculation
+        const complexityPatterns = [
+            /\bif\b/g,
+            /\belse\b/g,
+            /\bwhile\b/g,
+            /\bfor\b/g,
+            /\bswitch\b/g,
+            /\bcase\b/g,
+            /\bcatch\b/g,
+            /\b&&\b/g,
+            /\b\|\|\b/g,
+            /\?\s*.*\s*:/g
+        ];
+        let complexity = 1; // Base complexity
+        for (const pattern of complexityPatterns){
+            const matches = code.match(pattern);
+            complexity += matches ? matches.length : 0;
+        }
+        return complexity;
+    }
+    async runIntegrationChecks(filePaths, review) {
+        // Run integration-specific checks
+        review.suggestions.push({
+            type: 'test',
+            description: 'Consider adding integration tests',
+            impact: 'medium',
+            effort: 'medium',
+            priority: 3
+        });
+    }
+    async runMonitoringChecks(filePaths, review) {
+        // Check for monitoring instrumentation
+        const hasLogging = filePaths.some(async (filePath)=>{
+            const content = await fs.readFile(filePath, 'utf-8');
+            return content.includes('console.log') || content.includes('logger');
+        });
+        if (!hasLogging) {
+            review.suggestions.push({
+                type: 'document',
+                description: 'Add logging for better observability',
+                impact: 'medium',
+                effort: 'low',
+                priority: 4
+            });
+        }
+    }
+    async runHealthChecks(filePaths, review) {
+        // Post-deployment health checks
+        review.suggestions.push({
+            type: 'document',
+            description: 'Ensure health check endpoints are available',
+            impact: 'high',
+            effort: 'low',
+            priority: 5
+        });
+    }
+    evaluateReviewResults(review) {
+        const criticalIssues = review.issues.filter((issue)=>issue.severity === 'critical').length;
+        const majorIssues = review.issues.filter((issue)=>issue.severity === 'major').length;
+        // Fail if there are critical issues
+        if (criticalIssues > 0) return false;
+        // Fail if too many major issues
+        if (majorIssues > 5) return false;
+        // Check metrics against criteria
+        const metrics = review.metrics;
+        const criteria = review.criteria;
+        if (metrics.testCoverage < criteria.minTestCoverage) return false;
+        if (metrics.securityScore < criteria.minSecurityScore) return false;
+        if (metrics.maintainability < criteria.minMaintainability) return false;
+        if (metrics.duplications > criteria.maxDuplications) return false;
+        return true;
+    }
+    mapEslintRuleType(ruleId) {
+        if (!ruleId) return 'style';
+        if (ruleId.includes('security')) return 'security';
+        if (ruleId.includes('performance')) return 'performance';
+        if (ruleId.includes('complexity')) return 'complexity';
+        if (ruleId.includes('test')) return 'testing';
+        return 'style';
+    }
+    mapEslintSeverity(severity) {
+        switch(severity){
+            case 2:
+                return 'major';
+            case 1:
+                return 'minor';
+            default:
+                return 'info';
+        }
+    }
+    mapAuditSeverity(severity) {
+        switch(severity.toLowerCase()){
+            case 'critical':
+                return 'critical';
+            case 'high':
+                return 'major';
+            case 'moderate':
+                return 'minor';
+            default:
+                return 'info';
+        }
+    }
+    getReview(reviewId) {
+        return this.reviewHistory.find((review)=>review.id === reviewId) || this.activeReviews.get(reviewId);
+    }
+    getActiveReviews() {
+        return Array.from(this.activeReviews.values());
+    }
+    getReviewHistory() {
+        return [
+            ...this.reviewHistory
+        ];
+    }
+    async autoFix(reviewId) {
+        const review = this.getReview(reviewId);
+        if (!review || !review.autoFixable) return false;
+        const fixableIssues = review.issues.filter((issue)=>issue.fixable);
+        for (const issue of fixableIssues){
+            try {
+                await this.applyAutoFix(issue, review.filePath);
+            } catch (error) {
+                console.error(`Failed to auto-fix issue ${issue.rule}:`, error);
+            }
+        }
+        this.emit('review:auto-fixed', {
+            reviewId,
+            fixedIssues: fixableIssues
+        });
+        return true;
+    }
+    async applyAutoFix(issue, filePath) {
+        switch(issue.rule){
+            case 'prettier':
+                await execAsync(`npx prettier --write ${filePath}`);
+                break;
+            case 'eslint':
+                await execAsync(`npx eslint --fix ${filePath}`);
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+//# sourceMappingURL=automated-review-system.js.map

package/dist/src/quality-gates/automated-review-system.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/quality-gates/automated-review-system.ts"],"names":["EventEmitter","promises","fs","exec","promisify","execAsync","AutomatedReviewSystem","reviewHistory","activeReviews","Map","config","reviewers","mergeWithDefaults","initializeReviewers","stages","preCommit","enabled","blocksProgression","requiredChecks","autoApprove","timeoutMinutes","prReview","preDeployment","postDeployment","tools","linting","eslint","prettier","typescript","customRules","security","auditDependencies","secretScanning","codeAnalysis","licenseCheck","testing","unitTests","integrationTests","e2eTests","coverageThreshold","performanceTests","performance","bundleSize","loadTime","memoryUsage","cpuUsage","set","type","specializations","weight","startReview","filePaths","stage","metadata","reviewId","Date","now","Math","random","toString","substr","stageConfig","Error","review","id","timestamp","filePath","metrics","complexity","maintainability","duplications","testCoverage","securityScore","performanceScore","linesOfCode","technicalDebt","criteria","getReviewCriteria","passed","issues","suggestions","autoFixable","blocksDeployment","reviewerComments","emit","checkPromises","map","check","runQualityCheck","Promise","all","evaluateReviewResults","every","issue","fixable","push","delete","error","severity","line","column","message","String","rule","baseThresholds","minComplexity","minMaintainability","maxDuplications","minTestCoverage","minSecurityScore","minPerformanceScore","maxTechnicalDebt","thresholds","checkType","runLinting","runFormatting","runTypeChecking","runTestAnalysis","runSecurityAnalysis","runPerformanceAnalysis","runComplexityAnalysis","runIntegrationChecks","runMonitoringChecks","runHealthChecks","console","warn","stdout","stderr","join","lintResults","JSON","parse","result","messages","mapEslintRuleType","ruleId","mapEslintSeverity","fix","undefined","parseError","trim","suggestion","typeErrors","split","filter","includes","some","path","match","parseInt","coverageData","total","lines","pct","auditData","vulnerabilities","name","vuln","Object","entries","vulnData","mapAuditSeverity","title","fixAvailable","criticalCount","values","v","length","highCount","max","totalSize","stats","stat","size","readFile","floor","round","totalComplexity","fileCount","content","calculateCyclomaticComplexity","code","complexityPatterns","pattern","matches","description","impact","effort","priority","hasLogging","criticalIssues","majorIssues","toLowerCase","getReview","find","get","getActiveReviews","Array","from","getReviewHistory","autoFix","fixableIssues","applyAutoFix","fixedIssues"],"mappings":"AAAA,SAASA,YAAY,QAAQ,SAAS;AACtC,SAASC,YAAYC,EAAE,QAAQ,KAAK;AACpC,SAASC,IAAI,QAAQ,gBAAgB;AACrC,SAASC,SAAS,QAAQ,OAAO;AAEjC,MAAMC,YAAYD,UAAUD;AAwH5B,OAAO,MAAMG,8BAA8BN;IACjCO,gBAAgC,EAAE,CAAC;IACnCC,gBAA2C,IAAIC,MAAM;IACrDC,OAA0B;IAC1BC,YAA8B,IAAIF,MAAM;IAEhD,YAAYC,SAAqC,CAAC,CAAC,CAAE;QACnD,KAAK;QACL,IAAI,CAACA,MAAM,GAAG,IAAI,CAACE,iBAAiB,CAACF;QACrC,IAAI,CAACG,mBAAmB;IAC1B;IAEQD,kBAAkBF,MAAkC,EAAqB;QAC/E,OAAO;YACLI,QAAQ;gBACNC,WAAW;oBACTC,SAAS;oBACTC,mBAAmB;oBACnBC,gBAAgB;wBAAC;wBAAQ;wBAAU;qBAAQ;oBAC3CP,WAAW,EAAE;oBACbQ,aAAa;oBACbC,gBAAgB;gBAClB;gBACAC,UAAU;oBACRL,SAAS;oBACTC,mBAAmB;oBACnBC,gBAAgB;wBAAC;wBAAQ;wBAAQ;wBAAY;qBAAa;oBAC1DP,WAAW;wBAAC;wBAAsB;qBAAmB;oBACrDQ,aAAa;oBACbC,gBAAgB;gBAClB;gBACAE,eAAe;oBACbN,SAAS;oBACTC,mBAAmB;oBACnBC,gBAAgB;wBAAC;wBAAQ;wBAAY;wBAAe;qBAAc;oBAClEP,WAAW;wBAAC;wBAAsB;qBAAY;oBAC9CQ,aAAa;oBACbC,gBAAgB;gBAClB;gBACAG,gBAAgB;oBACdP,SAAS;oBACTC,mBAAmB;oBACnBC,gBAAgB;wBAAC;wBAAc;wBAAe;qBAAS;oBACvDP,WAAW;wBAAC;qBAAW;oBACvBQ,aAAa;oBACbC,gBAAgB;gBAClB;gBACA,GAAGV,OAAOI,MAAM;YAClB;YACAU,OAAO;gBACLC,SAAS;oBACPC,QAAQ;oBACRC,UAAU;oBACVC,YAAY;oBACZC,aAAa,EAAE;gBACjB;gBACAC,UAAU;oBACRC,mBAAmB;oBACnBC,gBAAgB;oBAChBC,cAAc;oBACdC,cAAc;gBAChB;gBACAC,SAAS;oBACPC,WAAW;oBACXC,kBAAkB;oBAClBC,UAAU;oBACVC,mBAAmB;oBACnBC,kBAAkB;gBACpB;gBACAC,aAAa;oBACXC,YAAY;oBACZC,UAAU;oBACVC,aAAa;oBACbC,UAAU;gBACZ;gBACA,GAAGnC,OAAOc,KAAK;YACjB;QACF;IACF;IAEQX,sBAA4B;QAClC,gEAAgE;QAChE,IAAI,CAACF,SAAS,CAACmC,GAAG,CAAC,sBAAsB;YACvCC,MAAM;YACNC,iBAAiB;gBAAC;gBAAW;gBAAS;aAAa;YACnDC,QAAQ;QACV;QAEA,IAAI,CAACtC,SAAS,CAACmC,GAAG,CAAC,qBAAqB;YACtCC,MAAM;YACNC,iBAAiB;gBAAC;gBAAY;aAAyB;YACvDC,QAAQ;QACV;QAEA,IAAI,CAACtC,SAAS,CAACmC,GAAG,CAAC,wBAAwB;YACzCC,MAAM;YACNC,iBAAiB;gBAAC;gBAAe;aAAe;YAChDC,QAAQ;QACV;QAEA,IAAI,CAACtC,SAAS,CAACmC,GAAG,CAAC,iBAAiB;YAClCC,MAAM;YACNC,iBAAiB;gBAAC;gBAAW;aAAW;YACxCC,QAAQ;QACV;IACF;IAEA,MAAaC,YACXC,SAAmB,EACnBC,KAAwC,EACxCC,WAAgB,CAAC,CAAC,EACD;QACjB,MAAMC,WAAW,CAAC,OAAO,EAAEC,KAAKC,GAAG,GAAG,CAAC,EAAEC,KAAKC,MAAM,GAAGC,QAAQ,CAAC,IAAIC,MAAM,CAAC,GAAG,IAAI;QAClF,MAAMC,cAAc,IAAI,CAACnD,MAAM,CAACI,MAAM,CAACsC,MAAM;QAE7C,IAAI,CAACS,YAAY7C,OAAO,EAAE;YACxB,MAAM,IAAI8C,MAAM,CAAC,mBAAmB,EAAEV,MAAM,YAAY,CAAC;QAC3D;QAEA,MAAMW,SAAuB;YAC3BC,IAAIV;YACJW,WAAW,IAAIV;YACfW,UAAUf,SAAS,CAAC,EAAE;YACtBgB,SAAS;gBACPC,YAAY;gBACZC,iBAAiB;gBACjBC,cAAc;gBACdC,cAAc;gBACdC,eAAe;gBACfC,kBAAkB;gBAClBC,aAAa;gBACbC,eAAe;YACjB;YACAC,UAAU,IAAI,CAACC,iBAAiB,CAACzB;YACjC0B,QAAQ;YACRC,QAAQ,EAAE;YACVC,aAAa,EAAE;YACfC,aAAa;YACbC,kBAAkBrB,YAAY5C,iBAAiB;YAC/CkE,kBAAkB,EAAE;QACtB;QAEA,IAAI,CAAC3E,aAAa,CAACsC,GAAG,CAACQ,UAAUS;QACjC,IAAI,CAACqB,IAAI,CAAC,kBAAkB;YAAE9B;YAAUF;YAAOD;YAAWE;QAAS;QAEnE,kDAAkD;QAClD,MAAMgC,gBAAgBxB,YAAY3C,cAAc,CAACoE,GAAG,CAAC,CAACC,QACpD,IAAI,CAACC,eAAe,CAACD,OAAOpC,WAAWY;QAGzC,IAAI;YACF,MAAM0B,QAAQC,GAAG,CAACL;YAElB,0CAA0C;YAC1CtB,OAAOe,MAAM,GAAG,IAAI,CAACa,qBAAqB,CAAC5B;YAC3CA,OAAOkB,WAAW,GAAGlB,OAAOgB,MAAM,CAACa,KAAK,CAAC,CAACC,QAAUA,MAAMC,OAAO;YAEjE,IAAI,CAACvF,aAAa,CAACwF,IAAI,CAAChC;YACxB,IAAI,CAACvD,aAAa,CAACwF,MAAM,CAAC1C;YAE1B,IAAI,CAAC8B,IAAI,CAAC,oBAAoB;gBAAErB;gBAAQX;YAAM;YAE9C,IAAI,CAACW,OAAOe,MAAM,IAAIf,OAAOmB,gBAAgB,EAAE;gBAC7C,IAAI,CAACE,IAAI,CAAC,kBAAkB;oBAAErB;oBAAQX;gBAAM;YAC9C;YAEA,OAAOE;QACT,EAAE,OAAO2C,OAAO;YACdlC,OAAOe,MAAM,GAAG;YAChBf,OAAOgB,MAAM,CAACgB,IAAI,CAAC;gBACjBhD,MAAM;gBACNmD,UAAU;gBACVC,MAAM;gBACNC,QAAQ;gBACRC,SAAS,CAAC,eAAe,EAAEJ,iBAAiBnC,QAAQmC,MAAMI,OAAO,GAAGC,OAAOL,QAAQ;gBACnFM,MAAM;gBACNT,SAAS;YACX;YAEA,IAAI,CAACV,IAAI,CAAC,iBAAiB;gBAAE9B;gBAAU2C;gBAAO7C;YAAM;YACpD,OAAOE;QACT;IACF;IAEQuB,kBAAkBzB,KAAwC,EAAkB;QAClF,MAAMoD,iBAAiB;YACrBzF,WAAW;gBACT0F,eAAe;gBACfC,oBAAoB;gBACpBC,iBAAiB;gBACjBC,iBAAiB;gBACjBC,kBAAkB;gBAClBC,qBAAqB;gBACrBC,kBAAkB;YACpB;YACA1F,UAAU;gBACRoF,eAAe;gBACfC,oBAAoB;gBACpBC,iBAAiB;gBACjBC,iBAAiB;gBACjBC,kBAAkB;gBAClBC,qBAAqB;gBACrBC,kBAAkB;YACpB;YACAzF,eAAe;gBACbmF,eAAe;gBACfC,oBAAoB;gBACpBC,iBAAiB;gBACjBC,iBAAiB;gBACjBC,kBAAkB;gBAClBC,qBAAqB;gBACrBC,kBAAkB;YACpB;YACAxF,gBAAgB;gBACdkF,eAAe;gBACfC,oBAAoB;gBACpBC,iBAAiB;gBACjBC,iBAAiB;gBACjBC,kBAAkB;gBAClBC,qBAAqB;gBACrBC,kBAAkB;YACpB;QACF;QAEA,MAAMC,aAAaR,cAAc,CAACpD,MAAM;QACxC,OAAO;YACL,GAAG4D,UAAU;YACb9F,gBAAgB,IAAI,CAACR,MAAM,CAACI,MAAM,CAACsC,MAAM,CAAClC,cAAc;QAC1D;IACF;IAEA,MAAcsE,gBACZyB,SAAiB,EACjB9D,SAAmB,EACnBY,MAAoB,EACL;QACf,OAAQkD;YACN,KAAK;gBACH,MAAM,IAAI,CAACC,UAAU,CAAC/D,WAAWY;gBACjC;YACF,KAAK;gBACH,MAAM,IAAI,CAACoD,aAAa,CAAChE,WAAWY;gBACpC;YACF,KAAK;gBACH,MAAM,IAAI,CAACqD,eAAe,CAACjE,WAAWY;gBACtC;YACF,KAAK;gBACH,MAAM,IAAI,CAACsD,eAAe,CAAClE,WAAWY;gBACtC;YACF,KAAK;gBACH,MAAM,IAAI,CAACuD,mBAAmB,CAACnE,WAAWY;gBAC1C;YACF,KAAK;gBACH,MAAM,IAAI,CAACwD,sBAAsB,CAACpE,WAAWY;gBAC7C;YACF,KAAK;gBACH,MAAM,IAAI,CAACyD,qBAAqB,CAACrE,WAAWY;gBAC5C;YACF,KAAK;gBACH,MAAM,IAAI,CAAC0D,oBAAoB,CAACtE,WAAWY;gBAC3C;YACF,KAAK;gBACH,MAAM,IAAI,CAAC2D,mBAAmB,CAACvE,WAAWY;gBAC1C;YACF,KAAK;gBACH,MAAM,IAAI,CAAC4D,eAAe,CAACxE,WAAWY;gBACtC;YACF;gBACE6D,QAAQC,IAAI,CAAC,CAAC,oBAAoB,EAAEZ,WAAW;QACnD;IACF;IAEA,MAAcC,WAAW/D,SAAmB,EAAEY,MAAoB,EAAiB;QACjF,IAAI,CAAC,IAAI,CAACrD,MAAM,CAACc,KAAK,CAACC,OAAO,CAACC,MAAM,EAAE;QAEvC,IAAI;YACF,MAAM,EAAEoG,MAAM,EAAEC,MAAM,EAAE,GAAG,MAAM1H,UAAU,CAAC,WAAW,EAAE8C,UAAU6E,IAAI,CAAC,KAAK,cAAc,CAAC;YAE5F,MAAMC,cAAcC,KAAKC,KAAK,CAACL;YAE/B,KAAK,MAAMM,UAAUH,YAAa;gBAChC,KAAK,MAAM5B,WAAW+B,OAAOC,QAAQ,CAAE;oBACrCtE,OAAOgB,MAAM,CAACgB,IAAI,CAAC;wBACjBhD,MAAM,IAAI,CAACuF,iBAAiB,CAACjC,QAAQkC,MAAM;wBAC3CrC,UAAU,IAAI,CAACsC,iBAAiB,CAACnC,QAAQH,QAAQ;wBACjDC,MAAME,QAAQF,IAAI;wBAClBC,QAAQC,QAAQD,MAAM;wBACtBC,SAASA,QAAQA,OAAO;wBACxBE,MAAMF,QAAQkC,MAAM,IAAI;wBACxBzC,SAASO,QAAQoC,GAAG,KAAKC;oBAC3B;gBACF;YACF;QACF,EAAE,OAAOzC,OAAO;YACd,6EAA6E;YAC7E,IAAIA,iBAAiBnC,SAAS,YAAYmC,OAAO;gBAC/C,IAAI;oBACF,MAAMgC,cAAcC,KAAKC,KAAK,CAAC,AAAClC,MAAc6B,MAAM;gBACpD,2BAA2B;gBAC7B,EAAE,OAAOa,YAAY;oBACnB5E,OAAOgB,MAAM,CAACgB,IAAI,CAAC;wBACjBhD,MAAM;wBACNmD,UAAU;wBACVC,MAAM;wBACNC,QAAQ;wBACRC,SAAS,CAAC,gBAAgB,EAAEJ,MAAMI,OAAO,EAAE;wBAC3CE,MAAM;wBACNT,SAAS;oBACX;gBACF;YACF;QACF;IACF;IAEA,MAAcqB,cAAchE,SAAmB,EAAEY,MAAoB,EAAiB;QACpF,IAAI,CAAC,IAAI,CAACrD,MAAM,CAACc,KAAK,CAACC,OAAO,CAACE,QAAQ,EAAE;QAEzC,IAAI;YACF,MAAM,EAAEmG,MAAM,EAAE,GAAG,MAAMzH,UAAU,CAAC,qBAAqB,EAAE8C,UAAU6E,IAAI,CAAC,MAAM;YAEhF,sCAAsC;YACtC,IAAI,CAACF,OAAOc,IAAI,IAAI;gBAClB;YACF;QACF,EAAE,OAAO3C,OAAO;YACdlC,OAAOgB,MAAM,CAACgB,IAAI,CAAC;gBACjBhD,MAAM;gBACNmD,UAAU;gBACVC,MAAM;gBACNC,QAAQ;gBACRC,SAAS;gBACTE,MAAM;gBACNT,SAAS;gBACT+C,YAAY;YACd;QACF;IACF;IAEA,MAAczB,gBAAgBjE,SAAmB,EAAEY,MAAoB,EAAiB;QACtF,IAAI,CAAC,IAAI,CAACrD,MAAM,CAACc,KAAK,CAACC,OAAO,CAACG,UAAU,EAAE;QAE3C,IAAI;YACF,MAAM,EAAEkG,MAAM,EAAEC,MAAM,EAAE,GAAG,MAAM1H,UAAU;YAE3C,IAAI0H,QAAQ;gBACV,MAAMe,aAAaf,OAChBgB,KAAK,CAAC,MACNC,MAAM,CACL,CAAC7C,OAASA,KAAK8C,QAAQ,CAAC,eAAe9F,UAAU+F,IAAI,CAAC,CAACC,OAAShD,KAAK8C,QAAQ,CAACE;gBAGlF,KAAK,MAAMlD,SAAS6C,WAAY;oBAC9B,MAAMM,QAAQnD,MAAMmD,KAAK,CAAC;oBAC1B,IAAIA,OAAO;wBACTrF,OAAOgB,MAAM,CAACgB,IAAI,CAAC;4BACjBhD,MAAM;4BACNmD,UAAU;4BACVC,MAAMkD,SAASD,KAAK,CAAC,EAAE;4BACvBhD,QAAQiD,SAASD,KAAK,CAAC,EAAE;4BACzB/C,SAAS+C,KAAK,CAAC,EAAE;4BACjB7C,MAAM,CAAC,EAAE,EAAE6C,KAAK,CAAC,EAAE,EAAE;4BACrBtD,SAAS;wBACX;oBACF;gBACF;YACF;QACF,EAAE,OAAOG,OAAO;QACd,2CAA2C;QAC7C;IACF;IAEA,MAAcoB,gBAAgBlE,SAAmB,EAAEY,MAAoB,EAAiB;QACtF,IAAI;YACF,6BAA6B;YAC7B,MAAM,EAAE+D,MAAM,EAAE,GAAG,MAAMzH,UAAU;YACnC,MAAMiJ,eAAepB,KAAKC,KAAK,CAACL;YAEhC,IAAIwB,aAAaC,KAAK,EAAE;gBACtBxF,OAAOI,OAAO,CAACI,YAAY,GAAG+E,aAAaC,KAAK,CAACC,KAAK,CAACC,GAAG;gBAE1D,IAAI1F,OAAOI,OAAO,CAACI,YAAY,GAAGR,OAAOa,QAAQ,CAACgC,eAAe,EAAE;oBACjE7C,OAAOgB,MAAM,CAACgB,IAAI,CAAC;wBACjBhD,MAAM;wBACNmD,UAAU;wBACVC,MAAM;wBACNC,QAAQ;wBACRC,SAAS,CAAC,eAAe,EAAEtC,OAAOI,OAAO,CAACI,YAAY,CAAC,oBAAoB,EAAER,OAAOa,QAAQ,CAACgC,eAAe,CAAC,EAAE,CAAC;wBAChHL,MAAM;wBACNT,SAAS;wBACT+C,YAAY;oBACd;gBACF;YACF;QACF,EAAE,OAAO5C,OAAO;YACdlC,OAAOgB,MAAM,CAACgB,IAAI,CAAC;gBACjBhD,MAAM;gBACNmD,UAAU;gBACVC,MAAM;gBACNC,QAAQ;gBACRC,SAAS;gBACTE,MAAM;gBACNT,SAAS;YACX;QACF;IACF;IAEA,MAAcwB,oBAAoBnE,SAAmB,EAAEY,MAAoB,EAAiB;QAC1F,IAAI,CAAC,IAAI,CAACrD,MAAM,CAACc,KAAK,CAACM,QAAQ,CAACC,iBAAiB,EAAE;QAEnD,IAAI;YACF,MAAM,EAAE+F,MAAM,EAAE,GAAG,MAAMzH,UAAU;YACnC,MAAMqJ,YAAYxB,KAAKC,KAAK,CAACL;YAE7B,IAAI4B,UAAUC,eAAe,EAAE;gBAC7B,KAAK,MAAM,CAACC,MAAMC,KAAK,IAAIC,OAAOC,OAAO,CAACL,UAAUC,eAAe,EAAG;oBACpE,MAAMK,WAAWH;oBACjB9F,OAAOgB,MAAM,CAACgB,IAAI,CAAC;wBACjBhD,MAAM;wBACNmD,UAAU,IAAI,CAAC+D,gBAAgB,CAACD,SAAS9D,QAAQ;wBACjDC,MAAM;wBACNC,QAAQ;wBACRC,SAAS,CAAC,0BAA0B,EAAEuD,KAAK,EAAE,EAAEI,SAASE,KAAK,EAAE;wBAC/D3D,MAAM;wBACNT,SAASkE,SAASG,YAAY,KAAK;oBACrC;gBACF;YACF;YAEA,oDAAoD;YACpD,MAAMC,gBAAgBN,OAAOO,MAAM,CAACX,UAAUC,eAAe,IAAI,CAAC,GAAGX,MAAM,CACzE,CAACsB,IAAWA,EAAEpE,QAAQ,KAAK,YAC3BqE,MAAM;YACR,MAAMC,YAAYV,OAAOO,MAAM,CAACX,UAAUC,eAAe,IAAI,CAAC,GAAGX,MAAM,CACrE,CAACsB,IAAWA,EAAEpE,QAAQ,KAAK,QAC3BqE,MAAM;YAERxG,OAAOI,OAAO,CAACK,aAAa,GAAGf,KAAKgH,GAAG,CAAC,GAAG,MAAOL,CAAAA,gBAAgB,KAAKI,YAAY,EAAC;QACtF,EAAE,OAAOvE,OAAO;YACdlC,OAAOI,OAAO,CAACK,aAAa,GAAG,IAAI,0BAA0B;QAC/D;IACF;IAEA,MAAc+C,uBAAuBpE,SAAmB,EAAEY,MAAoB,EAAiB;QAC7F,kCAAkC;QAClC,IAAI;YACF,IAAI2G,YAAY;YAChB,KAAK,MAAMxG,YAAYf,UAAW;gBAChC,MAAMwH,QAAQ,MAAMzK,GAAG0K,IAAI,CAAC1G;gBAC5BwG,aAAaC,MAAME,IAAI;gBACvB9G,OAAOI,OAAO,CAACO,WAAW,IAAI,AAAC,CAAA,MAAMxE,GAAG4K,QAAQ,CAAC5G,UAAU,QAAO,EAAG6E,KAAK,CAAC,MAAMwB,MAAM;YACzF;YAEA,6DAA6D;YAC7DxG,OAAOI,OAAO,CAACM,gBAAgB,GAAGhB,KAAKgH,GAAG,CAAC,GAAG,MAAMhH,KAAKsH,KAAK,CAACL,YAAY,SAAS;YAEpF,IAAIA,YAAY,QAAQ;gBACtB,kBAAkB;gBAClB3G,OAAOgB,MAAM,CAACgB,IAAI,CAAC;oBACjBhD,MAAM;oBACNmD,UAAU;oBACVC,MAAM;oBACNC,QAAQ;oBACRC,SAAS,CAAC,iBAAiB,EAAE5C,KAAKuH,KAAK,CAACN,YAAY,MAAM,0BAA0B,CAAC;oBACrFnE,MAAM;oBACNT,SAAS;oBACT+C,YAAY;gBACd;YACF;QACF,EAAE,OAAO5C,OAAO;YACdlC,OAAOI,OAAO,CAACM,gBAAgB,GAAG,IAAI,gBAAgB;QACxD;IACF;IAEA,MAAc+C,sBAAsBrE,SAAmB,EAAEY,MAAoB,EAAiB;QAC5F,iCAAiC;QACjC,IAAIkH,kBAAkB;QACtB,IAAIC,YAAY;QAEhB,KAAK,MAAMhH,YAAYf,UAAW;YAChC,IAAI;gBACF,MAAMgI,UAAU,MAAMjL,GAAG4K,QAAQ,CAAC5G,UAAU;gBAC5C,MAAME,aAAa,IAAI,CAACgH,6BAA6B,CAACD;gBACtDF,mBAAmB7G;gBACnB8G;gBAEA,IAAI9G,aAAa,IAAI;oBACnBL,OAAOgB,MAAM,CAACgB,IAAI,CAAC;wBACjBhD,MAAM;wBACNmD,UAAU;wBACVC,MAAM;wBACNC,QAAQ;wBACRC,SAAS,CAAC,4BAA4B,EAAEjC,WAAW,CAAC,CAAC;wBACrDmC,MAAM;wBACNT,SAAS;wBACT+C,YAAY;oBACd;gBACF;YACF,EAAE,OAAO5C,OAAO;YACd,gCAAgC;YAClC;QACF;QAEAlC,OAAOI,OAAO,CAACC,UAAU,GAAG8G,YAAY,IAAID,kBAAkBC,YAAY;QAC1EnH,OAAOI,OAAO,CAACE,eAAe,GAAGZ,KAAKgH,GAAG,CAAC,GAAG,MAAM1G,OAAOI,OAAO,CAACC,UAAU,GAAG;IACjF;IAEQgH,8BAA8BC,IAAY,EAAU;QAC1D,+CAA+C;QAC/C,MAAMC,qBAAqB;YACzB;YACA;YACA;YACA;YACA;YACA;YACA;YACA;YACA;YACA;SACD;QAED,IAAIlH,aAAa,GAAG,kBAAkB;QAEtC,KAAK,MAAMmH,WAAWD,mBAAoB;YACxC,MAAME,UAAUH,KAAKjC,KAAK,CAACmC;YAC3BnH,cAAcoH,UAAUA,QAAQjB,MAAM,GAAG;QAC3C;QAEA,OAAOnG;IACT;IAEA,MAAcqD,qBAAqBtE,SAAmB,EAAEY,MAAoB,EAAiB;QAC3F,kCAAkC;QAClCA,OAAOiB,WAAW,CAACe,IAAI,CAAC;YACtBhD,MAAM;YACN0I,aAAa;YACbC,QAAQ;YACRC,QAAQ;YACRC,UAAU;QACZ;IACF;IAEA,MAAclE,oBAAoBvE,SAAmB,EAAEY,MAAoB,EAAiB;QAC1F,uCAAuC;QACvC,MAAM8H,aAAa1I,UAAU+F,IAAI,CAAC,OAAOhF;YACvC,MAAMiH,UAAU,MAAMjL,GAAG4K,QAAQ,CAAC5G,UAAU;YAC5C,OAAOiH,QAAQlC,QAAQ,CAAC,kBAAkBkC,QAAQlC,QAAQ,CAAC;QAC7D;QAEA,IAAI,CAAC4C,YAAY;YACf9H,OAAOiB,WAAW,CAACe,IAAI,CAAC;gBACtBhD,MAAM;gBACN0I,aAAa;gBACbC,QAAQ;gBACRC,QAAQ;gBACRC,UAAU;YACZ;QACF;IACF;IAEA,MAAcjE,gBAAgBxE,SAAmB,EAAEY,MAAoB,EAAiB;QACtF,gCAAgC;QAChCA,OAAOiB,WAAW,CAACe,IAAI,CAAC;YACtBhD,MAAM;YACN0I,aAAa;YACbC,QAAQ;YACRC,QAAQ;YACRC,UAAU;QACZ;IACF;IAEQjG,sBAAsB5B,MAAoB,EAAW;QAC3D,MAAM+H,iBAAiB/H,OAAOgB,MAAM,CAACiE,MAAM,CAAC,CAACnD,QAAUA,MAAMK,QAAQ,KAAK,YAAYqE,MAAM;QAC5F,MAAMwB,cAAchI,OAAOgB,MAAM,CAACiE,MAAM,CAAC,CAACnD,QAAUA,MAAMK,QAAQ,KAAK,SAASqE,MAAM;QAEtF,oCAAoC;QACpC,IAAIuB,iBAAiB,GAAG,OAAO;QAE/B,gCAAgC;QAChC,IAAIC,cAAc,GAAG,OAAO;QAE5B,iCAAiC;QACjC,MAAM5H,UAAUJ,OAAOI,OAAO;QAC9B,MAAMS,WAAWb,OAAOa,QAAQ;QAEhC,IAAIT,QAAQI,YAAY,GAAGK,SAASgC,eAAe,EAAE,OAAO;QAC5D,IAAIzC,QAAQK,aAAa,GAAGI,SAASiC,gBAAgB,EAAE,OAAO;QAC9D,IAAI1C,QAAQE,eAAe,GAAGO,SAAS8B,kBAAkB,EAAE,OAAO;QAClE,IAAIvC,QAAQG,YAAY,GAAGM,SAAS+B,eAAe,EAAE,OAAO;QAE5D,OAAO;IACT;IAEQ2B,kBAAkBC,MAAqB,EAAuB;QACpE,IAAI,CAACA,QAAQ,OAAO;QAEpB,IAAIA,OAAOU,QAAQ,CAAC,aAAa,OAAO;QACxC,IAAIV,OAAOU,QAAQ,CAAC,gBAAgB,OAAO;QAC3C,IAAIV,OAAOU,QAAQ,CAAC,eAAe,OAAO;QAC1C,IAAIV,OAAOU,QAAQ,CAAC,SAAS,OAAO;QAEpC,OAAO;IACT;IAEQT,kBAAkBtC,QAAgB,EAA2B;QACnE,OAAQA;YACN,KAAK;gBACH,OAAO;YACT,KAAK;gBACH,OAAO;YACT;gBACE,OAAO;QACX;IACF;IAEQ+D,iBAAiB/D,QAAgB,EAA2B;QAClE,OAAQA,SAAS8F,WAAW;YAC1B,KAAK;gBACH,OAAO;YACT,KAAK;gBACH,OAAO;YACT,KAAK;gBACH,OAAO;YACT;gBACE,OAAO;QACX;IACF;IAEOC,UAAU3I,QAAgB,EAA4B;QAC3D,OACE,IAAI,CAAC/C,aAAa,CAAC2L,IAAI,CAAC,CAACnI,SAAWA,OAAOC,EAAE,KAAKV,aAClD,IAAI,CAAC9C,aAAa,CAAC2L,GAAG,CAAC7I;IAE3B;IAEO8I,mBAAmC;QACxC,OAAOC,MAAMC,IAAI,CAAC,IAAI,CAAC9L,aAAa,CAAC6J,MAAM;IAC7C;IAEOkC,mBAAmC;QACxC,OAAO;eAAI,IAAI,CAAChM,aAAa;SAAC;IAChC;IAEA,MAAaiM,QAAQlJ,QAAgB,EAAoB;QACvD,MAAMS,SAAS,IAAI,CAACkI,SAAS,CAAC3I;QAC9B,IAAI,CAACS,UAAU,CAACA,OAAOkB,WAAW,EAAE,OAAO;QAE3C,MAAMwH,gBAAgB1I,OAAOgB,MAAM,CAACiE,MAAM,CAAC,CAACnD,QAAUA,MAAMC,OAAO;QAEnE,KAAK,MAAMD,SAAS4G,cAAe;YACjC,IAAI;gBACF,MAAM,IAAI,CAACC,YAAY,CAAC7G,OAAO9B,OAAOG,QAAQ;YAChD,EAAE,OAAO+B,OAAO;gBACd2B,QAAQ3B,KAAK,CAAC,CAAC,yBAAyB,EAAEJ,MAAMU,IAAI,CAAC,CAAC,CAAC,EAAEN;YAC3D;QACF;QAEA,IAAI,CAACb,IAAI,CAAC,qBAAqB;YAAE9B;YAAUqJ,aAAaF;QAAc;QACtE,OAAO;IACT;IAEA,MAAcC,aAAa7G,KAAkB,EAAE3B,QAAgB,EAAiB;QAC9E,OAAQ2B,MAAMU,IAAI;YAChB,KAAK;gBACH,MAAMlG,UAAU,CAAC,qBAAqB,EAAE6D,UAAU;gBAClD;YACF,KAAK;gBACH,MAAM7D,UAAU,CAAC,iBAAiB,EAAE6D,UAAU;gBAC9C;YACF;gBAEE;QACJ;IACF;AACF"}