@grafema/core 0.1.0-alpha.1

package/dist/plugins/analysis/ServiceLayerAnalyzer.js

@@ -0,0 +1,303 @@
+/**
+ * ServiceLayerAnalyzer - детектит Service Layer Pattern
+ *
+ * Паттерны:
+ * - class XxxService { ... } - Service classes
+ * - new XxxService() - Service instantiation
+ * - app.set('service', instance) - DI registration
+ * - req.app.get('service') - Service usage
+ * - export class XxxService - Service exports
+ */
+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 ServiceLayerAnalyzer extends Plugin {
+    get metadata() {
+        return {
+            name: 'ServiceLayerAnalyzer',
+            phase: 'ANALYSIS',
+            priority: 75, // После JSASTAnalyzer (80)
+            creates: {
+                nodes: ['SERVICE_CLASS', 'SERVICE_INSTANCE', 'SERVICE_REGISTRATION', 'SERVICE_USAGE'],
+                edges: ['CONTAINS', 'INSTANTIATES', 'REGISTERS', 'USES_SERVICE']
+            },
+            dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
+        };
+    }
+    async execute(context) {
+        try {
+            const { graph } = context;
+            // Получаем все модули
+            const modules = await this.getModules(graph);
+            console.log(`[ServiceLayerAnalyzer] Processing ${modules.length} modules...`);
+            let classesCount = 0;
+            let instancesCount = 0;
+            let registrationsCount = 0;
+            let usagesCount = 0;
+            const startTime = Date.now();
+            for (let i = 0; i < modules.length; i++) {
+                const module = modules[i];
+                const result = await this.analyzeModule(module, graph);
+                classesCount += result.classes;
+                instancesCount += result.instances;
+                registrationsCount += result.registrations;
+                usagesCount += result.usages;
+                // 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(`[ServiceLayerAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`);
+                }
+            }
+            console.log(`[ServiceLayerAnalyzer] Found ${classesCount} service classes, ${instancesCount} instances, ${registrationsCount} registrations, ${usagesCount} usages`);
+            return createSuccessResult({
+                nodes: classesCount + instancesCount + registrationsCount + usagesCount,
+                edges: 0
+            }, {
+                classesCount,
+                instancesCount,
+                registrationsCount,
+                usagesCount
+            });
+        }
+        catch (error) {
+            console.error('[ServiceLayerAnalyzer] Error:', error);
+            return createErrorResult(error);
+        }
+    }
+    async analyzeModule(module, graph) {
+        try {
+            const code = readFileSync(module.file, 'utf-8');
+            const ast = parse(code, {
+                sourceType: 'module',
+                plugins: [
+                    'jsx',
+                    'typescript',
+                    'classProperties',
+                    'decorators-legacy',
+                    'asyncGenerators',
+                    'dynamicImport',
+                    'optionalChaining',
+                    'nullishCoalescingOperator'
+                ]
+            });
+            const serviceClasses = [];
+            const serviceInstances = [];
+            const serviceRegistrations = [];
+            const serviceUsages = [];
+            // Детект Service паттернов
+            traverse(ast, {
+                // Pattern 1: class XxxService { ... }
+                ClassDeclaration: (path) => {
+                    const node = path.node;
+                    const className = node.id?.name;
+                    if (className && this.isServiceClass(className)) {
+                        const line = node.loc.start.line;
+                        // Извлекаем методы сервиса
+                        const methods = node.body.body
+                            .filter(m => m.type === 'ClassMethod' && m.kind === 'method')
+                            .map(m => m.key.name);
+                        serviceClasses.push({
+                            id: `${module.file}:SERVICE_CLASS:${className}:${line}`,
+                            type: 'SERVICE_CLASS',
+                            name: className,
+                            methods: methods,
+                            file: module.file,
+                            line: line
+                        });
+                    }
+                },
+                // Pattern 2: new XxxService()
+                NewExpression: (path) => {
+                    const node = path.node;
+                    const callee = node.callee;
+                    if (callee.type === 'Identifier') {
+                        const className = callee.name;
+                        if (this.isServiceClass(className)) {
+                            const line = node.loc.start.line;
+                            serviceInstances.push({
+                                id: `${module.file}:SERVICE_INSTANCE:${className}:${line}`,
+                                type: 'SERVICE_INSTANCE',
+                                serviceClass: className,
+                                file: module.file,
+                                line: line
+                            });
+                        }
+                    }
+                },
+                // Pattern 3: app.set('serviceName', serviceInstance)
+                CallExpression: (path) => {
+                    const node = path.node;
+                    const callee = node.callee;
+                    // app.set('service', instance)
+                    if (callee.type === 'MemberExpression' &&
+                        callee.property.type === 'Identifier' &&
+                        callee.property.name === 'set') {
+                        const objectName = this.getObjectName(callee.object);
+                        if (objectName === 'app' && node.arguments.length >= 2) {
+                            const serviceName = this.extractStringArg(node.arguments[0]);
+                            const line = node.loc.start.line;
+                            // Проверяем что это похоже на service (имя содержит 'service' или '*Service')
+                            if (serviceName.toLowerCase().includes('service') ||
+                                this.isServiceClass(serviceName)) {
+                                serviceRegistrations.push({
+                                    id: `${module.file}:SERVICE_REGISTRATION:${serviceName}:${line}`,
+                                    type: 'SERVICE_REGISTRATION',
+                                    serviceName: serviceName,
+                                    objectName: objectName,
+                                    file: module.file,
+                                    line: line
+                                });
+                            }
+                        }
+                    }
+                    // req.app.get('service') - service usage
+                    if (callee.type === 'MemberExpression' &&
+                        callee.property.type === 'Identifier' &&
+                        callee.property.name === 'get') {
+                        // Проверяем что это req.app.get или app.get
+                        const objectChain = this.getObjectChain(callee.object);
+                        if ((objectChain.includes('req') && objectChain.includes('app')) ||
+                            objectChain.includes('app')) {
+                            if (node.arguments.length >= 1) {
+                                const serviceName = this.extractStringArg(node.arguments[0]);
+                                const line = node.loc.start.line;
+                                // Проверяем что это похоже на service
+                                if (serviceName.toLowerCase().includes('service') ||
+                                    this.isServiceClass(serviceName)) {
+                                    serviceUsages.push({
+                                        id: `${module.file}:SERVICE_USAGE:${serviceName}:${line}`,
+                                        type: 'SERVICE_USAGE',
+                                        serviceName: serviceName,
+                                        file: module.file,
+                                        line: line
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            // Создаём ноды в графе
+            for (const serviceClass of serviceClasses) {
+                await graph.addNode(serviceClass);
+                // Создаём ребро от модуля к service class
+                await graph.addEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: serviceClass.id
+                });
+            }
+            for (const instance of serviceInstances) {
+                await graph.addNode(instance);
+                // Создаём ребро от модуля к instance
+                await graph.addEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: instance.id
+                });
+                // Ищем SERVICE_CLASS ноду и создаём ребро INSTANTIATES
+                for await (const n of graph.queryNodes({ type: 'SERVICE_CLASS' })) {
+                    if (n.name === instance.serviceClass) {
+                        await graph.addEdge({
+                            type: 'INSTANTIATES',
+                            src: instance.id,
+                            dst: n.id
+                        });
+                        break;
+                    }
+                }
+            }
+            for (const registration of serviceRegistrations) {
+                await graph.addNode(registration);
+                // Создаём ребро от модуля к registration
+                await graph.addEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: registration.id
+                });
+            }
+            for (const usage of serviceUsages) {
+                await graph.addNode(usage);
+                // Создаём ребро от модуля к usage
+                await graph.addEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: usage.id
+                });
+            }
+            return {
+                classes: serviceClasses.length,
+                instances: serviceInstances.length,
+                registrations: serviceRegistrations.length,
+                usages: serviceUsages.length
+            };
+        }
+        catch (error) {
+            console.error(`[ServiceLayerAnalyzer] Error analyzing ${module.file}:`, error.message);
+            return { classes: 0, instances: 0, registrations: 0, usages: 0 };
+        }
+    }
+    /**
+     * Проверяет является ли класс Service классом
+     * (заканчивается на Service или содержит Service в имени)
+     */
+    isServiceClass(className) {
+        if (!className)
+            return false;
+        return (className.endsWith('Service') ||
+            className.includes('Service') ||
+            /Service[A-Z]/.test(className));
+    }
+    /**
+     * Извлекает имя объекта из MemberExpression
+     */
+    getObjectName(node) {
+        if (node.type === 'Identifier') {
+            return node.name;
+        }
+        else if (node.type === 'MemberExpression') {
+            return this.getObjectName(node.object);
+        }
+        else if (node.type === 'CallExpression') {
+            return this.getObjectName(node.callee);
+        }
+        return 'unknown';
+    }
+    /**
+     * Извлекает цепочку объектов (для req.app.get)
+     */
+    getObjectChain(node, chain = []) {
+        if (node.type === 'Identifier') {
+            chain.unshift(node.name);
+        }
+        else if (node.type === 'MemberExpression') {
+            const memberExpr = node;
+            if (memberExpr.property.type === 'Identifier') {
+                chain.push(memberExpr.property.name);
+            }
+            this.getObjectChain(memberExpr.object, chain);
+        }
+        return chain;
+    }
+    /**
+     * Извлекает строковое значение из аргумента
+     */
+    extractStringArg(arg) {
+        if (!arg)
+            return 'unknown';
+        if (arg.type === 'StringLiteral') {
+            return arg.value;
+        }
+        else if (arg.type === 'TemplateLiteral') {
+            const tl = arg;
+            if (tl.quasis.length === 1) {
+                return tl.quasis[0].value.raw;
+            }
+        }
+        return 'dynamic';
+    }
+}

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

