codehere 0.1.1

package/dist/infrastructure/xai/uncertainty-quantifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uncertainty-quantifier.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/xai/uncertainty-quantifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,CAAC;AAErE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IAClD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,gBAAgB,CAAC;IAC5B,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED;;;GAGG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,kBAAkB,CAAe;IAEzC;;;OAGG;IACG,mBAAmB,CACvB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAA;KAAE,GAC7C,OAAO,CAAC,iBAAiB,CAAC;IAqB7B;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAmDpC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAuBpC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAc1B;;OAEG;IACH,OAAO,CAAC,YAAY;IAWpB;;OAEG;IACH,OAAO,CAAC,YAAY;IAapB;;OAEG;IACH,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;CAG/C"}

package/dist/infrastructure/xai/uncertainty-quantifier.js

@@ -0,0 +1,198 @@
+/**
+ * INTERNAL ONLY — infrastructure helper, not a user-facing feature.
+ *
+ * Uncertainty Quantifier - Distinguishes Epistemic vs Aleatoric uncertainty.
+ * Used internally for logging/debugging. Not guaranteed to be stable.
+ *
+ * Do not rely on this directly.
+ *
+ * @internal
+ */
+/**
+ * Uncertainty Quantifier
+ * Quantifies and communicates model uncertainty
+ */
+export class UncertaintyQuantifier {
+    epistemicThreshold = 0.7; // High epistemic = hallucination risk
+    /**
+     * Quantify uncertainty from LLM response
+     * Uses multiple sampling approach (dropout method)
+     */
+    async quantifyUncertainty(query, response, context) {
+        // For now, use heuristics based on response characteristics
+        // In production, would use multiple sampling (dropout method)
+        // 1. Epistemic Uncertainty (model knowledge gap)
+        const epistemic = this.estimateEpistemicUncertainty(query, response, context);
+        // 2. Aleatoric Uncertainty (inherent randomness)
+        const aleatoric = this.estimateAleatoricUncertainty(response);
+        // 3. Combined Uncertainty
+        const combined = this.combineUncertainties(epistemic, aleatoric);
+        return {
+            epistemic,
+            aleatoric,
+            combined,
+            isHallucinationRisk: epistemic.value > this.epistemicThreshold,
+        };
+    }
+    /**
+     * Estimate epistemic uncertainty (model knowledge gap)
+     * High epistemic = query outside training distribution
+     */
+    estimateEpistemicUncertainty(query, response, context) {
+        let epistemicValue = 0;
+        const factors = [];
+        // Factor 1: Query complexity (unknown patterns)
+        if (this.hasUnknownPatterns(query)) {
+            epistemicValue += 0.3;
+            factors.push('Query contains unknown patterns');
+        }
+        // Factor 2: Context availability (low context = high uncertainty)
+        const contextScore = this.calculateContextScore(context);
+        if (contextScore < 0.3) {
+            epistemicValue += 0.3;
+            factors.push('Low context availability');
+        }
+        // Factor 3: Response confidence markers (hedging language)
+        if (this.hasHedgingLanguage(response)) {
+            epistemicValue += 0.2;
+            factors.push('Response contains hedging language');
+        }
+        // Factor 4: Niche/proprietary API usage (outside training)
+        if (this.hasNicheAPIs(response)) {
+            epistemicValue += 0.4;
+            factors.push('Niche or proprietary API usage detected');
+        }
+        epistemicValue = Math.min(epistemicValue, 1.0);
+        const riskLevel = this.getRiskLevel(epistemicValue);
+        const recommendation = epistemicValue > this.epistemicThreshold
+            ? 'High epistemic uncertainty detected. This may indicate hallucination risk. Verify output carefully, especially for niche APIs or proprietary patterns.'
+            : undefined;
+        return {
+            type: 'epistemic',
+            value: epistemicValue,
+            explanation: factors.length > 0
+                ? `Epistemic uncertainty factors: ${factors.join('; ')}`
+                : 'Low epistemic uncertainty - query appears within model knowledge',
+            riskLevel,
+            recommendation,
+        };
+    }
+    /**
+     * Estimate aleatoric uncertainty (inherent randomness)
+     */
+    estimateAleatoricUncertainty(response) {
+        // Aleatoric uncertainty is harder to estimate from single response
+        // Would require multiple samples in production
+        // For now, estimate based on response variability markers
+        let aleatoricValue = 0;
+        // Multiple valid solutions increase aleatoric uncertainty
+        if (response.includes('alternative') || response.includes('could also')) {
+            aleatoricValue += 0.2;
+        }
+        // Default to low aleatoric (assuming deterministic generation)
+        aleatoricValue = Math.min(aleatoricValue, 0.3);
+        return {
+            type: 'aleatoric',
+            value: aleatoricValue,
+            explanation: 'Inherent randomness in generation process',
+            riskLevel: aleatoricValue < 0.2 ? 'low' : 'medium',
+        };
+    }
+    /**
+     * Combine uncertainties
+     */
+    combineUncertainties(epistemic, aleatoric) {
+        const aleatoricValue = aleatoric?.value || 0;
+        const combinedValue = Math.max(epistemic.value, aleatoricValue);
+        return {
+            type: 'combined',
+            value: combinedValue,
+            explanation: `Combined uncertainty: ${epistemic.value.toFixed(2)} epistemic, ${aleatoricValue.toFixed(2)} aleatoric`,
+            riskLevel: this.getRiskLevel(combinedValue),
+            recommendation: epistemic.recommendation,
+        };
+    }
+    /**
+     * Check for unknown patterns (outside training distribution)
+     */
+    hasUnknownPatterns(query) {
+        // Heuristic: Very specific, niche terminology
+        const nichePatterns = [
+            /internal.*?api/i,
+            /proprietary/i,
+            /custom.*?framework/i,
+            /company.*?specific/i,
+        ];
+        return nichePatterns.some(pattern => pattern.test(query));
+    }
+    /**
+     * Calculate context availability score
+     */
+    calculateContextScore(context) {
+        if (!context) {
+            return 0;
+        }
+        const chunkCount = context.chunks?.length || 0;
+        const memoryCount = context.memories?.length || 0;
+        // More context = lower epistemic uncertainty
+        if (chunkCount > 5 && memoryCount > 2) {
+            return 0.8;
+        }
+        if (chunkCount > 3 || memoryCount > 1) {
+            return 0.5;
+        }
+        if (chunkCount > 0 || memoryCount > 0) {
+            return 0.3;
+        }
+        return 0;
+    }
+    /**
+     * Check for hedging language (indicates uncertainty)
+     */
+    hasHedgingLanguage(response) {
+        const hedging = [
+            /might/i,
+            /could/i,
+            /possibly/i,
+            /may/i,
+            /perhaps/i,
+            /probably/i,
+            /likely/i,
+        ];
+        return hedging.some(pattern => pattern.test(response));
+    }
+    /**
+     * Check for niche/proprietary APIs
+     */
+    hasNicheAPIs(response) {
+        const nichePatterns = [
+            /internal.*?sdk/i,
+            /company.*?api/i,
+            /custom.*?service/i,
+            /proprietary.*?library/i,
+        ];
+        return nichePatterns.some(pattern => pattern.test(response));
+    }
+    /**
+     * Get risk level from uncertainty value
+     */
+    getRiskLevel(value) {
+        if (value >= 0.8) {
+            return 'critical';
+        }
+        if (value >= 0.6) {
+            return 'high';
+        }
+        if (value >= 0.4) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    /**
+     * Set epistemic threshold
+     */
+    setEpistemicThreshold(threshold) {
+        this.epistemicThreshold = threshold;
+    }
+}
+//# sourceMappingURL=uncertainty-quantifier.js.map

package/dist/infrastructure/xai/uncertainty-quantifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uncertainty-quantifier.js","sourceRoot":"","sources":["../../../src/infrastructure/xai/uncertainty-quantifier.ts"],"names":[],"mappings":"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"}

package/dist/intelligent-retrieval 2.js

@@ -0,0 +1,272 @@
+/**
+ * Intelligent Context Retrieval System
+ * 10X effectiveness through smart context selection
+ */
+import { parseFile, findCallers, findCallees, buildCallGraph } from './ast-parser.js';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+/**
+ * Classify query intent
+ */
+export function classifyQueryIntent(query) {
+    const lowerQuery = query.toLowerCase();
+    // Refactor intent
+    if (lowerQuery.includes('refactor') || lowerQuery.includes('rename') ||
+        lowerQuery.includes('extract') || lowerQuery.includes('move') ||
+        lowerQuery.includes('restructure')) {
+        return 'refactor';
+    }
+    // Debug intent
+    if (lowerQuery.includes('bug') || lowerQuery.includes('error') ||
+        lowerQuery.includes('fix') || lowerQuery.includes('issue') ||
+        lowerQuery.includes('problem') || lowerQuery.includes('wrong')) {
+        return 'debug';
+    }
+    // Implement intent
+    if (lowerQuery.includes('implement') || lowerQuery.includes('create') ||
+        lowerQuery.includes('add') || lowerQuery.includes('write') ||
+        lowerQuery.includes('build')) {
+        return 'implement';
+    }
+    // Find intent
+    if (lowerQuery.includes('find') || lowerQuery.includes('where') ||
+        lowerQuery.includes('locate') || lowerQuery.includes('search')) {
+        return 'find';
+    }
+    // Modify intent
+    if (lowerQuery.includes('modify') || lowerQuery.includes('change') ||
+        lowerQuery.includes('update') || lowerQuery.includes('edit')) {
+        return 'modify';
+    }
+    // Understand/Explain intent (default)
+    if (lowerQuery.includes('how') || lowerQuery.includes('what') ||
+        lowerQuery.includes('explain') || lowerQuery.includes('understand') ||
+        lowerQuery.includes('does') || lowerQuery.includes('work')) {
+        return 'explain';
+    }
+    return 'understand';
+}
+/**
+ * Extract function/class names from query
+ */
+export function extractSymbolNames(query) {
+    // Look for function/class names (capitalized words, camelCase, etc.)
+    const patterns = [
+        /function\s+(\w+)/gi,
+        /class\s+(\w+)/gi,
+        /interface\s+(\w+)/gi,
+        /type\s+(\w+)/gi,
+        /const\s+(\w+)/gi,
+        /let\s+(\w+)/gi,
+        /var\s+(\w+)/gi,
+        /([A-Z][a-zA-Z0-9]+)/g, // Capitalized words (likely class names)
+        /([a-z][a-zA-Z0-9]*\(\))/g, // camelCase followed by () (likely function calls)
+    ];
+    const symbols = new Set();
+    for (const pattern of patterns) {
+        const matches = query.matchAll(pattern);
+        for (const match of matches) {
+            if (match[1]) {
+                symbols.add(match[1]);
+            }
+        }
+    }
+    return Array.from(symbols);
+}
+/**
+ * Get intelligent context based on query intent and code structure
+ */
+export async function getIntelligentContext(query, options = {}) {
+    const { maxTokens = 2000, baseDir = process.cwd() } = options;
+    // Classify query intent
+    const intent = classifyQueryIntent(query);
+    // Extract symbol names from query
+    const symbolNames = extractSymbolNames(query);
+    // Get initial search results (more than needed, we'll filter)
+    // Use searchSimilar directly - it's imported at top level now
+    const { searchSimilar } = await import('./search.js');
+    const initialResults = await searchSimilar(query, 30);
+    if (initialResults.length === 0) {
+        return {
+            primaryChunks: [],
+            relatedChunks: [],
+            codeStructure: { symbols: [], relationships: [] },
+            relevance: new Map(),
+            tokenEstimate: 0,
+        };
+    }
+    // Get unique filepaths
+    const filepaths = [...new Set(initialResults.map(r => r.filepath))];
+    // Parse files to get code structure
+    const analyses = [];
+    const filepathToAnalysis = new Map();
+    for (const filepath of filepaths.slice(0, 10)) { // Limit to 10 files for performance
+        const fullPath = join(baseDir, filepath);
+        if (existsSync(fullPath)) {
+            const analysis = parseFile(fullPath);
+            if (analysis) {
+                analyses.push(analysis);
+                filepathToAnalysis.set(filepath, analysis);
+            }
+        }
+    }
+    // Build call graph
+    const callGraph = buildCallGraph(analyses);
+    // Find relevant symbols
+    const relevantSymbols = new Set();
+    for (const symbolName of symbolNames) {
+        relevantSymbols.add(symbolName);
+        // Add callers and callees
+        const callers = findCallers(symbolName, callGraph);
+        const callees = findCallees(symbolName, callGraph);
+        callers.forEach(c => relevantSymbols.add(c));
+        callees.forEach(c => relevantSymbols.add(c));
+    }
+    // Calculate relevance scores
+    const relevance = new Map();
+    for (const result of initialResults) {
+        let score = result.score; // Base similarity score
+        // Boost if file contains relevant symbols
+        const analysis = filepathToAnalysis.get(result.filepath);
+        if (analysis) {
+            const hasRelevantSymbol = analysis.symbols.some(s => relevantSymbols.has(s.name) ||
+                symbolNames.some(sn => s.name.includes(sn) || sn.includes(s.name)));
+            if (hasRelevantSymbol) {
+                score *= 1.5; // Boost relevance
+            }
+            // Boost if chunk contains symbol names
+            const chunkHasSymbol = symbolNames.some(sn => result.content.toLowerCase().includes(sn.toLowerCase()));
+            if (chunkHasSymbol) {
+                score *= 1.3;
+            }
+        }
+        // Intent-based scoring
+        if (intent === 'refactor' || intent === 'modify') {
+            // Prefer chunks with function/class definitions
+            if (result.content.match(/(function|class|interface|type)\s+\w+/)) {
+                score *= 1.2;
+            }
+        }
+        if (intent === 'debug') {
+            // Prefer chunks with error handling, try-catch, etc.
+            if (result.content.match(/(try|catch|error|throw|if.*error)/i)) {
+                score *= 1.2;
+            }
+        }
+        relevance.set(result.filepath, score);
+    }
+    // Sort by relevance with source file priority
+    const sortedResults = initialResults.sort((a, b) => {
+        const scoreA = relevance.get(a.filepath) || a.score;
+        const scoreB = relevance.get(b.filepath) || b.score;
+        // Boost source files over documentation
+        const isSourceA = /\.(ts|tsx|js|jsx)$/.test(a.filepath) && !/\.(md|txt)$/.test(a.filepath);
+        const isSourceB = /\.(ts|tsx|js|jsx)$/.test(b.filepath) && !/\.(md|txt)$/.test(b.filepath);
+        if (isSourceA && !isSourceB)
+            return -1; // A is source, B is not
+        if (!isSourceA && isSourceB)
+            return 1; // B is source, A is not
+        return scoreB - scoreA;
+    });
+    // Filter and optimize chunks based on intent
+    const optimizedChunks = await optimizeChunks(sortedResults, intent, symbolNames, analyses, maxTokens);
+    // Split into primary and related
+    const primaryChunks = optimizedChunks.slice(0, Math.min(10, optimizedChunks.length));
+    const relatedChunks = optimizedChunks.slice(primaryChunks.length);
+    // Extract code structure info
+    const allSymbols = analyses.flatMap(a => a.symbols.map(s => ({
+        name: s.name,
+        filepath: a.filepath,
+        line: s.line,
+        kind: s.kind,
+    })));
+    const allRelationships = analyses.flatMap(a => a.relationships.map(r => ({
+        from: r.from,
+        to: r.to,
+        type: r.type,
+    })));
+    // Estimate tokens (rough: 1 token ≈ 4 characters)
+    const tokenEstimate = optimizedChunks.reduce((sum, chunk) => sum + Math.ceil(chunk.content.length / 4), 0);
+    return {
+        primaryChunks,
+        relatedChunks,
+        codeStructure: {
+            symbols: allSymbols,
+            relationships: allRelationships,
+        },
+        relevance,
+        tokenEstimate,
+    };
+}
+/**
+ * Optimize chunks based on intent and token limit
+ */
+async function optimizeChunks(results, intent, symbolNames, analyses, maxTokens) {
+    const optimized = [];
+    let currentTokens = 0;
+    // Create filepath to analysis map
+    const filepathToAnalysis = new Map();
+    for (const analysis of analyses) {
+        filepathToAnalysis.set(analysis.filepath, analysis);
+    }
+    for (const result of results) {
+        if (currentTokens >= maxTokens)
+            break;
+        const analysis = filepathToAnalysis.get(result.filepath);
+        // For function/class queries, extract just the relevant function/class
+        if (symbolNames.length > 0 && analysis) {
+            const relevantSymbol = analysis.symbols.find(s => symbolNames.some(sn => s.name === sn || s.name.includes(sn)));
+            if (relevantSymbol) {
+                // Extract just the function/class, not the entire chunk
+                const optimizedChunk = extractSymbolCode(result.filepath, relevantSymbol.line, relevantSymbol.kind);
+                if (optimizedChunk) {
+                    const chunkTokens = Math.ceil(optimizedChunk.length / 4);
+                    if (currentTokens + chunkTokens <= maxTokens) {
+                        optimized.push({
+                            ...result,
+                            content: optimizedChunk,
+                        });
+                        currentTokens += chunkTokens;
+                        continue;
+                    }
+                }
+            }
+        }
+        // Otherwise, use the chunk but truncate if needed
+        const chunkTokens = Math.ceil(result.content.length / 4);
+        const remainingTokens = maxTokens - currentTokens;
+        if (chunkTokens <= remainingTokens) {
+            optimized.push(result);
+            currentTokens += chunkTokens;
+        }
+        else if (remainingTokens > 100) {
+            // Truncate chunk to fit
+            const truncatedContent = result.content.substring(0, remainingTokens * 4);
+            optimized.push({
+                ...result,
+                content: truncatedContent + '...',
+            });
+            currentTokens = maxTokens;
+            break;
+        }
+    }
+    return optimized;
+}
+/**
+ * Extract code for a specific symbol (function, class, etc.)
+ */
+function extractSymbolCode(filepath, line, kind) {
+    try {
+        const content = readFileSync(filepath, 'utf-8');
+        const lines = content.split('\n');
+        // For now, return a window around the symbol
+        // TODO: Use AST to extract exact symbol boundaries
+        const start = Math.max(0, line - 5);
+        const end = Math.min(lines.length, line + 50);
+        return lines.slice(start, end).join('\n');
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=intelligent-retrieval.js.map

package/dist/intelligent-retrieval.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Intelligent Context Retrieval System
+ * 10X effectiveness through smart context selection
+ */
+import type { SearchResult } from './types.js';
+export type QueryIntent = 'explain' | 'refactor' | 'debug' | 'implement' | 'understand' | 'find' | 'modify';
+export interface IntelligentContext {
+    primaryChunks: SearchResult[];
+    relatedChunks: SearchResult[];
+    codeStructure: {
+        symbols: Array<{
+            name: string;
+            filepath: string;
+            line: number;
+            kind: string;
+        }>;
+        relationships: Array<{
+            from: string;
+            to: string;
+            type: string;
+        }>;
+    };
+    relevance: Map<string, number>;
+    tokenEstimate: number;
+}
+/**
+ * Classify query intent
+ */
+export declare function classifyQueryIntent(query: string): QueryIntent;
+/**
+ * Extract function/class names from query
+ */
+export declare function extractSymbolNames(query: string): string[];
+/**
+ * Get intelligent context based on query intent and code structure
+ */
+export declare function getIntelligentContext(query: string, options?: {
+    maxTokens?: number;
+    baseDir?: string;
+}): Promise<IntelligentContext>;
+//# sourceMappingURL=intelligent-retrieval.d.ts.map

package/dist/intelligent-retrieval.d.ts 2.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligent-retrieval.d.ts","sourceRoot":"","sources":["../src/intelligent-retrieval.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAK/C,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,GAAG,YAAY,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE5G,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,aAAa,EAAE;QACb,OAAO,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAC/E,aAAa,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAClE,CAAC;IACF,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CA4C9D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA0B1D;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CACb,GACL,OAAO,CAAC,kBAAkB,CAAC,CAsK7B"}

package/dist/intelligent-retrieval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligent-retrieval.d.ts","sourceRoot":"","sources":["../src/intelligent-retrieval.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAK/C,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,GAAG,YAAY,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE5G,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,aAAa,EAAE;QACb,OAAO,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAC/E,aAAa,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAClE,CAAC;IACF,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CA4C9D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA0B1D;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CACb,GACL,OAAO,CAAC,kBAAkB,CAAC,CAsK7B"}