@grafema/core 0.1.0-alpha.1

package/dist/plugins/indexing/IncrementalModuleIndexer.js

@@ -0,0 +1,238 @@
+/**
+ * IncrementalModuleIndexer - индексирует модули по требованию через очередь
+ * Стартует с entry файла, затем анализирует импорты и добавляет новые файлы в очередь
+ */
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname, resolve, extname, relative } from 'path';
+import { createHash } from 'crypto';
+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 IncrementalModuleIndexer extends Plugin {
+    get metadata() {
+        return {
+            name: 'IncrementalModuleIndexer',
+            phase: 'INDEXING',
+            priority: 90,
+            creates: {
+                nodes: ['MODULE'],
+                edges: ['CONTAINS', 'IMPORTS_FROM']
+            }
+        };
+    }
+    /**
+     * Resolve module path from import
+     */
+    resolveModule(fromFile, importPath, projectRoot) {
+        // Absolute path (starts with /)
+        if (importPath.startsWith('/')) {
+            const fullPath = join(projectRoot, importPath);
+            return this.tryResolve(fullPath);
+        }
+        // Relative path (starts with . or ..)
+        if (importPath.startsWith('.')) {
+            const fromDir = dirname(fromFile);
+            const resolved = resolve(fromDir, importPath);
+            return this.tryResolve(resolved);
+        }
+        // Bare specifier (could be alias inside monorepo, e.g. pkg/svc/...)
+        // Heuristic: if it contains a slash and not "node_modules" treat as project-root relative
+        if (importPath.includes('/') && !importPath.startsWith('node:')) {
+            const candidate = join(projectRoot, importPath);
+            const resolved = this.tryResolve(candidate);
+            if (resolved)
+                return resolved;
+        }
+        // node builtin or unresolved external - skip for incremental indexing
+        return null;
+    }
+    /**
+     * Try to resolve file with different extensions
+     */
+    tryResolve(basePath) {
+        if (existsSync(basePath)) {
+            if (!extname(basePath)) {
+                // Try as directory with index.js
+                const indexPath = join(basePath, 'index.js');
+                if (existsSync(indexPath))
+                    return indexPath;
+                // Try adding .js
+                if (existsSync(basePath + '.js'))
+                    return basePath + '.js';
+            }
+            return basePath;
+        }
+        // Try with .js extension
+        if (existsSync(basePath + '.js'))
+            return basePath + '.js';
+        // Try as directory
+        const indexPath = join(basePath, 'index.js');
+        if (existsSync(indexPath))
+            return indexPath;
+        return null;
+    }
+    /**
+     * Calculate file hash
+     */
+    calculateFileHash(filePath) {
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            return createHash('sha256').update(content).digest('hex');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Parse imports from file
+     */
+    parseImports(filePath, projectRoot) {
+        try {
+            const code = readFileSync(filePath, 'utf-8');
+            const ast = parse(code, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript'],
+                errorRecovery: true
+            });
+            const imports = [];
+            traverse(ast, {
+                ImportDeclaration: (path) => {
+                    const importPath = path.node.source.value;
+                    const resolved = this.resolveModule(filePath, importPath, projectRoot);
+                    if (resolved) {
+                        imports.push(resolved);
+                    }
+                },
+                CallExpression: (path) => {
+                    if (path.node.callee.name === 'require' &&
+                        path.node.arguments[0]?.type === 'StringLiteral') {
+                        const importPath = path.node.arguments[0].value;
+                        const resolved = this.resolveModule(filePath, importPath, projectRoot);
+                        if (resolved) {
+                            imports.push(resolved);
+                        }
+                    }
+                }
+            });
+            return imports;
+        }
+        catch (err) {
+            console.error(`   ⚠️  Failed to parse imports from ${relative(projectRoot, filePath)}: ${err.message}`);
+            return [];
+        }
+    }
+    async execute(context) {
+        try {
+            const { manifest, graph } = context;
+            // Cast manifest to expected shape
+            const typedManifest = manifest;
+            const { projectPath, service, entryFile } = typedManifest;
+            if (!entryFile) {
+                throw new Error('IncrementalModuleIndexer requires entryFile in manifest');
+            }
+            const queue = [entryFile];
+            const processed = new Set();
+            const pendingImports = []; // Store imports to create edges after all nodes exist
+            let nodesCreated = 0;
+            let edgesCreated = 0;
+            let totalImportsParsed = 0;
+            let unresolvedImports = 0;
+            console.log(`📦 Starting incremental indexing from: ${relative(projectPath, entryFile)}\n`);
+            while (queue.length > 0) {
+                const file = queue.shift();
+                if (processed.has(file))
+                    continue;
+                processed.add(file);
+                // Create MODULE node
+                const fileHash = this.calculateFileHash(file);
+                const relativePath = relative(projectPath, file);
+                const moduleNode = {
+                    id: `${file}:MODULE:${file}:0`,
+                    type: 'MODULE',
+                    name: relativePath,
+                    file: file,
+                    contentHash: fileHash
+                };
+                await graph.addNode(moduleNode);
+                nodesCreated++;
+                // Link to SERVICE
+                await graph.addEdge({
+                    src: service.id,
+                    dst: moduleNode.id,
+                    type: 'CONTAINS',
+                    version: 'main'
+                });
+                edgesCreated++;
+                // Parse imports and add to queue
+                const imports = this.parseImports(file, projectPath);
+                totalImportsParsed += imports.length;
+                for (const importFile of imports) {
+                    // Store for later edge creation
+                    pendingImports.push({
+                        src: moduleNode.id,
+                        dst: `${importFile}:MODULE:${importFile}:0`
+                    });
+                    if (!processed.has(importFile)) {
+                        queue.push(importFile);
+                    }
+                }
+                // Simple unresolved import heuristic: look for raw import strings we failed to resolve
+                // Re-parse quickly and count any that did not get resolved (debug aid)
+                try {
+                    const code = readFileSync(file, 'utf-8');
+                    const ast = parse(code, {
+                        sourceType: 'module',
+                        plugins: ['jsx', 'typescript'],
+                        errorRecovery: true
+                    });
+                    traverse(ast, {
+                        ImportDeclaration: (p) => {
+                            const ip = p.node.source.value;
+                            const isResolved = this.resolveModule(file, ip, projectPath);
+                            if (!isResolved)
+                                unresolvedImports++;
+                        },
+                        CallExpression: (p) => {
+                            if (p.node.callee.name === 'require' &&
+                                p.node.arguments[0]?.type === 'StringLiteral') {
+                                const ip = p.node.arguments[0].value;
+                                const isResolved = this.resolveModule(file, ip, projectPath);
+                                if (!isResolved)
+                                    unresolvedImports++;
+                            }
+                        }
+                    });
+                }
+                catch {
+                    // Ignore parse errors for unresolved count
+                }
+                if (processed.size % 10 === 0) {
+                    process.stdout.write(`\r   📦 Indexed ${processed.size} modules (${queue.length} in queue)...`);
+                }
+            }
+            console.log(`\r   ✅ Indexed ${processed.size} modules\n`);
+            console.log(`   📥 Parsed ${totalImportsParsed} import specifiers (unresolved: ${unresolvedImports})`);
+            console.log(`   🔗 Pending IMPORTS edges to create: ${pendingImports.length}\n`);
+            console.log(`   📊 Creating IMPORTS edges...\n`);
+            // Now create all IMPORTS edges after all MODULE nodes exist
+            for (const { src, dst } of pendingImports) {
+                await graph.addEdge({
+                    src,
+                    dst,
+                    type: 'IMPORTS',
+                    version: 'main'
+                });
+                edgesCreated++;
+            }
+            console.log(`   📊 Created ${nodesCreated} MODULE nodes and ${edgesCreated} edges`);
+            console.log(`   📈 IMPORTS edges created: ${pendingImports.length}\n`);
+            return createSuccessResult({ nodes: nodesCreated, edges: edgesCreated }, { filesScanned: processed.size });
+        }
+        catch (error) {
+            console.error(`[IncrementalModuleIndexer] Error:`, error);
+            return createErrorResult(error);
+        }
+    }
+}