@@ -0,0 +1,33 @@
+/**
+ * SocketIOAnalyzer - детектит Socket.IO operations
+ *
+ * Паттерны Server:
+ * - io.emit(event, data)
+ * - io.to(room).emit(event, data)
+ * - io.of(namespace).emit(event, data)
+ * - socket.on(event, handler)
+ * - socket.join(room)
+ * - socket.broadcast.emit(event, data)
+ *
+ * Паттерны Client:
+ * - socket.emit(event, data)
+ * - socket.on(event, handler)
+ * - socket.off(event, handler)
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class SocketIOAnalyzer extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    private analyzeModule;
+    /**
+     * Извлекает имя объекта из MemberExpression
+     * Например: socket.emit → 'socket', io.to('room').emit → 'io'
+     */
+    private getObjectName;
+    /**
+     * Извлекает строковое значение из аргумента
+     */
+    private extractStringArg;
+}
+//# sourceMappingURL=SocketIOAnalyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SocketIOAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/SocketIOAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAyDhF,qBAAa,gBAAiB,SAAQ,MAAM;IAC1C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YA+C9C,aAAa;IA+M3B;;;OAGG;IACH,OAAO,CAAC,aAAa;IAWrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CA4BzB"}

package/dist/plugins/analysis/SocketIOAnalyzer.js

