@quantyapp/quanty-mcp-server 1.0.11 → 1.2.0

package/dist/core/learningService.d.ts

@@ -0,0 +1,94 @@
+import { AuthContext } from './auth.js';
+export interface LearningEntry {
+    id?: string;
+    task_signature: string;
+    task_description: string;
+    solution_steps: any[];
+    context_used?: any;
+    success_metrics: {
+        execution_time?: number;
+        items_processed?: number;
+        accuracy?: number;
+    };
+    confidence_score: number;
+    usage_count: number;
+    last_used: string;
+    created_at: string;
+    tenant_id: string;
+}
+export interface OperationPattern {
+    id?: string;
+    pattern_name: string;
+    trigger_keywords: string[];
+    preconditions: any;
+    action_sequence: any[];
+    success_criteria: any;
+    variations: any[];
+    optimization_hints: string[];
+    version: number;
+    tenant_id: string;
+}
+export interface KnowledgeContext {
+    similar_tasks: LearningEntry[];
+    relevant_patterns: OperationPattern[];
+    best_practices: string[];
+    warnings: string[];
+}
+export declare class QuantyLearningSystem {
+    private auth;
+    constructor(auth: AuthContext);
+    /**
+     * Creates a unique signature for a task based on its characteristics
+     */
+    private createTaskSignature;
+    private hashString;
+    /**
+     * Load knowledge base from Supabase
+     */
+    loadKnowledgeBase(): Promise<void>;
+    /**
+     * Find similar tasks from history
+     */
+    findSimilarTasks(task: string, limit?: number): Promise<LearningEntry[]>;
+    /**
+     * Get relevant knowledge for a task
+     */
+    getRelevantKnowledge(task: string): Promise<KnowledgeContext>;
+    /**
+     * Learn from a successful execution
+     */
+    learnFromExecution(task: string, steps: any[], result: any, executionTime: number): Promise<void>;
+    /**
+     * Extract patterns from successful executions
+     */
+    private extractAndUpdatePatterns;
+    private extractKeywords;
+    /**
+     * Process user feedback on executions
+     */
+    processFeedback(taskSignature: string, feedbackType: 'success' | 'failure' | 'improvement', details?: string): Promise<void>;
+    /**
+     * Get learning statistics
+     */
+    getStatistics(): Promise<any>;
+    /**
+     * Clean up old or low-confidence entries
+     */
+    pruneKnowledge(): Promise<void>;
+}
+export declare class ContextBuilder {
+    private learning;
+    constructor(learning: QuantyLearningSystem);
+    /**
+     * Build enriched context for a task
+     */
+    buildContext(task: string): Promise<string>;
+    /**
+     * Generate system prompt with accumulated knowledge
+     */
+    generateSystemPrompt(basePrompt: string): Promise<string>;
+}
+export declare function initLearningSystem(auth: AuthContext): void;
+export declare function getLearningSystem(): QuantyLearningSystem;
+export declare function getContextBuilder(): ContextBuilder;
+//# sourceMappingURL=learningService.d.ts.map

package/dist/core/learningService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"learningService.d.ts","sourceRoot":"","sources":["../../src/core/learningService.ts"],"names":[],"mappings":"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"}

package/dist/core/learningService.js

