@grafema/core 0.1.0-alpha.1

package/dist/plugins/enrichment/MethodCallResolver.js

@@ -0,0 +1,252 @@
+/**
+ * MethodCallResolver - обогащает METHOD_CALL ноды связями CALLS к определениям методов
+ *
+ * Находит вызовы методов (CALL с "object" атрибутом) и пытается связать их с:
+ * 1. Методами классов в том же файле
+ * 2. Методами классов в импортированных модулях
+ * 3. Методами объектов переменных
+ *
+ * СОЗДАЁТ РЁБРА:
+ * - METHOD_CALL -> CALLS -> METHOD (для методов классов)
+ * - METHOD_CALL -> CALLS -> FUNCTION (для методов объектов)
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+export class MethodCallResolver extends Plugin {
+    _containingClassCache;
+    get metadata() {
+        return {
+            name: 'MethodCallResolver',
+            phase: 'ENRICHMENT',
+            priority: 50,
+            creates: {
+                nodes: [],
+                edges: ['CALLS']
+            }
+        };
+    }
+    async execute(context) {
+        const { graph, onProgress } = context;
+        console.log('[MethodCallResolver] Starting method call resolution...');
+        let methodCallsProcessed = 0;
+        let edgesCreated = 0;
+        let unresolved = 0;
+        // Собираем все METHOD_CALL ноды (CALL с object атрибутом)
+        const methodCalls = [];
+        for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+            const callNode = node;
+            if (callNode.object) {
+                methodCalls.push(callNode);
+            }
+        }
+        console.log(`[MethodCallResolver] Found ${methodCalls.length} method calls to resolve`);
+        // Собираем все классы и их методы для быстрого поиска
+        const classMethodIndex = await this.buildClassMethodIndex(graph);
+        console.log(`[MethodCallResolver] Indexed ${classMethodIndex.size} classes`);
+        // Собираем переменные и их типы (если известны)
+        const variableTypes = await this.buildVariableTypeIndex(graph);
+        const startTime = Date.now();
+        for (const methodCall of methodCalls) {
+            methodCallsProcessed++;
+            // Report progress every 50 calls
+            if (onProgress && methodCallsProcessed % 50 === 0) {
+                const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                onProgress({
+                    phase: 'enrichment',
+                    currentPlugin: 'MethodCallResolver',
+                    message: `Resolving method calls ${methodCallsProcessed}/${methodCalls.length} (${elapsed}s)`,
+                    totalFiles: methodCalls.length,
+                    processedFiles: methodCallsProcessed
+                });
+            }
+            // Log every 10 calls with timing
+            if (methodCallsProcessed % 10 === 0) {
+                const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                const avgTime = ((Date.now() - startTime) / methodCallsProcessed).toFixed(0);
+                console.log(`[MethodCallResolver] Progress: ${methodCallsProcessed}/${methodCalls.length} (${elapsed}s, avg ${avgTime}ms/call)`);
+            }
+            // Пропускаем внешние методы (console, Array.prototype, etc.)
+            if (this.isExternalMethod(methodCall.object, methodCall.method)) {
+                continue;
+            }
+            // Проверяем есть ли уже CALLS ребро
+            const existingEdges = await graph.getOutgoingEdges(methodCall.id, ['CALLS']);
+            if (existingEdges.length > 0) {
+                continue; // Уже есть связь
+            }
+            // Пытаемся найти определение метода
+            const targetMethod = await this.resolveMethodCall(methodCall, classMethodIndex, variableTypes, graph);
+            if (targetMethod) {
+                await graph.addEdge({
+                    src: methodCall.id,
+                    dst: targetMethod.id,
+                    type: 'CALLS'
+                });
+                edgesCreated++;
+            }
+            else {
+                unresolved++;
+            }
+        }
+        const summary = {
+            methodCallsProcessed,
+            edgesCreated,
+            unresolved,
+            classesIndexed: classMethodIndex.size
+        };
+        console.log('[MethodCallResolver] Summary:', summary);
+        return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
+    }
+    /**
+     * Строит индекс классов и их методов
+     */
+    async buildClassMethodIndex(graph) {
+        const index = new Map();
+        const startTime = Date.now();
+        let classCount = 0;
+        for await (const classNode of graph.queryNodes({ nodeType: 'CLASS' })) {
+            classCount++;
+            if (classCount % 50 === 0) {
+                console.log(`[MethodCallResolver] Indexing classes: ${classCount}...`);
+            }
+            const className = classNode.name;
+            if (!className)
+                continue;
+            const classEntry = {
+                classNode,
+                methods: new Map()
+            };
+            const containsEdges = await graph.getOutgoingEdges(classNode.id, ['CONTAINS']);
+            for (const edge of containsEdges) {
+                const childNode = await graph.getNode(edge.dst);
+                if (childNode && (childNode.type === 'METHOD' || childNode.type === 'FUNCTION')) {
+                    if (childNode.name) {
+                        classEntry.methods.set(childNode.name, childNode);
+                    }
+                }
+            }
+            index.set(className, classEntry);
+            // Также индексируем по файлу для локального резолвинга
+            const fileKey = `${classNode.file}:${className}`;
+            index.set(fileKey, classEntry);
+        }
+        const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(`[MethodCallResolver] Indexed ${index.size} class entries in ${totalTime}s`);
+        return index;
+    }
+    /**
+     * Строит индекс переменных и их типов (из INSTANCE_OF рёбер)
+     */
+    async buildVariableTypeIndex(graph) {
+        const startTime = Date.now();
+        const index = new Map();
+        for await (const classNode of graph.queryNodes({ nodeType: 'CLASS' })) {
+            if (!classNode.name)
+                continue;
+            const incomingEdges = await graph.getIncomingEdges(classNode.id, ['INSTANCE_OF']);
+            for (const edge of incomingEdges) {
+                index.set(edge.src.toString(), classNode.name);
+            }
+        }
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(`[MethodCallResolver] Built variable type index: ${index.size} entries in ${elapsed}s`);
+        return index;
+    }
+    /**
+     * Пытается найти определение метода
+     */
+    async resolveMethodCall(methodCall, classMethodIndex, variableTypes, graph) {
+        const { object, method, file } = methodCall;
+        if (!object || !method)
+            return null;
+        // 1. Проверяем если object - это имя класса напрямую (статический вызов)
+        if (classMethodIndex.has(object)) {
+            const classEntry = classMethodIndex.get(object);
+            if (classEntry.methods.has(method)) {
+                return classEntry.methods.get(method);
+            }
+        }
+        // 2. Проверяем локальный класс в том же файле
+        const localKey = `${file}:${object}`;
+        if (classMethodIndex.has(localKey)) {
+            const classEntry = classMethodIndex.get(localKey);
+            if (classEntry.methods.has(method)) {
+                return classEntry.methods.get(method);
+            }
+        }
+        // 3. Проверяем если object - это "this" (ссылка на текущий класс)
+        if (object === 'this') {
+            if (!this._containingClassCache)
+                this._containingClassCache = new Map();
+            let containingClass = this._containingClassCache.get(methodCall.id);
+            if (containingClass === undefined) {
+                containingClass = await this.findContainingClass(methodCall, graph);
+                this._containingClassCache.set(methodCall.id, containingClass);
+            }
+            if (containingClass && classMethodIndex.has(containingClass.name)) {
+                const classEntry = classMethodIndex.get(containingClass.name);
+                if (classEntry.methods.has(method)) {
+                    return classEntry.methods.get(method);
+                }
+            }
+        }
+        // 4. Используем variableTypes индекс
+        for (const [, className] of variableTypes.entries()) {
+            if (className && classMethodIndex.has(className)) {
+                const classEntry = classMethodIndex.get(className);
+                if (classEntry.methods.has(method)) {
+                    return classEntry.methods.get(method);
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Находит класс, содержащий данный method call
+     */
+    async findContainingClass(methodCall, graph) {
+        const incomingEdges = await graph.getIncomingEdges(methodCall.id, ['CONTAINS']);
+        for (const edge of incomingEdges) {
+            const parentNode = await graph.getNode(edge.src);
+            if (!parentNode)
+                continue;
+            if (parentNode.type === 'CLASS') {
+                return parentNode;
+            }
+            const found = await this.findContainingClassRecursive(parentNode, graph, new Set());
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    async findContainingClassRecursive(node, graph, visited) {
+        if (visited.has(node.id.toString()))
+            return null;
+        visited.add(node.id.toString());
+        const incomingEdges = await graph.getIncomingEdges(node.id, ['CONTAINS']);
+        for (const edge of incomingEdges) {
+            const parentNode = await graph.getNode(edge.src);
+            if (!parentNode)
+                continue;
+            if (parentNode.type === 'CLASS') {
+                return parentNode;
+            }
+            const found = await this.findContainingClassRecursive(parentNode, graph, visited);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    /**
+     * Проверяет является ли метод внешним (console, Array, Promise, etc.)
+     */
+    isExternalMethod(object, method) {
+        const externalObjects = new Set([
+            'console', 'Math', 'JSON', 'Object', 'Array', 'String', 'Number',
+            'Boolean', 'Date', 'RegExp', 'Error', 'Promise', 'Set', 'Map',
+            'WeakSet', 'WeakMap', 'Symbol', 'Proxy', 'Reflect', 'Intl',
+            'process', 'global', 'window', 'document', 'Buffer',
+            'fs', 'path', 'http', 'https', 'crypto', 'os', 'url', 'util'
+        ]);
+        return externalObjects.has(object);
+    }
+}

package/dist/plugins/enrichment/MountPointResolver.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MountPointResolver - ENRICHMENT plugin for resolving mount points
+ *
+ * Updates ENDPOINT nodes by adding fullPath based on MOUNT_POINT prefixes.
+ *
+ * Graph traversal:
+ * MOUNT_POINT --MOUNTS--> MODULE --EXPOSES--> ENDPOINT
+ *
+ * Updates:
+ * endpoint.fullPath = mountPoint.prefix + endpoint.localPath
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginMetadata, PluginContext, PluginResult } from '@grafema/types';
+export declare class MountPointResolver extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Recursively resolve mount point and all nested mount points
+     */
+    private resolveMountPoint;
+    /**
+     * Helper method for finding edges by criteria
+     */
+    private findEdges;
+}
+//# sourceMappingURL=MountPointResolver.d.ts.map

package/dist/plugins/enrichment/MountPointResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MountPointResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/MountPointResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAuBhG,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA6F5D;;OAEG;YACW,iBAAiB;IAsF/B;;OAEG;YACW,SAAS;CA2BxB"}

package/dist/plugins/enrichment/MountPointResolver.js

@@ -0,0 +1,189 @@
+/**
+ * MountPointResolver - ENRICHMENT plugin for resolving mount points
+ *
+ * Updates ENDPOINT nodes by adding fullPath based on MOUNT_POINT prefixes.
+ *
+ * Graph traversal:
+ * MOUNT_POINT --MOUNTS--> MODULE --EXPOSES--> ENDPOINT
+ *
+ * Updates:
+ * endpoint.fullPath = mountPoint.prefix + endpoint.localPath
+ */
+import { Plugin } from '../Plugin.js';
+import { createSuccessResult, createErrorResult } from '@grafema/types';
+export class MountPointResolver extends Plugin {
+    get metadata() {
+        return {
+            name: 'MountPointResolver',
+            phase: 'ENRICHMENT',
+            priority: 90, // High priority - one of first enrichment plugins
+            creates: {
+                nodes: [], // Doesn't create new nodes
+                edges: [] // Doesn't create new edges
+            },
+            dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
+        };
+    }
+    async execute(context) {
+        try {
+            const { graph } = context;
+            let endpointsUpdated = 0;
+            let mountPointsProcessed = 0;
+            // Find all MOUNT_POINT nodes
+            const allNodes = await graph.getAllNodes();
+            const mountPoints = allNodes.filter(node => node.type === 'MOUNT_POINT');
+            console.log(`[MountPointResolver] Found ${mountPoints.length} mount points`);
+            // For each top-level mount point (from app.use in index.js)
+            // apply recursive resolver
+            const processedMountPoints = new Set();
+            for (const mountPoint of mountPoints) {
+                if (!processedMountPoints.has(mountPoint.id)) {
+                    const updated = await this.resolveMountPoint(graph, mountPoint, '', processedMountPoints);
+                    endpointsUpdated += updated;
+                    mountPointsProcessed++;
+                }
+            }
+            // Fallback: process mount points without recursion (old logic for compatibility)
+            for (const mountPoint of mountPoints) {
+                if (processedMountPoints.has(mountPoint.id))
+                    continue;
+                // Find MOUNT_POINT --MOUNTS--> MODULE edge
+                const mountsEdges = await this.findEdges(graph, {
+                    type: 'MOUNTS',
+                    src: mountPoint.id
+                });
+                for (const mountsEdge of mountsEdges) {
+                    const targetModuleId = mountsEdge.dst;
+                    // Find MODULE --EXPOSES--> ENDPOINT edges
+                    const exposesEdges = await this.findEdges(graph, {
+                        type: 'EXPOSES',
+                        src: targetModuleId
+                    });
+                    for (const exposesEdge of exposesEdges) {
+                        const endpointId = exposesEdge.dst;
+                        const endpoint = await graph.getNode(endpointId);
+                        if (endpoint && endpoint.type === 'ENDPOINT') {
+                            // Support multiple mount points for one endpoint
+                            // Store all prefixes and fullPaths in arrays
+                            const mountPrefixes = endpoint.mountPrefixes || [];
+                            const fullPaths = endpoint.fullPaths || [];
+                            const prefix = mountPoint.prefix;
+                            const fullPath = prefix + (endpoint.localPath || endpoint.path || '');
+                            // Only add if not already added (avoid duplicates)
+                            if (!mountPrefixes.includes(prefix)) {
+                                mountPrefixes.push(prefix);
+                                fullPaths.push(fullPath);
+                            }
+                            // Update endpoint node
+                            const updatedEndpoint = {
+                                ...endpoint,
+                                mountPrefixes,
+                                fullPaths,
+                                mountPrefix: endpoint.mountPrefix || prefix,
+                                fullPath: endpoint.fullPath || fullPath
+                            };
+                            await graph.addNode(updatedEndpoint);
+                            endpointsUpdated++;
+                        }
+                    }
+                }
+                mountPointsProcessed++;
+            }
+            console.log(`[MountPointResolver] Updated ${endpointsUpdated} endpoints from ${mountPointsProcessed} mount points`);
+            return createSuccessResult({ nodes: 0, edges: 0 }, { endpointsUpdated, mountPointsProcessed });
+        }
+        catch (error) {
+            console.error(`[MountPointResolver] Error:`, error);
+            return createErrorResult(error);
+        }
+    }
+    /**
+     * Recursively resolve mount point and all nested mount points
+     */
+    async resolveMountPoint(graph, mountPoint, parentPrefix, processedMountPoints) {
+        let endpointsUpdated = 0;
+        // Mark as processed
+        processedMountPoints.add(mountPoint.id);
+        // Calculate full prefix (parent + current)
+        const fullPrefix = parentPrefix + mountPoint.prefix;
+        // Find MOUNT_POINT --MOUNTS--> MODULE edge
+        const mountsEdges = await this.findEdges(graph, {
+            type: 'MOUNTS',
+            src: mountPoint.id
+        });
+        for (const mountsEdge of mountsEdges) {
+            const targetModuleId = mountsEdge.dst;
+            // 1. Process ENDPOINT in this module
+            const exposesEdges = await this.findEdges(graph, {
+                type: 'EXPOSES',
+                src: targetModuleId
+            });
+            for (const exposesEdge of exposesEdges) {
+                const endpointId = exposesEdge.dst;
+                const endpoint = await graph.getNode(endpointId);
+                if (endpoint && endpoint.type === 'ENDPOINT') {
+                    // Support multiple mount points
+                    const mountPrefixes = endpoint.mountPrefixes || [];
+                    const fullPaths = endpoint.fullPaths || [];
+                    const fullPath = fullPrefix + (endpoint.localPath || endpoint.path || '');
+                    // Only add if not already added
+                    if (!mountPrefixes.includes(fullPrefix)) {
+                        mountPrefixes.push(fullPrefix);
+                        fullPaths.push(fullPath);
+                    }
+                    // Update endpoint node with new data
+                    const updatedEndpoint = {
+                        ...endpoint,
+                        mountPrefixes,
+                        fullPaths,
+                        mountPrefix: endpoint.mountPrefix || fullPrefix,
+                        fullPath: endpoint.fullPath || fullPath
+                    };
+                    await graph.addNode(updatedEndpoint);
+                    endpointsUpdated++;
+                }
+            }
+            // 2. Recursively process nested MOUNT_POINT in this module
+            const definesEdges = await this.findEdges(graph, {
+                type: 'DEFINES',
+                src: targetModuleId
+            });
+            for (const definesEdge of definesEdges) {
+                const nestedMountPointId = definesEdge.dst;
+                const nestedMountPoint = await graph.getNode(nestedMountPointId);
+                if (nestedMountPoint && nestedMountPoint.type === 'MOUNT_POINT' &&
+                    !processedMountPoints.has(nestedMountPointId)) {
+                    // Recursively process nested mount point
+                    endpointsUpdated += await this.resolveMountPoint(graph, nestedMountPoint, fullPrefix, // Pass accumulated prefix
+                    processedMountPoints);
+                }
+            }
+        }
+        return endpointsUpdated;
+    }
+    /**
+     * Helper method for finding edges by criteria
+     */
+    async findEdges(graph, criteria) {
+        const result = [];
+        // Get all edges using RFDBServerBackend API
+        if (!graph.getAllEdges) {
+            return result;
+        }
+        const allEdges = await graph.getAllEdges();
+        for (const edge of allEdges) {
+            let matches = true;
+            for (const [key, value] of Object.entries(criteria)) {
+                const edgeRecord = edge;
+                if (edgeRecord[key] !== value) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) {
+                result.push(edge);
+            }
+        }
+        return result;
+    }
+}

package/dist/plugins/enrichment/PrefixEvaluator.d.ts

@@ -0,0 +1,89 @@
+/**
+ * PrefixEvaluator - ENRICHMENT plugin for evaluating dynamic prefixes
+ *
+ * Resolves placeholders in MOUNT_POINT.prefix:
+ * - ${variable} → finds VariableDeclaration in the same module
+ * - ${binary} → recursively resolves BinaryExpression
+ * - ${template} → resolves TemplateLiteral with variables
+ * - ${member} → finds object and its property
+ * - ${call} → not supported yet (requires runtime eval)
+ * - ${conditional} → not supported yet (requires runtime eval)
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginMetadata, PluginContext, PluginResult } from '../Plugin.js';
+import type { ParseResult } from '@babel/parser';
+import type { File, Node, MemberExpression, ObjectExpression, ArrayExpression } from '@babel/types';
+import type { NodeRecord } from '@grafema/types';
+interface ModuleNode {
+    id: string;
+    type: 'MODULE';
+    name: string;
+    file: string;
+    line: number;
+}
+interface Edge {
+    type: string;
+    fromId: string;
+    dst: string;
+    [key: string]: unknown;
+}
+interface EdgeCriteria {
+    type?: string;
+    dst?: string;
+    [key: string]: unknown;
+}
+interface Graph {
+    nodes: Map<string, NodeRecord> | {
+        get(id: string): NodeRecord | undefined;
+        values(): Iterable<NodeRecord>;
+    };
+    edges: Map<string, Edge> | {
+        values(): Iterable<Edge>;
+    };
+}
+export declare class PrefixEvaluator extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Evaluate prefix based on placeholder type
+     */
+    evaluatePrefix(placeholder: string, line: number, ast: ParseResult<File>, _module: ModuleNode): Promise<string | null>;
+    /**
+     * Resolve ${variable} - find VariableDeclaration
+     */
+    evaluateVariable(line: number, ast: ParseResult<File>): string | null;
+    /**
+     * Resolve ${binary} - BinaryExpression (a + b)
+     */
+    evaluateBinary(line: number, ast: ParseResult<File>): string | null;
+    /**
+     * Recursively resolve arbitrary expression
+     */
+    resolveExpression(node: Node, ast: ParseResult<File>): string | null;
+    /**
+     * Resolve ${template} - TemplateLiteral with variables
+     */
+    evaluateTemplate(line: number, ast: ParseResult<File>): string | null;
+    /**
+     * Resolve ${member} - MemberExpression (config.apiPrefix)
+     */
+    evaluateMember(line: number, ast: ParseResult<File>): string | null;
+    /**
+     * Recursively resolve MemberExpression
+     */
+    resolveMemberExpression(node: MemberExpression, ast: ParseResult<File>): string | null;
+    /**
+     * Evaluate ObjectExpression to plain JS object
+     */
+    evaluateObjectExpression(node: ObjectExpression): Record<string, unknown>;
+    /**
+     * Evaluate ArrayExpression to plain JS array
+     */
+    evaluateArrayExpression(node: ArrayExpression): string[];
+    /**
+     * Helper method for finding edges
+     */
+    findEdges(graph: Graph, criteria: EdgeCriteria): Edge[];
+}
+export {};
+//# sourceMappingURL=PrefixEvaluator.d.ts.map

package/dist/plugins/enrichment/PrefixEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrefixEvaluator.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/PrefixEvaluator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEhF,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,eAAe,CAAC;AAE/D,OAAO,KAAK,EACV,IAAI,EACJ,IAAI,EAEJ,gBAAgB,EAKhB,gBAAgB,EAEhB,eAAe,EAGhB,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAmBjD,UAAU,UAAU;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,IAAI;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,UAAU,YAAY;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,UAAU,KAAK;IACb,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG;QAAE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;QAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAA;KAAE,CAAC;IAC7G,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC;CACzD;AAED,qBAAa,eAAgB,SAAQ,MAAM;IACzC,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAyF5D;;OAEG;IACG,cAAc,CAClB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,EACtB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAczB;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI;IA0CrE;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI;IAsCnE;;OAEG;IACH,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI;IAgCpE;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI;IA6CrE;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI;IA4BnE;;OAEG;IACH,uBAAuB,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI;IAgEtF;;OAEG;IACH,wBAAwB,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAkBzE;;OAEG;IACH,uBAAuB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE;IAUxD;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,EAAE;CAkBxD"}