@@ -0,0 +1,283 @@
+/**
+ * SocketIOAnalyzer - детектит Socket.IO operations
+ *
+ * Паттерны Server:
+ * - io.emit(event, data)
+ * - io.to(room).emit(event, data)
+ * - io.of(namespace).emit(event, data)
+ * - socket.on(event, handler)
+ * - socket.join(room)
+ * - socket.broadcast.emit(event, data)
+ *
+ * Паттерны Client:
+ * - socket.emit(event, data)
+ * - socket.on(event, handler)
+ * - socket.off(event, handler)
+ */
+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 SocketIOAnalyzer extends Plugin {
+    get metadata() {
+        return {
+            name: 'SocketIOAnalyzer',
+            phase: 'ANALYSIS',
+            priority: 75, // После JSASTAnalyzer (80)
+            creates: {
+                nodes: ['socketio:emit', 'socketio:on', 'socketio:room'],
+                edges: ['CONTAINS', 'EMITS_EVENT', 'LISTENS_TO', 'JOINS_ROOM']
+            },
+            dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
+        };
+    }
+    async execute(context) {
+        try {
+            const { graph } = context;
+            // Получаем все модули
+            const modules = await this.getModules(graph);
+            console.log(`[SocketIOAnalyzer] Processing ${modules.length} modules...`);
+            let emitsCount = 0;
+            let listenersCount = 0;
+            let roomsCount = 0;
+            const startTime = Date.now();
+            for (let i = 0; i < modules.length; i++) {
+                const module = modules[i];
+                const result = await this.analyzeModule(module, graph);
+                emitsCount += result.emits;
+                listenersCount += result.listeners;
+                roomsCount += result.rooms;
+                // 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(`[SocketIOAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`);
+                }
+            }
+            console.log(`[SocketIOAnalyzer] Found ${emitsCount} emits, ${listenersCount} listeners, ${roomsCount} rooms`);
+            return createSuccessResult({
+                nodes: emitsCount + listenersCount + roomsCount,
+                edges: 0
+            }, { emitsCount, listenersCount, roomsCount });
+        }
+        catch (error) {
+            console.error('[SocketIOAnalyzer] Error:', error);
+            return createErrorResult(error);
+        }
+    }
+    async analyzeModule(module, graph) {
+        try {
+            const code = readFileSync(module.file, 'utf-8');
+            const ast = parse(code, {
+                sourceType: 'module',
+                plugins: [
+                    'jsx',
+                    'typescript',
+                    'classProperties',
+                    'decorators-legacy',
+                    'asyncGenerators',
+                    'dynamicImport',
+                    'optionalChaining',
+                    'nullishCoalescingOperator'
+                ]
+            });
+            const emits = [];
+            const listeners = [];
+            const rooms = [];
+            // Детект Socket.IO паттернов
+            traverse(ast, {
+                CallExpression: (path) => {
+                    const node = path.node;
+                    const callee = node.callee;
+                    // Pattern: socket.emit(event, data) или io.emit(event, data)
+                    if (callee.type === 'MemberExpression' &&
+                        callee.property.type === 'Identifier' &&
+                        callee.property.name === 'emit') {
+                        const objectName = this.getObjectName(callee.object);
+                        const event = this.extractStringArg(node.arguments[0]);
+                        const line = node.loc.start.line;
+                        const column = node.loc.start.column;
+                        // io.to('room').emit() - room-based emit
+                        let room = null;
+                        if (callee.object.type === 'CallExpression' &&
+                            callee.object.callee.type === 'MemberExpression' &&
+                            callee.object.callee.property.name === 'to') {
+                            room = this.extractStringArg(callee.object.arguments[0]);
+                        }
+                        // io.of('/namespace').emit() - namespace emit
+                        let namespace = null;
+                        if (callee.object.type === 'CallExpression' &&
+                            callee.object.callee.type === 'MemberExpression' &&
+                            callee.object.callee.property.name === 'of') {
+                            namespace = this.extractStringArg(callee.object.arguments[0]);
+                        }
+                        // socket.broadcast.emit() - broadcast to all except sender
+                        let broadcast = false;
+                        if (callee.object.type === 'MemberExpression' &&
+                            callee.object.property.name === 'broadcast') {
+                            broadcast = true;
+                        }
+                        emits.push({
+                            id: `socketio:emit#${event}#${module.file}#${line}`,
+                            type: 'socketio:emit',
+                            event: event,
+                            room: room,
+                            namespace: namespace,
+                            broadcast: broadcast,
+                            objectName: objectName,
+                            file: module.file,
+                            line: line,
+                            column: column
+                        });
+                    }
+                    // Pattern: socket.on(event, handler) или io.on(event, handler)
+                    if (callee.type === 'MemberExpression' &&
+                        callee.property.type === 'Identifier' &&
+                        callee.property.name === 'on') {
+                        const objectName = this.getObjectName(callee.object);
+                        const event = this.extractStringArg(node.arguments[0]);
+                        const line = node.loc.start.line;
+                        const handler = node.arguments[1];
+                        // Извлекаем имя handler функции
+                        let handlerName = 'anonymous';
+                        let handlerLine = line;
+                        if (handler) {
+                            if (handler.type === 'FunctionExpression' ||
+                                handler.type === 'ArrowFunctionExpression') {
+                                handlerName = `anonymous:${handler.loc.start.line}`;
+                                handlerLine = handler.loc.start.line;
+                            }
+                            else if (handler.type === 'Identifier') {
+                                handlerName = handler.name;
+                            }
+                        }
+                        listeners.push({
+                            id: `socketio:on#${event}#${module.file}#${line}`,
+                            type: 'socketio:on',
+                            event: event,
+                            objectName: objectName,
+                            handlerName: handlerName,
+                            handlerLine: handlerLine,
+                            file: module.file,
+                            line: line
+                        });
+                    }
+                    // Pattern: socket.join(room)
+                    if (callee.type === 'MemberExpression' &&
+                        callee.property.type === 'Identifier' &&
+                        callee.property.name === 'join') {
+                        const objectName = this.getObjectName(callee.object);
+                        const roomName = this.extractStringArg(node.arguments[0]);
+                        const line = node.loc.start.line;
+                        if (objectName === 'socket') {
+                            rooms.push({
+                                id: `socketio:room#${roomName}#${module.file}#${line}`,
+                                type: 'socketio:room',
+                                room: roomName,
+                                objectName: objectName,
+                                file: module.file,
+                                line: line
+                            });
+                        }
+                    }
+                }
+            });
+            // Создаём ноды в графе
+            for (const emit of emits) {
+                await graph.addNode(emit);
+                // Создаём ребро от модуля к event
+                await graph.addEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: emit.id
+                });
+            }
+            for (const listener of listeners) {
+                await graph.addNode(listener);
+                // Создаём ребро от модуля к listener
+                await graph.addEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: listener.id
+                });
+                // Ищем FUNCTION node для handler и создаём ребро LISTENS_TO
+                const handlerFunctionId = `FUNCTION#${listener.handlerName}#${listener.file}#${listener.handlerLine}`;
+                const handlerFunction = await graph.getNode(handlerFunctionId);
+                if (handlerFunction) {
+                    await graph.addEdge({
+                        type: 'LISTENS_TO',
+                        src: listener.id,
+                        dst: handlerFunctionId
+                    });
+                }
+            }
+            for (const room of rooms) {
+                await graph.addNode(room);
+                // Создаём ребро от модуля к room
+                await graph.addEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: room.id
+                });
+            }
+            return {
+                emits: emits.length,
+                listeners: listeners.length,
+                rooms: rooms.length
+            };
+        }
+        catch (error) {
+            console.error(`[SocketIOAnalyzer] Error analyzing ${module.file}:`, error.message);
+            return { emits: 0, listeners: 0, rooms: 0 };
+        }
+    }
+    /**
+     * Извлекает имя объекта из MemberExpression
+     * Например: socket.emit → 'socket', io.to('room').emit → 'io'
+     */
+    getObjectName(node) {
+        if (node.type === 'Identifier') {
+            return node.name;
+        }
+        else if (node.type === 'MemberExpression') {
+            return this.getObjectName(node.object);
+        }
+        else if (node.type === 'CallExpression') {
+            return this.getObjectName(node.callee);
+        }
+        return 'unknown';
+    }
+    /**
+     * Извлекает строковое значение из аргумента
+     */
+    extractStringArg(arg) {
+        if (!arg)
+            return 'unknown';
+        if (arg.type === 'StringLiteral') {
+            return arg.value;
+        }
+        else if (arg.type === 'TemplateLiteral') {
+            const tl = arg;
+            if (tl.quasis.length === 1) {
+                // Простой template literal без интерполяции
+                return tl.quasis[0].value.raw;
+            }
+            else {
+                // Template literal с переменными - возвращаем паттерн
+                const parts = tl.quasis.map(q => q.value.raw);
+                const expressions = tl.expressions.map(() => '${...}');
+                let result = '';
+                for (let i = 0; i < parts.length; i++) {
+                    result += parts[i];
+                    if (i < expressions.length) {
+                        result += expressions[i];
+                    }
+                }
+                return result;
+            }
+        }
+        return 'dynamic';
+    }
+}

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

@@ -0,0 +1,27 @@
+/**
+ * SystemDbAnalyzer - специализированный плагин для анализа system_db API
+ *
+ * Понимает семантику system_db и добавляет ноды для сайд-эффектов:
+ * - system_db.use(view, server) -> регистрирует VIEW через get_view()
+ * - system_db.subscribe(servers) -> проверяет все зарегистрированные VIEW'ы
+ * - local.use(view) -> регистрирует VIEW в get_hosts()
+ *
+ * Добавляет специальные ноды:
+ * - SYSTEM_DB_VIEW_REGISTRATION - регистрация VIEW'а
+ * - SYSTEM_DB_SUBSCRIPTION - подписка на сервер
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class SystemDbAnalyzer extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Extract literal value from AST node
+     */
+    private extractLiteral;
+    /**
+     * Extract server list from subscribe() argument
+     */
+    private extractServerList;
+}
+//# sourceMappingURL=SystemDbAnalyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SystemDbAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/SystemDbAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA2BhF,qBAAa,gBAAiB,SAAQ,MAAM;IAC1C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAuL5D;;OAEG;IACH,OAAO,CAAC,cAAc;IAiBtB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAkB1B"}