@@ -0,0 +1,462 @@
+import { supabase } from './supabase.js';
+// ================ CACHE MANAGEMENT ================
+class LearningCache {
+    cache = new Map();
+    patterns = new Map();
+    lastSync = new Date();
+    CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+    isStale() {
+        return Date.now() - this.lastSync.getTime() > this.CACHE_TTL;
+    }
+    clear() {
+        this.cache.clear();
+        this.patterns.clear();
+    }
+    addEntry(entry) {
+        if (entry.task_signature) {
+            this.cache.set(entry.task_signature, entry);
+        }
+    }
+    addPattern(pattern) {
+        this.patterns.set(pattern.pattern_name, pattern);
+    }
+    getEntry(signature) {
+        return this.cache.get(signature);
+    }
+    getPattern(name) {
+        return this.patterns.get(name);
+    }
+    getAllEntries() {
+        return Array.from(this.cache.values());
+    }
+    getAllPatterns() {
+        return Array.from(this.patterns.values());
+    }
+    updateSyncTime() {
+        this.lastSync = new Date();
+    }
+}
+const learningCache = new LearningCache();
+// ================ CORE LEARNING SYSTEM ================
+export class QuantyLearningSystem {
+    auth;
+    constructor(auth) {
+        this.auth = auth;
+    }
+    /**
+     * Creates a unique signature for a task based on its characteristics
+     */
+    createTaskSignature(task) {
+        // Extract key components from task
+        const normalized = task.toLowerCase()
+            .replace(/['"]/g, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        // Extract operation type
+        let operationType = 'unknown';
+        if (normalized.includes('criar') || normalized.includes('novo'))
+            operationType = 'create';
+        else if (normalized.includes('adicionar') || normalized.includes('incluir'))
+            operationType = 'add';
+        else if (normalized.includes('buscar') || normalized.includes('pesquisar'))
+            operationType = 'search';
+        else if (normalized.includes('analisar') || normalized.includes('análise'))
+            operationType = 'analyze';
+        else if (normalized.includes('importar'))
+            operationType = 'import';
+        else if (normalized.includes('excluir') || normalized.includes('remover'))
+            operationType = 'delete';
+        // Extract entity type
+        let entityType = 'unknown';
+        if (normalized.includes('orçamento'))
+            entityType = 'budget';
+        else if (normalized.includes('item') || normalized.includes('insumo'))
+            entityType = 'item';
+        else if (normalized.includes('composição'))
+            entityType = 'composition';
+        else if (normalized.includes('banco'))
+            entityType = 'bank';
+        // Create signature
+        return `${operationType}:${entityType}:${this.hashString(normalized)}`;
+    }
+    hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return Math.abs(hash).toString(36);
+    }
+    /**
+     * Load knowledge base from Supabase
+     */
+    async loadKnowledgeBase() {
+        if (!learningCache.isStale())
+            return;
+        try {
+            // Load learning entries
+            const { data: entries, error: entriesError } = await supabase
+                .from('ai_learnings')
+                .select('*')
+                .eq('tenant_id', this.auth.tenantId)
+                .order('confidence_score', { ascending: false })
+                .limit(100);
+            if (!entriesError && entries) {
+                learningCache.clear();
+                entries.forEach((e) => learningCache.addEntry(e));
+            }
+            // Load patterns
+            const { data: patterns, error: patternsError } = await supabase
+                .from('ai_patterns')
+                .select('*')
+                .eq('tenant_id', this.auth.tenantId)
+                .order('version', { ascending: false });
+            if (!patternsError && patterns) {
+                patterns.forEach((p) => learningCache.addPattern(p));
+            }
+            learningCache.updateSyncTime();
+        }
+        catch (error) {
+            console.error('Failed to load knowledge base:', error);
+        }
+    }
+    /**
+     * Find similar tasks from history
+     */
+    async findSimilarTasks(task, limit = 5) {
+        await this.loadKnowledgeBase();
+        const taskLower = task.toLowerCase();
+        const taskWords = new Set(taskLower.split(/\s+/));
+        const scoredEntries = learningCache.getAllEntries().map(entry => {
+            const descWords = new Set(entry.task_description.toLowerCase().split(/\s+/));
+            const intersection = new Set([...taskWords].filter(x => descWords.has(x)));
+            const union = new Set([...taskWords, ...descWords]);
+            // Jaccard similarity
+            const similarity = intersection.size / union.size;
+            // Boost score based on confidence and usage
+            const score = similarity * entry.confidence_score * Math.log(entry.usage_count + 1);
+            return { entry, score };
+        });
+        return scoredEntries
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map(s => s.entry);
+    }
+    /**
+     * Get relevant knowledge for a task
+     */
+    async getRelevantKnowledge(task) {
+        await this.loadKnowledgeBase();
+        const similarTasks = await this.findSimilarTasks(task);
+        const taskLower = task.toLowerCase();
+        // Find relevant patterns
+        const relevantPatterns = learningCache.getAllPatterns().filter(pattern => {
+            return pattern.trigger_keywords.some(keyword => taskLower.includes(keyword.toLowerCase()));
+        });
+        // Extract best practices from successful similar tasks
+        const bestPractices = [];
+        const warnings = [];
+        for (const similar of similarTasks) {
+            if (similar.confidence_score > 0.8) {
+                if (similar.success_metrics.execution_time && similar.success_metrics.execution_time < 1000) {
+                    // Fast execution hints could be added here
+                }
+            }
+        }
+        // Extract optimization hints from patterns
+        for (const pattern of relevantPatterns) {
+            if (pattern.optimization_hints) {
+                bestPractices.push(...pattern.optimization_hints);
+            }
+        }
+        return {
+            similar_tasks: similarTasks,
+            relevant_patterns: relevantPatterns,
+            best_practices: [...new Set(bestPractices)],
+            warnings
+        };
+    }
+    /**
+     * Learn from a successful execution
+     */
+    async learnFromExecution(task, steps, result, executionTime) {
+        const signature = this.createTaskSignature(task);
+        // Check if we already have this task
+        const existing = learningCache.getEntry(signature);
+        if (existing) {
+            // Update existing entry
+            const updatedEntry = {
+                ...existing,
+                usage_count: existing.usage_count + 1,
+                confidence_score: Math.min(1, existing.confidence_score + 0.05),
+                last_used: new Date().toISOString(),
+                success_metrics: {
+                    ...existing.success_metrics,
+                    execution_time: (existing.success_metrics.execution_time + executionTime) / 2
+                }
+            };
+            await supabase
+                .from('ai_learnings')
+                .update(updatedEntry)
+                .eq('id', existing.id);
+            learningCache.addEntry(updatedEntry);
+        }
+        else {
+            // Create new entry
+            const newEntry = {
+                task_signature: signature,
+                task_description: task,
+                solution_steps: steps,
+                success_metrics: {
+                    execution_time: executionTime,
+                    items_processed: result.items_processed || 0,
+                    accuracy: 1.0
+                },
+                confidence_score: 0.7,
+                usage_count: 1,
+                last_used: new Date().toISOString(),
+                created_at: new Date().toISOString(),
+                tenant_id: this.auth.tenantId
+            };
+            const { data, error } = await supabase
+                .from('ai_learnings')
+                .insert(newEntry)
+                .select()
+                .single();
+            if (!error && data) {
+                learningCache.addEntry(data);
+            }
+        }
+        // Extract and update patterns
+        await this.extractAndUpdatePatterns(task, steps, result);
+    }
+    /**
+     * Extract patterns from successful executions
+     */
+    async extractAndUpdatePatterns(task, steps, result) {
+        // Extract keywords from task
+        const keywords = this.extractKeywords(task);
+        // Try to find existing pattern
+        const existingPattern = learningCache.getAllPatterns().find(p => p.trigger_keywords.some(k => keywords.includes(k)));
+        if (existingPattern) {
+            // Add variation to existing pattern
+            const variation = {
+                task,
+                steps,
+                result,
+                timestamp: new Date().toISOString()
+            };
+            const variations = existingPattern.variations || [];
+            const updatedPattern = {
+                ...existingPattern,
+                variations: [...variations, variation].slice(-10), // Keep last 10 variations
+                version: existingPattern.version + 1
+            };
+            await supabase
+                .from('ai_patterns')
+                .update(updatedPattern)
+                .eq('id', existingPattern.id);
+            learningCache.addPattern(updatedPattern);
+        }
+        else if (keywords.length > 0) {
+            // Create new pattern
+            const newPattern = {
+                pattern_name: `pattern_${this.hashString(task)}`,
+                trigger_keywords: keywords,
+                preconditions: {},
+                action_sequence: steps,
+                success_criteria: result,
+                variations: [],
+                optimization_hints: [],
+                version: 1,
+                tenant_id: this.auth.tenantId
+            };
+            const { data, error } = await supabase
+                .from('ai_patterns')
+                .insert(newPattern)
+                .select()
+                .single();
+            if (!error && data) {
+                learningCache.addPattern(data);
+            }
+        }
+    }
+    extractKeywords(text) {
+        const stopWords = new Set(['o', 'a', 'de', 'para', 'com', 'em', 'do', 'da', 'um', 'uma']);
+        const words = text.toLowerCase()
+            .split(/\s+/)
+            .filter(w => w.length > 3 && !stopWords.has(w));
+        // Return unique significant words
+        return [...new Set(words)];
+    }
+    /**
+     * Process user feedback on executions
+     */
+    async processFeedback(taskSignature, feedbackType, details) {
+        const entry = learningCache.getEntry(taskSignature);
+        if (!entry)
+            return;
+        // Adjust confidence based on feedback
+        let confidenceAdjustment = 0;
+        switch (feedbackType) {
+            case 'success':
+                confidenceAdjustment = 0.1;
+                break;
+            case 'failure':
+                confidenceAdjustment = -0.2;
+                break;
+            case 'improvement':
+                confidenceAdjustment = 0.05;
+                break;
+        }
+        const updatedEntry = {
+            ...entry,
+            confidence_score: Math.max(0, Math.min(1, entry.confidence_score + confidenceAdjustment))
+        };
+        await supabase
+            .from('ai_learnings')
+            .update(updatedEntry)
+            .eq('id', entry.id);
+        // Store feedback record
+        await supabase
+            .from('ai_feedback')
+            .insert({
+            learning_id: entry.id,
+            feedback_type: feedbackType,
+            details,
+            created_at: new Date().toISOString(),
+            tenant_id: this.auth.tenantId
+        });
+        learningCache.addEntry(updatedEntry);
+    }
+    /**
+     * Get learning statistics
+     */
+    async getStatistics() {
+        await this.loadKnowledgeBase();
+        const entries = learningCache.getAllEntries();
+        const patterns = learningCache.getAllPatterns();
+        return {
+            total_learnings: entries.length,
+            total_patterns: patterns.length,
+            average_confidence: entries.length > 0 ? entries.reduce((sum, e) => sum + e.confidence_score, 0) / entries.length : 0,
+            most_used_tasks: entries
+                .sort((a, b) => b.usage_count - a.usage_count)
+                .slice(0, 5)
+                .map(e => ({ task: e.task_description, count: e.usage_count })),
+            recent_learnings: entries
+                .sort((a, b) => new Date(b.last_used).getTime() - new Date(a.last_used).getTime())
+                .slice(0, 5)
+                .map(e => ({ task: e.task_description, date: e.last_used }))
+        };
+    }
+    /**
+     * Clean up old or low-confidence entries
+     */
+    async pruneKnowledge() {
+        const thirtyDaysAgo = new Date();
+        thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+        // Remove entries with low confidence that haven't been used recently
+        await supabase
+            .from('ai_learnings')
+            .delete()
+            .eq('tenant_id', this.auth.tenantId)
+            .lt('confidence_score', 0.3)
+            .lt('last_used', thirtyDaysAgo.toISOString());
+        // Refresh cache
+        learningCache.clear();
+        await this.loadKnowledgeBase();
+    }
+}
+// ================ CONTEXT BUILDER ================
+export class ContextBuilder {
+    learning;
+    constructor(learning) {
+        this.learning = learning;
+    }
+    /**
+     * Build enriched context for a task
+     */
+    async buildContext(task) {
+        const knowledge = await this.learning.getRelevantKnowledge(task);
+        let context = '';
+        // Add similar tasks context
+        if (knowledge.similar_tasks.length > 0) {
+            context += 'EXPERIÊNCIAS ANTERIORES SIMILARES:\n';
+            for (const similar of knowledge.similar_tasks.slice(0, 3)) {
+                context += `- ${similar.task_description}\n`;
+                if (similar.solution_steps.length > 0) {
+                    context += `  Passos: ${JSON.stringify(similar.solution_steps.slice(0, 3))}\n`;
+                }
+                context += `  Confiança: ${(similar.confidence_score * 100).toFixed(0)}%\n`;
+            }
+            context += '\n';
+        }
+        // Add patterns
+        if (knowledge.relevant_patterns.length > 0) {
+            context += 'PADRÕES IDENTIFICADOS:\n';
+            for (const pattern of knowledge.relevant_patterns) {
+                context += `- ${pattern.pattern_name}: `;
+                context += `${JSON.stringify(pattern.action_sequence.slice(0, 3))}\n`;
+            }
+            context += '\n';
+        }
+        // Add best practices
+        if (knowledge.best_practices.length > 0) {
+            context += 'MELHORES PRÁTICAS:\n';
+            for (const practice of knowledge.best_practices) {
+                context += `- ${practice}\n`;
+            }
+            context += '\n';
+        }
+        // Add warnings
+        if (knowledge.warnings.length > 0) {
+            context += 'AVISOS:\n';
+            for (const warning of knowledge.warnings) {
+                context += `⚠️ ${warning}\n`;
+            }
+            context += '\n';
+        }
+        return context;
+    }
+    /**
+     * Generate system prompt with accumulated knowledge
+     */
+    async generateSystemPrompt(basePrompt) {
+        const stats = await this.learning.getStatistics();
+        let enhancedPrompt = basePrompt + '\n\n';
+        enhancedPrompt += '=== CONHECIMENTO ACUMULADO DO QUANTY ===\n\n';
+        if (stats.most_used_tasks.length > 0) {
+            enhancedPrompt += 'OPERAÇÕES MAIS COMUNS:\n';
+            for (const task of stats.most_used_tasks) {
+                enhancedPrompt += `- ${task.task}: ${task.count} vezes\n`;
+            }
+            enhancedPrompt += '\n';
+        }
+        enhancedPrompt += `Total de aprendizados: ${stats.total_learnings}\n`;
+        enhancedPrompt += `Padrões identificados: ${stats.total_patterns}\n`;
+        enhancedPrompt += `Confiança média: ${(stats.average_confidence * 100).toFixed(0)}%\n\n`;
+        enhancedPrompt += 'Use este conhecimento acumulado para fornecer respostas mais precisas e eficientes.\n';
+        return enhancedPrompt;
+    }
+}
+// ================ EXPORT SINGLETON ================
+let learningSystemInstance = null;
+let contextBuilderInstance = null;
+export function initLearningSystem(auth) {
+    learningSystemInstance = new QuantyLearningSystem(auth);
+    contextBuilderInstance = new ContextBuilder(learningSystemInstance);
+}
+export function getLearningSystem() {
+    if (!learningSystemInstance) {
+        throw new Error('Learning system not initialized. Call initLearningSystem first.');
+    }
+    return learningSystemInstance;
+}
+export function getContextBuilder() {
+    if (!contextBuilderInstance) {
+        throw new Error('Context builder not initialized. Call initLearningSystem first.');
+    }
+    return contextBuilderInstance;
+}

package/dist/core/matchingService.d.ts

@@ -0,0 +1,76 @@
+import { AuthContext } from './auth.js';
+/**
+ * Calcula similaridade combinada (ensemble)
+ */
+export declare function calculateSimilarity(a: string, b: string): {
+    overall: number;
+    fuzzy: number;
+    keyword: number;
+    tfidf: number;
+    category: {
+        a: string;
+        b: string;
+        match: boolean;
+    };
+};
+export interface MatchResult {
+    id: string;
+    code: string;
+    description: string;
+    unit: string;
+    unitCost: number;
+    source: string;
+    sourceId: string;
+    sourceName: string;
+    similarity: number;
+    similarityDetails: {
+        fuzzy: number;
+        keyword: number;
+        tfidf: number;
+    };
+}
+/**
+ * Busca itens similares em outros orçamentos
+ */
+export declare function findSimilarInBudgets(auth: AuthContext, description: string, excludeBudgetId?: string, limit?: number, minSimilarity?: number): Promise<MatchResult[]>;
+/**
+ * Busca itens similares em bancos de composições
+ */
+export declare function findSimilarInBanks(auth: AuthContext, description: string, bankIds?: string[], limit?: number, minSimilarity?: number): Promise<MatchResult[]>;
+/**
+ * Busca unificada em orçamentos e bancos
+ */
+export declare function findSimilarItems(auth: AuthContext, description: string, options?: {
+    searchBudgets?: boolean;
+    searchBanks?: boolean;
+    excludeBudgetId?: string;
+    bankIds?: string[];
+    limit?: number;
+    minSimilarity?: number;
+}): Promise<{
+    budgetResults: MatchResult[];
+    bankResults: MatchResult[];
+    topMatches: MatchResult[];
+}>;
+/**
+ * Compara preços de itens similares
+ */
+export declare function comparePrices(auth: AuthContext, description: string, currentPrice: number, options?: {
+    excludeBudgetId?: string;
+    limit?: number;
+    minSimilarity?: number;
+}): Promise<{
+    currentPrice: number;
+    matches: Array<MatchResult & {
+        priceDiff: number;
+        priceDiffPercent: number;
+    }>;
+    statistics: {
+        minPrice: number;
+        maxPrice: number;
+        avgPrice: number;
+        medianPrice: number;
+        recommendation: string;
+    };
+}>;
+//# sourceMappingURL=matchingService.d.ts.map

package/dist/core/matchingService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchingService.d.ts","sourceRoot":"","sources":["../../src/core/matchingService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAwPxC;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;CACtD,CAkCA;AAID,MAAM,WAAW,WAAW;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE;QACf,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACtC,IAAI,EAAE,WAAW,EACjB,WAAW,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,MAAM,EACxB,KAAK,GAAE,MAAW,EAClB,aAAa,GAAE,MAAW,GAC3B,OAAO,CAAC,WAAW,EAAE,CAAC,CAgDxB;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACpC,IAAI,EAAE,WAAW,EACjB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,EAAE,EAClB,KAAK,GAAE,MAAW,EAClB,aAAa,GAAE,MAAW,GAC3B,OAAO,CAAC,WAAW,EAAE,CAAC,CAqExB;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAClC,IAAI,EAAE,WAAW,EACjB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE;IACL,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;CACrB,GACP,OAAO,CAAC;IACP,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,WAAW,EAAE,WAAW,EAAE,CAAC;IAC3B,UAAU,EAAE,WAAW,EAAE,CAAC;CAC7B,CAAC,CA0BD;AAED;;GAEG;AACH,wBAAsB,aAAa,CAC/B,IAAI,EAAE,WAAW,EACjB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE;IACL,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;CACrB,GACP,OAAO,CAAC;IACP,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,KAAK,CAAC,WAAW,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC9E,UAAU,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;KAC1B,CAAC;CACL,CAAC,CAqED"}