package/dist/plugins/indexing/JSModuleIndexer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * JSModuleIndexer - плагин для индексации JavaScript/TypeScript модулей
+ * Строит дерево зависимостей от entrypoint через DFS (как в file2host.js)
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class JSModuleIndexer extends Plugin {
+    private walker;
+    private cache;
+    private testPatterns;
+    private markTestFiles;
+    constructor();
+    /**
+     * Check if file is a test file based on path patterns
+     */
+    private isTestFile;
+    get metadata(): PluginMetadata;
+    private calculateFileHash;
+    /**
+     * Парсит файл и извлекает все зависимости:
+     * - require('...')
+     * - import ... from '...'
+     * - export * from '...'
+     * - export { ... } from '...'
+     */
+    private processFile;
+    /**
+     * Резолвит путь к модулю (добавляет .js/.ts если нужно)
+     */
+    private resolveModulePath;
+    execute(context: PluginContext): Promise<PluginResult>;
+}
+//# sourceMappingURL=JSModuleIndexer.d.ts.map

package/dist/plugins/indexing/JSModuleIndexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JSModuleIndexer.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/JSModuleIndexer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA2DhF,qBAAa,eAAgB,SAAQ,MAAM;IACzC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,YAAY,CAAW;IAC/B,OAAO,CAAC,aAAa,CAAU;;IAU/B;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAED,OAAO,CAAC,iBAAiB;IASzB;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAuEnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAiBnB,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAoK7D"}

