@grafema/core 0.1.0-alpha.1

package/dist/plugins/analysis/DatabaseAnalyzer.js

@@ -0,0 +1,260 @@
+/**
+ * DatabaseAnalyzer - анализ database access patterns
+ * Детектирует db.query(), connection.query() и другие SQL вызовы
+ */
+import { readFileSync } from 'fs';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverse = traverseModule.default || traverseModule;
+export class DatabaseAnalyzer extends Plugin {
+    get metadata() {
+        return {
+            name: 'DatabaseAnalyzer',
+            phase: 'ANALYSIS',
+            priority: 75, // После JSASTAnalyzer (80)
+            creates: {
+                nodes: ['db:query', 'db:table', 'db:connection'],
+                edges: ['MAKES_QUERY', 'TARGETS', 'READS_FROM', 'WRITES_TO']
+            },
+            dependencies: ['JSASTAnalyzer'] // Требует MODULE и FUNCTION ноды
+        };
+    }
+    async execute(context) {
+        try {
+            const { graph } = context;
+            // Получаем все MODULE ноды
+            const modules = await this.getModules(graph);
+            console.log(`[DatabaseAnalyzer] Processing ${modules.length} modules...`);
+            // Получаем все FUNCTION ноды для связывания
+            const functions = await this.getFunctions(graph);
+            let queriesCreated = 0;
+            let tablesCreated = 0;
+            let edgesCreated = 0;
+            const startTime = Date.now();
+            // Анализируем каждый модуль
+            for (let i = 0; i < modules.length; i++) {
+                const module = modules[i];
+                const result = await this.analyzeModule(module, functions, graph);
+                queriesCreated += result.queries;
+                tablesCreated += result.tables;
+                edgesCreated += result.edges;
+                // Progress every 20 modules
+                if ((i + 1) % 20 === 0 || i === modules.length - 1) {
+                    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                    const avgTime = ((Date.now() - startTime) / (i + 1)).toFixed(0);
+                    console.log(`[DatabaseAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`);
+                }
+            }
+            console.log(`[DatabaseAnalyzer] Created ${queriesCreated} queries, ${tablesCreated} tables`);
+            return createSuccessResult({
+                nodes: queriesCreated + tablesCreated,
+                edges: edgesCreated
+            }, {
+                queriesCreated,
+                tablesCreated
+            });
+        }
+        catch (error) {
+            console.error(`[DatabaseAnalyzer] Error:`, error);
+            return createErrorResult(error);
+        }
+    }
+    /**
+     * Получить все FUNCTION ноды из графа
+     */
+    async getFunctions(graph) {
+        const functions = [];
+        for await (const node of graph.queryNodes({ type: 'FUNCTION' })) {
+            functions.push(node);
+        }
+        return functions;
+    }
+    /**
+     * Анализировать один модуль на database patterns
+     */
+    async analyzeModule(module, functions, graph) {
+        let queriesCreated = 0;
+        let tablesCreated = 0;
+        let edgesCreated = 0;
+        try {
+            // Читаем и парсим файл
+            const code = readFileSync(module.file, 'utf-8');
+            const ast = parse(code, {
+                sourceType: 'module',
+                plugins: ['jsx']
+            });
+            const databaseQueries = [];
+            const createdTables = new Set();
+            let queryCounter = 0;
+            // Ищем db.query() паттерны
+            traverse(ast, {
+                CallExpression: (path) => {
+                    const node = path.node;
+                    // Проверяем что это MemberExpression: db.query(), connection.execute()
+                    if (node.callee.type === 'MemberExpression') {
+                        const methodName = node.callee.property.name;
+                        const objectName = node.callee.object.name;
+                        // Детектируем database queries
+                        const isDatabaseQuery = (methodName === 'query' || methodName === 'execute') &&
+                            (objectName === 'db' || objectName === 'connection' || objectName === 'pool') &&
+                            node.arguments.length >= 1;
+                        if (isDatabaseQuery) {
+                            const sqlArg = node.arguments[0];
+                            let sql = null;
+                            let operation = 'UNKNOWN';
+                            // Извлекаем SQL строку
+                            if (sqlArg.type === 'StringLiteral') {
+                                sql = sqlArg.value;
+                            }
+                            else if (sqlArg.type === 'TemplateLiteral') {
+                                // Template literal - собираем строку с placeholders
+                                sql = sqlArg.quasis.map(q => q.value.raw).join('${...}');
+                            }
+                            // Определяем тип операции и таблицу из SQL
+                            if (sql) {
+                                const sqlUpper = sql.trim().toUpperCase();
+                                let tableName = null;
+                                if (sqlUpper.startsWith('SELECT')) {
+                                    operation = 'SELECT';
+                                    const fromMatch = sqlUpper.match(/FROM\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                                    if (fromMatch)
+                                        tableName = fromMatch[1].toLowerCase();
+                                }
+                                else if (sqlUpper.startsWith('INSERT')) {
+                                    operation = 'INSERT';
+                                    const intoMatch = sqlUpper.match(/INTO\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                                    if (intoMatch)
+                                        tableName = intoMatch[1].toLowerCase();
+                                }
+                                else if (sqlUpper.startsWith('UPDATE')) {
+                                    operation = 'UPDATE';
+                                    const updateMatch = sqlUpper.match(/UPDATE\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                                    if (updateMatch)
+                                        tableName = updateMatch[1].toLowerCase();
+                                }
+                                else if (sqlUpper.startsWith('DELETE')) {
+                                    operation = 'DELETE';
+                                    const deleteMatch = sqlUpper.match(/FROM\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                                    if (deleteMatch)
+                                        tableName = deleteMatch[1].toLowerCase();
+                                }
+                                else if (sqlUpper.startsWith('CREATE')) {
+                                    operation = 'CREATE';
+                                    const createMatch = sqlUpper.match(/TABLE\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                                    if (createMatch)
+                                        tableName = createMatch[1].toLowerCase();
+                                }
+                                else if (sqlUpper.startsWith('DROP')) {
+                                    operation = 'DROP';
+                                    const dropMatch = sqlUpper.match(/TABLE\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                                    if (dropMatch)
+                                        tableName = dropMatch[1].toLowerCase();
+                                }
+                                else if (sqlUpper.startsWith('ALTER')) {
+                                    operation = 'ALTER';
+                                    const alterMatch = sqlUpper.match(/TABLE\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                                    if (alterMatch)
+                                        tableName = alterMatch[1].toLowerCase();
+                                }
+                                const queryId = queryCounter++;
+                                const sqlSnippet = sql.length > 50 ? sql.substring(0, 50) + '...' : sql;
+                                databaseQueries.push({
+                                    id: `${module.file}:DATABASE_QUERY:${queryId}`,
+                                    type: 'db:query',
+                                    sql: sql,
+                                    sqlSnippet: sqlSnippet,
+                                    operation: operation,
+                                    tableName: tableName,
+                                    object: objectName,
+                                    method: methodName,
+                                    file: module.file,
+                                    line: node.loc.start.line
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            // Создаём EXTERNAL_DATABASE ноду если есть хотя бы один query
+            if (databaseQueries.length > 0) {
+                const databaseId = 'EXTERNAL_DATABASE:__database__';
+                const existingDb = await graph.getNode(databaseId);
+                if (!existingDb) {
+                    await graph.addNode({
+                        id: databaseId,
+                        type: 'db:connection',
+                        name: '__database__'
+                    });
+                }
+                // Создаём DATABASE_QUERY ноды
+                for (const query of databaseQueries) {
+                    await graph.addNode(query);
+                    queriesCreated++;
+                    // Создаём TABLE ноду если есть tableName
+                    if (query.tableName) {
+                        const tableId = `TABLE:${query.tableName}`;
+                        if (!createdTables.has(tableId)) {
+                            await graph.addNode({
+                                id: tableId,
+                                type: 'db:table',
+                                name: query.tableName
+                            });
+                            tablesCreated++;
+                            createdTables.add(tableId);
+                        }
+                        // DATABASE_QUERY -> TARGETS -> TABLE
+                        await graph.addEdge({
+                            type: 'TARGETS',
+                            src: query.id,
+                            dst: tableId
+                        });
+                        edgesCreated++;
+                    }
+                    // DATABASE_QUERY -> (READS_FROM | WRITES_TO) -> __database__
+                    const isReadOperation = query.operation === 'SELECT';
+                    const edgeType = isReadOperation ? 'READS_FROM' : 'WRITES_TO';
+                    await graph.addEdge({
+                        type: edgeType,
+                        src: query.id,
+                        dst: databaseId
+                    });
+                    edgesCreated++;
+                    // Находим родительскую функцию для MAKES_QUERY ребра
+                    const parentFunction = this.findParentFunction(query, functions);
+                    if (parentFunction) {
+                        await graph.addEdge({
+                            type: 'MAKES_QUERY',
+                            src: parentFunction.id,
+                            dst: query.id
+                        });
+                        edgesCreated++;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[DatabaseAnalyzer] Error analyzing ${module.file}:`, error.message);
+        }
+        return {
+            queries: queriesCreated,
+            tables: tablesCreated,
+            edges: edgesCreated
+        };
+    }
+    /**
+     * Найти родительскую функцию для database query
+     */
+    findParentFunction(query, functions) {
+        // Ищем функцию в том же файле, которая содержит эту строку
+        const candidates = functions.filter(f => f.file === query.file && (f.line ?? 0) < query.line // Функция должна начинаться раньше query
+        );
+        // Берём ближайшую (с максимальным line number меньше query.line)
+        if (candidates.length > 0) {
+            candidates.sort((a, b) => (b.line ?? 0) - (a.line ?? 0));
+            return candidates[0];
+        }
+        return null;
+    }
+}

package/dist/plugins/analysis/ExpressAnalyzer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ExpressAnalyzer - анализ Express.js patterns
+ * Детектирует HTTP routes и mount points через AST парсинг
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class ExpressAnalyzer extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Анализировать один модуль на Express patterns
+     */
+    private analyzeModule;
+    /**
+     * Создать MOUNTS рёбра для mount point
+     */
+    private createMountEdges;
+}
+//# sourceMappingURL=ExpressAnalyzer.d.ts.map

package/dist/plugins/analysis/ExpressAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/ExpressAnalyzer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAoDhF,qBAAa,eAAgB,SAAQ,MAAM;IACzC,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA8C5D;;OAEG;YACW,aAAa;IA6N3B;;OAEG;YACW,gBAAgB;CAiD/B"}

package/dist/plugins/analysis/ExpressAnalyzer.js

@@ -0,0 +1,306 @@
+/**
+ * ExpressAnalyzer - анализ Express.js patterns
+ * Детектирует HTTP routes и mount points через AST парсинг
+ */
+import { readFileSync } from 'fs';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import { dirname, resolve } from 'path';
+import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverse = traverseModule.default || traverseModule;
+export class ExpressAnalyzer extends Plugin {
+    get metadata() {
+        return {
+            name: 'ExpressAnalyzer',
+            phase: 'ANALYSIS',
+            priority: 75, // После JSASTAnalyzer (80)
+            creates: {
+                nodes: ['http:route', 'express:mount'],
+                edges: ['EXPOSES', 'MOUNTS', 'DEFINES']
+            },
+            dependencies: ['JSASTAnalyzer'] // Требует MODULE ноды
+        };
+    }
+    async execute(context) {
+        try {
+            const { graph } = context;
+            // Создаём net:request ноду (дедупликация в GraphBackend)
+            const networkId = 'net:request#__network__';
+            await graph.addNode({
+                id: networkId,
+                type: 'net:request',
+                name: '__network__',
+                description: 'External HTTP network'
+            });
+            // Получаем все MODULE ноды
+            const modules = await this.getModules(graph);
+            let endpointsCreated = 0;
+            let mountPointsCreated = 0;
+            let edgesCreated = 0;
+            // Анализируем каждый модуль
+            for (const module of modules) {
+                const result = await this.analyzeModule(module, graph, networkId);
+                endpointsCreated += result.endpoints;
+                mountPointsCreated += result.mountPoints;
+                edgesCreated += result.edges;
+            }
+            console.log(`[ExpressAnalyzer] Created ${endpointsCreated} endpoints, ${mountPointsCreated} mount points`);
+            return createSuccessResult({
+                nodes: endpointsCreated + mountPointsCreated + 1, // +1 для EXTERNAL_NETWORK
+                edges: edgesCreated
+            }, {
+                endpointsCreated,
+                mountPointsCreated
+            });
+        }
+        catch (error) {
+            console.error(`[ExpressAnalyzer] Error:`, error);
+            return createErrorResult(error);
+        }
+    }
+    /**
+     * Анализировать один модуль на Express patterns
+     */
+    async analyzeModule(module, graph, networkId) {
+        let endpointsCreated = 0;
+        let mountPointsCreated = 0;
+        let edgesCreated = 0;
+        try {
+            // Читаем и парсим файл
+            const code = readFileSync(module.file, 'utf-8');
+            const ast = parse(code, {
+                sourceType: 'module',
+                plugins: ['jsx']
+            });
+            const endpoints = [];
+            const mountPoints = [];
+            const imports = [];
+            // Собираем импорты для резолвинга mount points
+            traverse(ast, {
+                ImportDeclaration: (path) => {
+                    const importNode = path.node;
+                    const source = importNode.source.value;
+                    // Собираем specifiers
+                    const specifiers = importNode.specifiers
+                        .map(spec => {
+                        if (spec.type === 'ImportDefaultSpecifier') {
+                            return { local: spec.local.name, imported: 'default' };
+                        }
+                        else if (spec.type === 'ImportSpecifier') {
+                            const imported = spec.imported.type === 'Identifier' ? spec.imported.name : spec.imported.value;
+                            return { local: spec.local.name, imported };
+                        }
+                        return null;
+                    })
+                        .filter((s) => s !== null);
+                    imports.push({
+                        source,
+                        specifiers,
+                        line: importNode.loc.start.line
+                    });
+                }
+            });
+            // Ищем Express patterns
+            traverse(ast, {
+                CallExpression: (path) => {
+                    const node = path.node;
+                    // Проверяем что это MemberExpression: app.get(), router.use(), и т.д.
+                    if (node.callee.type === 'MemberExpression') {
+                        const methodName = node.callee.property.name;
+                        const objectName = node.callee.object.name;
+                        // Детектируем routes
+                        const httpMethods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head'];
+                        const isRouteDefinition = httpMethods.includes(methodName?.toLowerCase()) &&
+                            (objectName === 'app' || objectName === 'router') &&
+                            node.arguments.length >= 2;
+                        if (isRouteDefinition) {
+                            const pathArg = node.arguments[0];
+                            let routePath = null;
+                            if (pathArg.type === 'StringLiteral') {
+                                routePath = pathArg.value;
+                            }
+                            else if (pathArg.type === 'TemplateLiteral' && pathArg.quasis.length === 1) {
+                                routePath = pathArg.quasis[0].value.raw;
+                            }
+                            if (routePath) {
+                                const method = methodName.toUpperCase();
+                                endpoints.push({
+                                    id: `http:route#${method}:${routePath}#${module.file}#${node.loc.start.line}`,
+                                    type: 'http:route',
+                                    method: method,
+                                    path: routePath,
+                                    localPath: routePath,
+                                    file: module.file,
+                                    line: node.loc.start.line,
+                                    mountedOn: objectName
+                                });
+                            }
+                        }
+                        // Детектируем mount points
+                        const isMountPoint = methodName === 'use' &&
+                            (objectName === 'app' || objectName === 'router') &&
+                            node.arguments.length >= 1;
+                        if (isMountPoint) {
+                            let prefix = null;
+                            let targetFunction = null;
+                            let targetVariable = null;
+                            let targetArg = null;
+                            // Определяем структуру аргументов
+                            if (node.arguments.length === 1) {
+                                // app.use(middleware) - без префикса
+                                targetArg = node.arguments[0];
+                                prefix = '/';
+                            }
+                            else if (node.arguments.length >= 2) {
+                                // app.use('/prefix', router) - с префиксом
+                                const firstArg = node.arguments[0];
+                                targetArg = node.arguments[1];
+                                // Извлекаем префикс
+                                if (firstArg.type === 'StringLiteral') {
+                                    prefix = firstArg.value;
+                                }
+                                else if (firstArg.type === 'TemplateLiteral') {
+                                    if (firstArg.quasis.length === 1 && firstArg.expressions.length === 0) {
+                                        prefix = firstArg.quasis[0].value.raw;
+                                    }
+                                    else {
+                                        prefix = '${template}';
+                                    }
+                                }
+                                else if (firstArg.type === 'BinaryExpression') {
+                                    prefix = '${binary}';
+                                }
+                                else if (firstArg.type === 'Identifier') {
+                                    prefix = '${variable}';
+                                }
+                                else if (firstArg.type === 'CallExpression') {
+                                    prefix = '${call}';
+                                }
+                                else if (firstArg.type === 'MemberExpression') {
+                                    prefix = '${member}';
+                                }
+                                else if (firstArg.type === 'ConditionalExpression') {
+                                    prefix = '${conditional}';
+                                }
+                                else {
+                                    prefix = '${expression}';
+                                }
+                            }
+                            // Извлекаем target
+                            if (targetArg) {
+                                if (targetArg.type === 'CallExpression') {
+                                    if (targetArg.callee.type === 'Identifier') {
+                                        targetFunction = targetArg.callee.name;
+                                    }
+                                    else if (targetArg.callee.type === 'MemberExpression' &&
+                                        targetArg.callee.object.type === 'Identifier') {
+                                        targetVariable = targetArg.callee.object.name;
+                                    }
+                                }
+                                else if (targetArg.type === 'Identifier') {
+                                    targetVariable = targetArg.name;
+                                }
+                            }
+                            // Создаём mount point
+                            if ((targetFunction || targetVariable) && prefix) {
+                                mountPoints.push({
+                                    id: `express:mount#${prefix}#${module.file}#${node.loc.start.line}`,
+                                    type: 'express:mount',
+                                    prefix: prefix,
+                                    targetFunction: targetFunction,
+                                    targetVariable: targetVariable,
+                                    file: module.file,
+                                    line: node.loc.start.line,
+                                    mountedOn: objectName
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            // Создаём ENDPOINT ноды
+            for (const endpoint of endpoints) {
+                await graph.addNode(endpoint);
+                endpointsCreated++;
+                // MODULE --EXPOSES--> ENDPOINT
+                await graph.addEdge({
+                    type: 'EXPOSES',
+                    src: module.id,
+                    dst: endpoint.id
+                });
+                edgesCreated++;
+                // ENDPOINT --INTERACTS_WITH--> EXTERNAL_NETWORK
+                await graph.addEdge({
+                    type: 'INTERACTS_WITH',
+                    src: endpoint.id,
+                    dst: networkId
+                });
+                edgesCreated++;
+            }
+            // Создаём MOUNT_POINT ноды
+            for (const mountPoint of mountPoints) {
+                await graph.addNode(mountPoint);
+                mountPointsCreated++;
+                // MODULE --DEFINES--> MOUNT_POINT
+                await graph.addEdge({
+                    type: 'DEFINES',
+                    src: module.id,
+                    dst: mountPoint.id
+                });
+                edgesCreated++;
+                // Создаём MOUNTS рёбра
+                const mountEdges = await this.createMountEdges(mountPoint, module, imports, graph);
+                edgesCreated += mountEdges;
+            }
+        }
+        catch (error) {
+            console.error(`[ExpressAnalyzer] Error analyzing ${module.file}:`, error.message);
+        }
+        return {
+            endpoints: endpointsCreated,
+            mountPoints: mountPointsCreated,
+            edges: edgesCreated
+        };
+    }
+    /**
+     * Создать MOUNTS рёбра для mount point
+     */
+    async createMountEdges(mountPoint, module, imports, graph) {
+        let edgesCreated = 0;
+        // Резолвим через импорты: какой модуль экспортирует targetFunction или targetVariable?
+        let targetModulePath = null;
+        const targetName = mountPoint.targetFunction || mountPoint.targetVariable;
+        if (targetName) {
+            for (const imp of imports) {
+                const isRelative = imp.source.startsWith('./') || imp.source.startsWith('../');
+                if (!isRelative)
+                    continue;
+                // Проверяем есть ли targetName среди specifiers
+                const hasTarget = imp.specifiers &&
+                    imp.specifiers.some(spec => spec.local === targetName || spec.imported === targetName);
+                if (hasTarget) {
+                    // Резолвим путь к модулю
+                    const currentDir = dirname(module.file);
+                    targetModulePath = resolve(currentDir, imp.source);
+                    break;
+                }
+            }
+        }
+        // Если нашли целевой модуль, создаем MOUNTS ребро
+        if (targetModulePath) {
+            const targetModuleId = `${targetModulePath}:MODULE:${targetModulePath}:0`;
+            // Проверяем что модуль существует в графе
+            const targetModule = await graph.getNode(targetModuleId);
+            if (targetModule) {
+                await graph.addEdge({
+                    type: 'MOUNTS',
+                    src: mountPoint.id,
+                    dst: targetModuleId
+                });
+                edgesCreated++;
+            }
+        }
+        return edgesCreated;
+    }
+}

package/dist/plugins/analysis/ExpressRouteAnalyzer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ExpressRouteAnalyzer - детектит Express/Router endpoints с middleware chains
+ *
+ * Паттерны:
+ * - router.get('/path', handler)
+ * - router.post('/path', middleware1, middleware2, handler)
+ * - app.use('/prefix', middleware)
+ * - router.get('/path', asyncHandler(async (req, res) => {...}))
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class ExpressRouteAnalyzer extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    private analyzeModule;
+}
+//# sourceMappingURL=ExpressRouteAnalyzer.d.ts.map

package/dist/plugins/analysis/ExpressRouteAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressRouteAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/ExpressRouteAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8ChF,qBAAa,oBAAqB,SAAQ,MAAM;IAC9C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YAgD9C,aAAa;CAiS5B"}