ruvector 0.1.64 → 0.1.66

package/dist/core/ast-parser.js

@@ -0,0 +1,602 @@
+"use strict";
+/**
+ * AST Parser - Tree-sitter based code parsing
+ *
+ * Provides real AST parsing for accurate code analysis,
+ * replacing regex-based heuristics with proper parsing.
+ *
+ * Supports: TypeScript, JavaScript, Python, Rust, Go, Java, C/C++
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeParser = void 0;
+exports.isTreeSitterAvailable = isTreeSitterAvailable;
+exports.getCodeParser = getCodeParser;
+exports.initCodeParser = initCodeParser;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Try to load tree-sitter
+let Parser = null;
+let languages = new Map();
+let parserError = null;
+async function loadTreeSitter() {
+    if (Parser)
+        return true;
+    if (parserError)
+        return false;
+    try {
+        // Dynamic require to avoid TypeScript errors
+        Parser = require('tree-sitter');
+        return true;
+    }
+    catch (e) {
+        parserError = new Error(`tree-sitter not installed: ${e.message}\n` +
+            `Install with: npm install tree-sitter tree-sitter-typescript tree-sitter-javascript tree-sitter-python`);
+        return false;
+    }
+}
+async function loadLanguage(lang) {
+    if (languages.has(lang))
+        return languages.get(lang);
+    const langPackages = {
+        typescript: 'tree-sitter-typescript',
+        javascript: 'tree-sitter-javascript',
+        python: 'tree-sitter-python',
+        rust: 'tree-sitter-rust',
+        go: 'tree-sitter-go',
+        java: 'tree-sitter-java',
+        c: 'tree-sitter-c',
+        cpp: 'tree-sitter-cpp',
+        ruby: 'tree-sitter-ruby',
+        php: 'tree-sitter-php',
+    };
+    const pkg = langPackages[lang];
+    if (!pkg)
+        return null;
+    try {
+        const langModule = await Promise.resolve(`${pkg}`).then(s => __importStar(require(s)));
+        const language = langModule.default || langModule;
+        // Handle TypeScript which exports tsx and typescript
+        if (lang === 'typescript' && language.typescript) {
+            languages.set(lang, language.typescript);
+            languages.set('tsx', language.tsx);
+            return language.typescript;
+        }
+        languages.set(lang, language);
+        return language;
+    }
+    catch {
+        return null;
+    }
+}
+function isTreeSitterAvailable() {
+    try {
+        require.resolve('tree-sitter');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ============================================================================
+// Parser
+// ============================================================================
+class CodeParser {
+    constructor() {
+        this.parser = null;
+        this.initialized = false;
+    }
+    async init() {
+        if (this.initialized)
+            return true;
+        const loaded = await loadTreeSitter();
+        if (!loaded)
+            return false;
+        this.parser = new Parser();
+        this.initialized = true;
+        return true;
+    }
+    /**
+     * Detect language from file extension
+     */
+    detectLanguage(file) {
+        const ext = path.extname(file).toLowerCase();
+        const langMap = {
+            '.ts': 'typescript',
+            '.tsx': 'tsx',
+            '.js': 'javascript',
+            '.jsx': 'javascript',
+            '.mjs': 'javascript',
+            '.cjs': 'javascript',
+            '.py': 'python',
+            '.rs': 'rust',
+            '.go': 'go',
+            '.java': 'java',
+            '.c': 'c',
+            '.h': 'c',
+            '.cpp': 'cpp',
+            '.cc': 'cpp',
+            '.cxx': 'cpp',
+            '.hpp': 'cpp',
+            '.rb': 'ruby',
+            '.php': 'php',
+        };
+        return langMap[ext] || 'unknown';
+    }
+    /**
+     * Parse a file and return the AST
+     */
+    async parse(file, content) {
+        if (!this.initialized) {
+            await this.init();
+        }
+        if (!this.parser)
+            return null;
+        const lang = this.detectLanguage(file);
+        const language = await loadLanguage(lang);
+        if (!language)
+            return null;
+        this.parser.setLanguage(language);
+        const code = content ?? (fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '');
+        const tree = this.parser.parse(code);
+        return this.convertNode(tree.rootNode);
+    }
+    convertNode(node) {
+        return {
+            type: node.type,
+            text: node.text,
+            startPosition: node.startPosition,
+            endPosition: node.endPosition,
+            children: node.children?.map((c) => this.convertNode(c)) || [],
+        };
+    }
+    /**
+     * Analyze a file for functions, classes, imports, etc.
+     */
+    async analyze(file, content) {
+        const start = performance.now();
+        const lang = this.detectLanguage(file);
+        const code = content ?? (fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '');
+        // Try tree-sitter first, fall back to regex
+        if (this.initialized && this.parser) {
+            const language = await loadLanguage(lang);
+            if (language) {
+                this.parser.setLanguage(language);
+                const tree = this.parser.parse(code);
+                return this.analyzeTree(file, lang, tree.rootNode, code, start);
+            }
+        }
+        // Regex fallback
+        return this.analyzeWithRegex(file, lang, code, start);
+    }
+    analyzeTree(file, lang, root, code, start) {
+        const imports = [];
+        const exports = [];
+        const functions = [];
+        const classes = [];
+        const variables = [];
+        const types = [];
+        const visit = (node) => {
+            // Imports
+            if (node.type === 'import_statement' || node.type === 'import_declaration') {
+                const imp = this.parseImport(node, lang);
+                if (imp)
+                    imports.push(imp);
+            }
+            // Exports
+            if (node.type.includes('export')) {
+                const exp = this.parseExport(node, lang);
+                if (exp)
+                    exports.push(exp);
+            }
+            // Functions
+            if (node.type.includes('function') || node.type === 'method_definition' || node.type === 'arrow_function') {
+                const fn = this.parseFunction(node, code, lang);
+                if (fn)
+                    functions.push(fn);
+            }
+            // Classes
+            if (node.type === 'class_declaration' || node.type === 'class') {
+                const cls = this.parseClass(node, code, lang);
+                if (cls)
+                    classes.push(cls);
+            }
+            // Variables
+            if (node.type === 'variable_declarator' || node.type === 'assignment') {
+                const name = this.getIdentifierName(node);
+                if (name)
+                    variables.push(name);
+            }
+            // Type definitions
+            if (node.type === 'type_alias_declaration' || node.type === 'interface_declaration') {
+                const name = this.getIdentifierName(node);
+                if (name)
+                    types.push(name);
+            }
+            // Recurse
+            for (const child of node.children || []) {
+                visit(child);
+            }
+        };
+        visit(root);
+        const lines = code.split('\n').length;
+        const complexity = this.calculateComplexity(code);
+        return {
+            file,
+            language: lang,
+            imports,
+            exports,
+            functions,
+            classes,
+            variables,
+            types,
+            complexity,
+            lines,
+            parseTime: performance.now() - start,
+        };
+    }
+    parseImport(node, lang) {
+        try {
+            const source = this.findChild(node, 'string')?.text?.replace(/['"]/g, '') || '';
+            const named = [];
+            let defaultImport;
+            let namespace;
+            // Find import specifiers
+            const specifiers = this.findChild(node, 'import_clause') || node;
+            for (const child of specifiers.children || []) {
+                if (child.type === 'identifier') {
+                    defaultImport = child.text;
+                }
+                else if (child.type === 'namespace_import') {
+                    namespace = this.getIdentifierName(child) || undefined;
+                }
+                else if (child.type === 'named_imports') {
+                    for (const spec of child.children || []) {
+                        if (spec.type === 'import_specifier') {
+                            named.push(this.getIdentifierName(spec) || '');
+                        }
+                    }
+                }
+            }
+            return {
+                source,
+                default: defaultImport,
+                named: named.filter(Boolean),
+                namespace,
+                type: 'esm',
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    parseExport(node, lang) {
+        try {
+            if (node.type === 'export_statement') {
+                const declaration = this.findChild(node, 'declaration');
+                if (declaration) {
+                    const name = this.getIdentifierName(declaration);
+                    return { name: name || 'default', type: node.text.includes('default') ? 'default' : 'named' };
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    parseFunction(node, code, lang) {
+        try {
+            const name = this.getIdentifierName(node) || '<anonymous>';
+            const params = [];
+            let returnType;
+            const isAsync = node.text.includes('async');
+            const isExported = node.parent?.type?.includes('export');
+            // Get parameters
+            const paramsNode = this.findChild(node, 'formal_parameters') || this.findChild(node, 'parameters');
+            if (paramsNode) {
+                for (const param of paramsNode.children || []) {
+                    if (param.type === 'identifier' || param.type === 'required_parameter') {
+                        params.push(this.getIdentifierName(param) || '');
+                    }
+                }
+            }
+            // Get return type
+            const returnNode = this.findChild(node, 'type_annotation');
+            if (returnNode) {
+                returnType = returnNode.text.replace(/^:\s*/, '');
+            }
+            // Calculate complexity
+            const bodyText = this.findChild(node, 'statement_block')?.text || '';
+            const complexity = this.calculateComplexity(bodyText);
+            // Find function calls
+            const calls = [];
+            const callRegex = /(\w+)\s*\(/g;
+            let match;
+            while ((match = callRegex.exec(bodyText)) !== null) {
+                if (!['if', 'for', 'while', 'switch', 'catch', 'function'].includes(match[1])) {
+                    calls.push(match[1]);
+                }
+            }
+            return {
+                name,
+                params: params.filter(Boolean),
+                returnType,
+                async: isAsync,
+                exported: isExported,
+                startLine: node.startPosition.row + 1,
+                endLine: node.endPosition.row + 1,
+                complexity,
+                calls: [...new Set(calls)],
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    parseClass(node, code, lang) {
+        try {
+            const name = this.getIdentifierName(node) || '<anonymous>';
+            let extendsClass;
+            const implementsList = [];
+            const methods = [];
+            const properties = [];
+            // Get extends/implements
+            const heritage = this.findChild(node, 'class_heritage');
+            if (heritage) {
+                const extendsNode = this.findChild(heritage, 'extends_clause');
+                if (extendsNode) {
+                    extendsClass = this.getIdentifierName(extendsNode) || undefined;
+                }
+            }
+            // Get methods and properties
+            const body = this.findChild(node, 'class_body');
+            if (body) {
+                for (const member of body.children || []) {
+                    if (member.type === 'method_definition') {
+                        const method = this.parseFunction(member, code, lang);
+                        if (method)
+                            methods.push(method);
+                    }
+                    else if (member.type === 'field_definition' || member.type === 'public_field_definition') {
+                        const propName = this.getIdentifierName(member);
+                        if (propName)
+                            properties.push(propName);
+                    }
+                }
+            }
+            return {
+                name,
+                extends: extendsClass,
+                implements: implementsList,
+                methods,
+                properties,
+                exported: node.parent?.type?.includes('export'),
+                startLine: node.startPosition.row + 1,
+                endLine: node.endPosition.row + 1,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    findChild(node, type) {
+        if (!node.children)
+            return null;
+        for (const child of node.children) {
+            if (child.type === type)
+                return child;
+            const found = this.findChild(child, type);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    getIdentifierName(node) {
+        if (node.type === 'identifier')
+            return node.text;
+        if (!node.children)
+            return null;
+        for (const child of node.children) {
+            if (child.type === 'identifier' || child.type === 'property_identifier') {
+                return child.text;
+            }
+        }
+        return null;
+    }
+    calculateComplexity(code) {
+        const patterns = [
+            /\bif\b/g,
+            /\belse\b/g,
+            /\bfor\b/g,
+            /\bwhile\b/g,
+            /\bcase\b/g,
+            /\bcatch\b/g,
+            /\?\s*[^:]/g, // ternary
+            /&&/g,
+            /\|\|/g,
+        ];
+        let complexity = 1;
+        for (const pattern of patterns) {
+            complexity += (code.match(pattern) || []).length;
+        }
+        return complexity;
+    }
+    analyzeWithRegex(file, lang, code, start) {
+        const lines = code.split('\n');
+        const imports = [];
+        const exports = [];
+        const functions = [];
+        const classes = [];
+        const variables = [];
+        const types = [];
+        // Regex patterns
+        const importRegex = /import\s+(?:(\w+)\s*,?\s*)?(?:\{([^}]+)\}\s*)?(?:\*\s+as\s+(\w+)\s*)?from\s+['"]([^'"]+)['"]/g;
+        const requireRegex = /(?:const|let|var)\s+(?:(\w+)|\{([^}]+)\})\s*=\s*require\s*\(['"]([^'"]+)['"]\)/g;
+        const exportRegex = /export\s+(?:(default)\s+)?(?:(class|function|const|let|var|interface|type)\s+)?(\w+)?/g;
+        const functionRegex = /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/g;
+        const arrowRegex = /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g;
+        const classRegex = /(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/g;
+        const typeRegex = /(?:export\s+)?(?:type|interface)\s+(\w+)/g;
+        // Parse imports
+        let match;
+        while ((match = importRegex.exec(code)) !== null) {
+            imports.push({
+                source: match[4],
+                default: match[1],
+                named: match[2] ? match[2].split(',').map(s => s.trim().split(/\s+as\s+/)[0]) : [],
+                namespace: match[3],
+                type: 'esm',
+            });
+        }
+        while ((match = requireRegex.exec(code)) !== null) {
+            imports.push({
+                source: match[3],
+                default: match[1],
+                named: match[2] ? match[2].split(',').map(s => s.trim()) : [],
+                type: 'commonjs',
+            });
+        }
+        // Parse exports
+        while ((match = exportRegex.exec(code)) !== null) {
+            if (match[3]) {
+                exports.push({
+                    name: match[3],
+                    type: match[1] === 'default' ? 'default' : 'named',
+                });
+            }
+        }
+        // Parse functions
+        while ((match = functionRegex.exec(code)) !== null) {
+            functions.push({
+                name: match[1],
+                params: match[2].split(',').map(p => p.trim().split(/[:\s]/)[0]).filter(Boolean),
+                async: code.substring(match.index - 10, match.index).includes('async'),
+                exported: code.substring(match.index - 10, match.index).includes('export'),
+                startLine: code.substring(0, match.index).split('\n').length,
+                endLine: 0,
+                complexity: 1,
+                calls: [],
+            });
+        }
+        while ((match = arrowRegex.exec(code)) !== null) {
+            functions.push({
+                name: match[1],
+                params: [],
+                async: code.substring(match.index, match.index + 50).includes('async'),
+                exported: false,
+                startLine: code.substring(0, match.index).split('\n').length,
+                endLine: 0,
+                complexity: 1,
+                calls: [],
+            });
+        }
+        // Parse classes
+        while ((match = classRegex.exec(code)) !== null) {
+            classes.push({
+                name: match[1],
+                extends: match[2],
+                implements: [],
+                methods: [],
+                properties: [],
+                exported: code.substring(match.index - 10, match.index).includes('export'),
+                startLine: code.substring(0, match.index).split('\n').length,
+                endLine: 0,
+            });
+        }
+        // Parse types
+        while ((match = typeRegex.exec(code)) !== null) {
+            types.push(match[1]);
+        }
+        return {
+            file,
+            language: lang,
+            imports,
+            exports,
+            functions,
+            classes,
+            variables,
+            types,
+            complexity: this.calculateComplexity(code),
+            lines: lines.length,
+            parseTime: performance.now() - start,
+        };
+    }
+    /**
+     * Get all symbols (functions, classes, types) in a file
+     */
+    async getSymbols(file) {
+        const analysis = await this.analyze(file);
+        return [
+            ...analysis.functions.map(f => f.name),
+            ...analysis.classes.map(c => c.name),
+            ...analysis.types,
+            ...analysis.variables,
+        ];
+    }
+    /**
+     * Get the call graph for a file
+     */
+    async getCallGraph(file) {
+        const analysis = await this.analyze(file);
+        const graph = new Map();
+        for (const fn of analysis.functions) {
+            graph.set(fn.name, fn.calls);
+        }
+        for (const cls of analysis.classes) {
+            for (const method of cls.methods) {
+                graph.set(`${cls.name}.${method.name}`, method.calls);
+            }
+        }
+        return graph;
+    }
+}
+exports.CodeParser = CodeParser;
+// ============================================================================
+// Singleton
+// ============================================================================
+let parserInstance = null;
+function getCodeParser() {
+    if (!parserInstance) {
+        parserInstance = new CodeParser();
+    }
+    return parserInstance;
+}
+async function initCodeParser() {
+    const parser = getCodeParser();
+    await parser.init();
+    return parser;
+}
+exports.default = CodeParser;

package/dist/core/coverage-router.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Coverage Router - Test coverage-aware agent routing
+ *
+ * Uses test coverage data to make smarter routing decisions:
+ * - Prioritize testing for uncovered code
+ * - Route to tester agent for low-coverage files
+ * - Suggest test files for modified code
+ */
+export interface CoverageData {
+    file: string;
+    lines: {
+        total: number;
+        covered: number;
+        percentage: number;
+    };
+    functions: {
+        total: number;
+        covered: number;
+        percentage: number;
+    };
+    branches: {
+        total: number;
+        covered: number;
+        percentage: number;
+    };
+    uncoveredLines: number[];
+    uncoveredFunctions: string[];
+}
+export interface CoverageSummary {
+    files: Map<string, CoverageData>;
+    overall: {
+        lines: number;
+        functions: number;
+        branches: number;
+    };
+    lowCoverageFiles: string[];
+    uncoveredFiles: string[];
+}
+export interface TestSuggestion {
+    file: string;
+    testFile: string;
+    reason: string;
+    priority: 'high' | 'medium' | 'low';
+    coverage: number;
+    uncoveredFunctions: string[];
+}
+/**
+ * Parse Istanbul/NYC JSON coverage report
+ */
+export declare function parseIstanbulCoverage(coveragePath: string): CoverageSummary;
+/**
+ * Find coverage report in project
+ */
+export declare function findCoverageReport(projectRoot?: string): string | null;
+/**
+ * Get coverage data for a specific file
+ */
+export declare function getFileCoverage(file: string, summary?: CoverageSummary): CoverageData | null;
+/**
+ * Suggest tests for files based on coverage
+ */
+export declare function suggestTests(files: string[], summary?: CoverageSummary): TestSuggestion[];
+/**
+ * Determine if a file needs the tester agent based on coverage
+ */
+export declare function shouldRouteToTester(file: string, summary?: CoverageSummary): {
+    route: boolean;
+    reason: string;
+    coverage: number;
+};
+/**
+ * Get coverage-aware routing weight for agent selection
+ */
+export declare function getCoverageRoutingWeight(file: string, summary?: CoverageSummary): {
+    coder: number;
+    tester: number;
+    reviewer: number;
+};
+declare const _default: {
+    parseIstanbulCoverage: typeof parseIstanbulCoverage;
+    findCoverageReport: typeof findCoverageReport;
+    getFileCoverage: typeof getFileCoverage;
+    suggestTests: typeof suggestTests;
+    shouldRouteToTester: typeof shouldRouteToTester;
+    getCoverageRoutingWeight: typeof getCoverageRoutingWeight;
+};
+export default _default;
+//# sourceMappingURL=coverage-router.d.ts.map

package/dist/core/coverage-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-router.d.ts","sourceRoot":"","sources":["../../src/core/coverage-router.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,SAAS,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACjC,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe,CA0F3E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAiBrF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,YAAY,GAAG,IAAI,CAqB5F;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,EAAE,CAwEzF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG;IAC5E,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAgCA;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG;IACjF,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAuBA;;;;;;;;;AAED,wBAOE"}