package/dist/plugins/indexing/JSModuleIndexer.js

@@ -0,0 +1,299 @@
+/**
+ * JSModuleIndexer - плагин для индексации JavaScript/TypeScript модулей
+ * Строит дерево зависимостей от entrypoint через DFS (как в file2host.js)
+ */
+import { readFileSync, existsSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { createHash } from 'crypto';
+import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+// @ts-expect-error - no type declarations for node-source-walk
+import Walker from 'node-source-walk';
+import { NodeFactory } from '../../core/NodeFactory.js';
+// Test file patterns (can be overridden in config)
+const DEFAULT_TEST_PATTERNS = [
+    /[/\\]test[/\\]/, // /test/
+    /[/\\]tests[/\\]/, // /tests/
+    /[/\\]__tests__[/\\]/, // /__tests__/
+    /[/\\]spec[/\\]/, // /spec/
+    /\.test\.[jt]sx?$/, // .test.js, .test.ts, .test.jsx, .test.tsx
+    /\.spec\.[jt]sx?$/, // .spec.js, .spec.ts, .spec.jsx, .spec.tsx
+    /_test\.[jt]sx?$/, // _test.js (Go-style)
+    /[/\\]fixtures?[/\\]/, // /fixture/ or /fixtures/
+];
+export class JSModuleIndexer extends Plugin {
+    walker;
+    cache;
+    testPatterns;
+    markTestFiles;
+    constructor() {
+        super();
+        this.walker = new Walker();
+        this.cache = new Map(); // Кеш зависимостей файла
+        this.testPatterns = DEFAULT_TEST_PATTERNS;
+        this.markTestFiles = true; // Default: enabled
+    }
+    /**
+     * Check if file is a test file based on path patterns
+     */
+    isTestFile(filePath) {
+        if (!this.markTestFiles)
+            return false;
+        return this.testPatterns.some(pattern => pattern.test(filePath));
+    }
+    get metadata() {
+        return {
+            name: 'JSModuleIndexer',
+            phase: 'INDEXING',
+            priority: 90,
+            creates: {
+                nodes: ['MODULE'],
+                edges: ['CONTAINS', 'DEPENDS_ON']
+            }
+        };
+    }
+    calculateFileHash(filePath) {
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            return createHash('sha256').update(content).digest('hex');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Парсит файл и извлекает все зависимости:
+     * - require('...')
+     * - import ... from '...'
+     * - export * from '...'
+     * - export { ... } from '...'
+     */
+    processFile(filePath, _projectPath) {
+        if (this.cache.has(filePath)) {
+            return this.cache.get(filePath);
+        }
+        const result = [];
+        let content;
+        let ast;
+        try {
+            if (!existsSync(filePath)) {
+                this.cache.set(filePath, new Error('ENOENT'));
+                return new Error('ENOENT');
+            }
+            content = readFileSync(filePath, 'utf-8');
+            ast = this.walker.parse(content);
+        }
+        catch (e) {
+            if (filePath.endsWith('.json')) {
+                this.cache.set(filePath, []);
+                return [];
+            }
+            this.cache.set(filePath, new Error(e.message));
+            return new Error(e.message);
+        }
+        this.walker.traverse(ast, (node) => {
+            const isRequire = node.type === 'CallExpression' && node.callee?.name === 'require';
+            const isImport = node.type === 'ImportDeclaration';
+            // export * from './module.js'
+            const isExportAll = node.type === 'ExportAllDeclaration';
+            // export { foo } from './module.js'
+            const isExportNamed = node.type === 'ExportNamedDeclaration' && node.source;
+            if (!isRequire && !isImport && !isExportAll && !isExportNamed) {
+                return;
+            }
+            let source;
+            if (isImport || isExportAll || isExportNamed) {
+                source = node.source;
+            }
+            else {
+                source = node.arguments?.[0];
+            }
+            if (!source || !['Identifier', 'StringLiteral'].includes(source.type)) {
+                return;
+            }
+            const name = source.value || source.name;
+            if (!name)
+                return;
+            // Игнорируем встроенные модули
+            if (name.startsWith('internal/')) {
+                return;
+            }
+            // Резолвим относительные пути
+            if (name.startsWith('.') || name.startsWith('/')) {
+                const dir = dirname(filePath);
+                const resolved = resolve(dir, name);
+                result.push(resolved);
+            }
+            else {
+                // npm пакет - помечаем специально
+                result.push(`package::${name}`);
+            }
+        });
+        this.cache.set(filePath, result);
+        return result;
+    }
+    /**
+     * Резолвит путь к модулю (добавляет .js/.ts если нужно)
+     */
+    resolveModulePath(path) {
+        if (existsSync(path))
+            return path;
+        // Try JavaScript extensions
+        if (existsSync(path + '.js'))
+            return path + '.js';
+        if (existsSync(path + '.mjs'))
+            return path + '.mjs';
+        if (existsSync(path + '.jsx'))
+            return path + '.jsx';
+        // Try TypeScript extensions
+        if (existsSync(path + '.ts'))
+            return path + '.ts';
+        if (existsSync(path + '.tsx'))
+            return path + '.tsx';
+        // Try index files
+        if (existsSync(join(path, 'index.js')))
+            return join(path, 'index.js');
+        if (existsSync(join(path, 'index.ts')))
+            return join(path, 'index.ts');
+        if (existsSync(join(path, 'index.mjs')))
+            return join(path, 'index.mjs');
+        if (existsSync(join(path, 'index.tsx')))
+            return join(path, 'index.tsx');
+        return path;
+    }
+    async execute(context) {
+        try {
+            const { graph, onProgress, config } = context;
+            const manifest = context.manifest;
+            const projectPath = manifest?.projectPath ?? '';
+            const service = manifest?.service ?? { id: '', name: '', path: '' };
+            // Check config for test file marking
+            if (config?.analysis?.tests?.markTestFiles === false) {
+                this.markTestFiles = false;
+            }
+            const entrypoint = service.path;
+            // const pkgPath = join(projectPath, 'pkg');
+            // Резолвим entrypoint относительно projectPath
+            const absoluteEntrypoint = entrypoint.startsWith('/')
+                ? entrypoint
+                : join(projectPath, entrypoint);
+            console.log(`[JSModuleIndexer] Building dependency tree from ${service.name}`);
+            // DFS через стек (как в file2host.js)
+            const visited = new Set();
+            const stack = [{ file: absoluteEntrypoint, depth: 0 }];
+            visited.add(absoluteEntrypoint);
+            let nodesCreated = 0;
+            let edgesCreated = 0;
+            // const skipped = 0;
+            const MAX_MODULES = 2000; // Safety limit per service
+            const MAX_DEPTH = 50; // Max dependency depth
+            // Collect DEPENDS_ON edges to create after all nodes exist
+            const pendingDependsOnEdges = [];
+            let lastProgressReport = 0;
+            const PROGRESS_INTERVAL = 10; // Report every N files
+            while (stack.length > 0 && visited.size < MAX_MODULES) {
+                const { file: currentFile, depth } = stack.pop();
+                // Report progress every PROGRESS_INTERVAL files
+                if (onProgress && visited.size - lastProgressReport >= PROGRESS_INTERVAL) {
+                    onProgress({
+                        phase: 'indexing',
+                        currentPlugin: 'JSModuleIndexer',
+                        message: `${service.name}: indexed ${visited.size} files`,
+                        processedFiles: visited.size,
+                        currentService: service.name
+                    });
+                    lastProgressReport = visited.size;
+                }
+                console.log(`[JSModuleIndexer] Processing: ${currentFile.replace(projectPath, '')} (depth ${depth})`);
+                if (depth > MAX_DEPTH) {
+                    console.log(`[JSModuleIndexer] Max depth ${MAX_DEPTH} reached at ${currentFile}`);
+                    continue;
+                }
+                // Парсим зависимости
+                const deps = this.processFile(currentFile, projectPath);
+                console.log(`[JSModuleIndexer] Found ${deps instanceof Error ? 0 : deps.length} dependencies in ${currentFile.replace(projectPath, '')}`);
+                if (deps instanceof Error) {
+                    if (!deps.message.includes('ENOENT')) {
+                        console.log(`[JSModuleIndexer] Error parsing ${currentFile}: ${deps.message}`);
+                    }
+                    continue;
+                }
+                // Создаём MODULE ноду для текущего файла
+                const fileHash = this.calculateFileHash(currentFile);
+                const moduleId = `MODULE:${fileHash}`; // StableID-based for deduplication
+                // Используем NodeFactory для создания MODULE ноды
+                // ВСЕГДА создаём ноду в графе (граф может быть пустой после force)
+                const isTest = this.isTestFile(currentFile);
+                const moduleNode = NodeFactory.createModule(currentFile, projectPath, {
+                    contentHash: fileHash ?? undefined,
+                    isTest
+                });
+                console.log(`[JSModuleIndexer] Creating MODULE node: ${moduleNode.id}`);
+                await graph.addNode(moduleNode);
+                nodesCreated++;
+                // Always create SERVICE -> CONTAINS -> MODULE edge (even if module exists)
+                await graph.addEdge({
+                    src: service.id,
+                    dst: moduleId,
+                    type: 'CONTAINS',
+                    version: 'main'
+                });
+                // Обрабатываем зависимости
+                for (const dep of deps) {
+                    if (dep.startsWith('package::')) {
+                        // npm пакет - игнорируем пока
+                        console.log(`[JSModuleIndexer]   Skipping npm package: ${dep}`);
+                        continue;
+                    }
+                    const resolvedDep = this.resolveModulePath(dep);
+                    console.log(`[JSModuleIndexer]   Resolved: ${dep} -> ${resolvedDep.replace(projectPath, '')}`);
+                    // Добавляем в стек если ещё не посещали
+                    if (!visited.has(resolvedDep)) {
+                        visited.add(resolvedDep);
+                        stack.push({ file: resolvedDep, depth: depth + 1 });
+                        console.log(`[JSModuleIndexer]   Added to stack (depth ${depth + 1})`);
+                    }
+                    else {
+                        console.log(`[JSModuleIndexer]   Already visited, skipping`);
+                    }
+                    // Queue DEPENDS_ON edges for later (after all nodes exist)
+                    const depHash = this.calculateFileHash(resolvedDep);
+                    const depModuleId = `MODULE:${depHash}`;
+                    pendingDependsOnEdges.push({
+                        src: moduleId,
+                        dst: depModuleId,
+                        type: 'DEPENDS_ON',
+                        version: 'main'
+                    });
+                }
+            }
+            // Create all DEPENDS_ON edges in one batch (faster than loop)
+            if (pendingDependsOnEdges.length > 0) {
+                await graph.addEdges(pendingDependsOnEdges);
+                edgesCreated += pendingDependsOnEdges.length;
+            }
+            // Warning if hit MAX_MODULES limit
+            if (visited.size >= MAX_MODULES) {
+                console.warn(`[JSModuleIndexer] ⚠️  ${service.name} hit MAX_MODULES limit (${MAX_MODULES})!`);
+                console.warn(`[JSModuleIndexer]    This service may be pulling in too many dependencies.`);
+                console.warn(`[JSModuleIndexer]    Unprocessed files in stack: ${stack.length}`);
+            }
+            // Final progress report
+            if (onProgress) {
+                onProgress({
+                    phase: 'indexing',
+                    currentPlugin: 'JSModuleIndexer',
+                    message: `${service.name}: indexed ${visited.size} files`,
+                    totalFiles: visited.size,
+                    processedFiles: visited.size,
+                    currentService: service.name
+                });
+            }
+            console.log(`[JSModuleIndexer] ${service.name}: ${nodesCreated} modules, ${visited.size} total in tree`);
+            return createSuccessResult({ nodes: nodesCreated, edges: edgesCreated }, { totalModules: visited.size });
+        }
+        catch (error) {
+            console.error(`[JSModuleIndexer] Error:`, error);
+            return createErrorResult(error);
+        }
+    }
+}

package/dist/plugins/indexing/RustModuleIndexer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * RustModuleIndexer - plugin for indexing Rust modules
+ * Discovers .rs files in rust-engine/src/ directory
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class RustModuleIndexer extends Plugin {
+    private testPatterns;
+    constructor();
+    get metadata(): PluginMetadata;
+    /**
+     * Check if file is a test file based on path patterns
+     */
+    private isTestFile;
+    /**
+     * Recursively find all .rs files in a directory
+     */
+    private findRustFiles;
+    /**
+     * Convert file path to Rust module name
+     * src/ffi/napi_bindings.rs -> ffi::napi_bindings
+     * src/lib.rs -> crate
+     * src/ffi/mod.rs -> ffi
+     */
+    private pathToModuleName;
+    execute(context: PluginContext): Promise<PluginResult>;
+}
+//# sourceMappingURL=RustModuleIndexer.d.ts.map

package/dist/plugins/indexing/RustModuleIndexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RustModuleIndexer.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/RustModuleIndexer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAUhF,qBAAa,iBAAkB,SAAQ,MAAM;IAC3C,OAAO,CAAC,YAAY,CAAW;;IAO/B,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAED;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAclB,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAiE7D"}