@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/dist/plugins/enrichment/ValueDomainAnalyzer.js

@@ -13,37 +13,11 @@
  * - CALL -> CALLS -> METHOD (with isConditional: true for conditional calls)
  */
 import { Plugin, createSuccessResult } from '../Plugin.js';
+import { traceValues, aggregateValues, NONDETERMINISTIC_PATTERNS, NONDETERMINISTIC_OBJECTS, } from '../../queries/traceValues.js';
+// Re-export for backward compatibility
+export { NONDETERMINISTIC_PATTERNS, NONDETERMINISTIC_OBJECTS };
 export class ValueDomainAnalyzer extends Plugin {
     static MAX_DEPTH = 10; // Maximum depth for tracing
-    // Nondeterministic MemberExpression patterns
-    // object.property patterns that are external/user input
-    static NONDETERMINISTIC_PATTERNS = [
-        // Environment variables
-        { object: 'process', property: 'env' },
-        // HTTP request data (Express.js patterns)
-        { object: 'req', property: 'body' },
-        { object: 'req', property: 'query' },
-        { object: 'req', property: 'params' },
-        { object: 'req', property: 'headers' },
-        { object: 'req', property: 'cookies' },
-        { object: 'request', property: 'body' },
-        { object: 'request', property: 'query' },
-        { object: 'request', property: 'params' },
-        // Context patterns (Koa, etc.)
-        { object: 'ctx', property: 'request' },
-        { object: 'ctx', property: 'body' },
-        { object: 'ctx', property: 'query' },
-        { object: 'ctx', property: 'params' },
-    ];
-    // Nondeterministic object prefixes (any property access is nondeterministic)
-    static NONDETERMINISTIC_OBJECTS = [
-        'process.env', // process.env.ANY_VAR
-        'req.body', // req.body.userId
-        'req.query', // req.query.filter
-        'req.params', // req.params.id
-        'request.body',
-        'ctx.request',
-    ];
     get metadata() {
         return {
             name: 'ValueDomainAnalyzer',
@@ -51,15 +25,16 @@ export class ValueDomainAnalyzer extends Plugin {
             priority: 65, // After AliasTracker (60)
             creates: {
                 nodes: [],
-                edges: ['CALLS']
+                edges: ['CALLS', 'FLOWS_INTO'] // Added FLOWS_INTO (modifies existing)
             }
         };
     }
     async execute(context) {
         const { graph } = context;
+        const logger = this.log(context);
         const onProgress = context.onProgress;
         const graphTyped = graph;
-        console.log('[ValueDomainAnalyzer] Starting value domain analysis...');
+        logger.info('Starting value domain analysis');
         let callsProcessed = 0;
         let callsResolved = 0;
         let edgesCreated = 0;
@@ -74,7 +49,7 @@ export class ValueDomainAnalyzer extends Plugin {
                 computedCalls.push(callNode);
             }
         }
-        console.log(`[ValueDomainAnalyzer] Found ${computedCalls.length} computed member calls`);
+        logger.info('Found computed member calls', { count: computedCalls.length });
         // 2. For each computed call get value set
         for (const call of computedCalls) {
             callsProcessed++;
@@ -130,15 +105,20 @@ export class ValueDomainAnalyzer extends Plugin {
                 }
             }
         }
+        // 5. Resolve computed property mutations in FLOWS_INTO edges
+        logger.debug('Resolving computed property mutations');
+        const mutationStats = await this.resolveComputedMutations(graphTyped, logger);
+        logger.debug('Mutation resolution stats', mutationStats);
         const summary = {
             callsProcessed,
             callsResolved,
             edgesCreated,
             conditionalCalls,
-            partialCalls
+            partialCalls,
+            computedMutations: mutationStats
         };
-        console.log('[ValueDomainAnalyzer] Summary:', summary);
-        return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
+        logger.info('Summary', summary);
+        return createSuccessResult({ nodes: 0, edges: edgesCreated + mutationStats.resolved + mutationStats.conditional }, summary);
     }
     /**
      * Get set of possible values for a variable
@@ -167,11 +147,9 @@ export class ValueDomainAnalyzer extends Plugin {
             }
         }
         if (variables.length === 0) {
-            console.log(`[ValueDomainAnalyzer] No variable found for ${variableName} in ${file}`);
             result.hasUnknown = true;
             return result;
         }
-        console.log(`[ValueDomainAnalyzer] Found ${variables.length} variable(s) for ${variableName}`);
         // Trace ASSIGNED_FROM to LITERAL or nondeterministic sources
         const visited = new Set();
         const valueSet = new Set();
@@ -223,8 +201,7 @@ export class ValueDomainAnalyzer extends Plugin {
             for await (const s of graph.queryNodes({ nodeType: 'SCOPE' })) {
                 const scopeNode = s;
                 if (scopeNode.id === currentScopeId ||
-                    scopeNode.originalId === currentScopeId ||
-                    scopeNode.stableId === currentScopeId) {
+                    scopeNode.originalId === currentScopeId) {
                     scope = scopeNode;
                     break;
                 }
@@ -324,107 +301,63 @@ export class ValueDomainAnalyzer extends Plugin {
         }
     }
     /**
-     * Check if an EXPRESSION node represents a nondeterministic source
+     * Recursive value set tracing through ASSIGNED_FROM edges.
+     * Delegates to shared traceValues utility (REG-244).
      */
-    isNondeterministicExpression(node) {
-        const expressionType = node.expressionType || node.attrs?.expressionType;
-        if (expressionType !== 'MemberExpression') {
-            return false;
-        }
-        const object = node.object || node.attrs?.object;
-        const property = node.property || node.attrs?.property;
-        if (!object || !property) {
-            return false;
-        }
-        // Check exact patterns (object.property)
-        for (const pattern of ValueDomainAnalyzer.NONDETERMINISTIC_PATTERNS) {
-            if (object === pattern.object && property === pattern.property) {
-                return true;
-            }
-        }
-        // Check if object is a known nondeterministic prefix
-        // e.g., process.env.VAR where object is 'process.env'
-        for (const prefix of ValueDomainAnalyzer.NONDETERMINISTIC_OBJECTS) {
-            if (object === prefix || object.startsWith(prefix + '.')) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Recursive value set tracing through ASSIGNED_FROM edges
-     */
-    async traceValueSet(node, graph, visited, depth) {
-        const result = { values: [], hasUnknown: false };
-        // Cycle protection
-        if (visited.has(node.id)) {
-            return result;
-        }
-        visited.add(node.id);
-        // Depth protection
-        if (depth > ValueDomainAnalyzer.MAX_DEPTH) {
-            result.hasUnknown = true;
-            return result;
-        }
-        // Support both fields: nodeType (from getNode) and type (alias)
-        const nodeType = node.nodeType ||
-            node.type;
-        // If it's a LITERAL - add value
-        if (nodeType === 'LITERAL') {
-            const value = node.value;
-            if (value !== undefined && value !== null) {
-                result.values.push(value);
-            }
-            return result;
-        }
-        // If it's a PARAMETER or nondeterministic source
-        if (nodeType === 'PARAMETER') {
-            result.hasUnknown = true;
-            return result;
-        }
-        // If it's a CALL - consider nondeterministic (for now)
-        if (nodeType === 'CALL') {
-            result.hasUnknown = true;
-            return result;
-        }
-        // If it's an EXPRESSION - check nondeterministic patterns
-        if (nodeType === 'EXPRESSION') {
-            if (this.isNondeterministicExpression(node)) {
-                result.hasUnknown = true;
-                return result;
-            }
-        }
-        // Follow ASSIGNED_FROM and DERIVES_FROM edges
-        // DERIVES_FROM is used for template literals and other composite expressions
-        const outgoing = await graph.getOutgoingEdges(node.id);
-        // edgeType (from getOutgoingEdges) or edge_type (from other APIs)
-        const dataFlowEdges = outgoing.filter(e => {
-            const edgeType = e.edgeType ||
-                e.edge_type;
-            return edgeType === 'ASSIGNED_FROM' || edgeType === 'DERIVES_FROM';
+    async traceValueSet(node, graph, _visited, depth) {
+        // Create adapter from Graph interface to TraceValuesGraphBackend
+        const backend = {
+            getNode: async (id) => {
+                const n = await graph.getNode(id);
+                if (!n)
+                    return null;
+                return {
+                    id: n.id,
+                    type: n.type,
+                    nodeType: n.nodeType,
+                    value: n.value,
+                    file: n.file,
+                    line: n.line,
+                    expressionType: n.expressionType,
+                    object: n.object,
+                    property: n.property,
+                };
+            },
+            getOutgoingEdges: async (nodeId, edgeTypes) => {
+                const edges = await graph.getOutgoingEdges(nodeId);
+                const filtered = edgeTypes === null
+                    ? edges
+                    : edges.filter(e => edgeTypes.includes(e.type));
+                return filtered.map(e => ({
+                    src: e.src ||
+                        e.source_id || '',
+                    dst: e.dst ||
+                        e.target_id || '',
+                    type: e.type,
+                }));
+            },
+            // REG-334: getIncomingEdges required for Promise tracing
+            getIncomingEdges: async (nodeId, edgeTypes) => {
+                const edges = await graph.getIncomingEdges(nodeId);
+                const filtered = edgeTypes === null
+                    ? edges
+                    : edges.filter(e => edgeTypes.includes(e.type));
+                return filtered.map(e => ({
+                    src: e.src ||
+                        e.source_id || '',
+                    dst: e.dst ||
+                        e.target_id || '',
+                    type: e.type,
+                }));
+            },
+        };
+        // Use shared utility
+        const traced = await traceValues(backend, node.id, {
+            maxDepth: ValueDomainAnalyzer.MAX_DEPTH - depth,
+            followDerivesFrom: true,
+            detectNondeterministic: true,
         });
-        if (dataFlowEdges.length === 0) {
-            // No sources - unknown
-            result.hasUnknown = true;
-            return result;
-        }
-        // Recursively trace each source
-        for (const edge of dataFlowEdges) {
-            // dst (from getOutgoingEdges) or target_id (from other APIs)
-            const targetId = edge.dst ||
-                edge.target_id;
-            if (!targetId)
-                continue;
-            const sourceNode = await graph.getNode(targetId);
-            if (!sourceNode)
-                continue;
-            const sourceResult = await this.traceValueSet(sourceNode, graph, visited, depth + 1);
-            sourceResult.values.forEach(v => result.values.push(v));
-            if (sourceResult.hasUnknown) {
-                result.hasUnknown = true;
-            }
-        }
-        return result;
+        return aggregateValues(traced);
     }
     /**
      * Find method by object name and method name
@@ -437,11 +370,7 @@ export class ValueDomainAnalyzer extends Plugin {
                 // Check if this is a method of the right object
                 // Simplified: check via incoming CONTAINS edges from CLASS
                 const incoming = await graph.getIncomingEdges(node.id);
-                const containsEdges = incoming.filter(e => {
-                    const edgeType = e.edgeType ||
-                        e.edge_type;
-                    return edgeType === 'CONTAINS';
-                });
+                const containsEdges = incoming.filter(e => e.type === 'CONTAINS');
                 for (const edge of containsEdges) {
                     const sourceId = edge.src ||
                         edge.source_id;
@@ -460,5 +389,118 @@ export class ValueDomainAnalyzer extends Plugin {
         }
         return null;
     }
+    /**
+     * Resolve computed property names for object mutations.
+     * Finds FLOWS_INTO edges with mutationType: 'computed' and resolves
+     * the property name using value set tracing.
+     *
+     * @param graph - Graph backend with edge operations
+     * @returns Statistics about resolution
+     */
+    async resolveComputedMutations(graph, logger) {
+        const stats = {
+            resolved: 0,
+            conditional: 0,
+            unknownParameter: 0,
+            unknownRuntime: 0,
+            deferredCrossFile: 0,
+            total: 0
+        };
+        // Process edges by finding all VARIABLE and CONSTANT nodes and checking their outgoing edges
+        const processedEdges = new Set();
+        // Helper to process a node's outgoing edges
+        const processNodeEdges = async (node) => {
+            const outgoing = await graph.getOutgoingEdges(node.id);
+            for (const edge of outgoing) {
+                if (edge.type !== 'FLOWS_INTO')
+                    continue;
+                const edgeKey = `${edge.src}->${edge.dst}:FLOWS_INTO`;
+                if (processedEdges.has(edgeKey))
+                    continue;
+                processedEdges.add(edgeKey);
+                const mutationType = edge.metadata?.mutationType;
+                const computedPropertyVar = edge.metadata?.computedPropertyVar;
+                if (mutationType !== 'computed' || !computedPropertyVar)
+                    continue;
+                stats.total++;
+                // Get file from source node
+                const sourceNode = await graph.getNode(edge.src);
+                const file = sourceNode?.file;
+                if (!file)
+                    continue;
+                // Resolve the computed property variable using existing getValueSet
+                const valueSet = await this.getValueSet(computedPropertyVar, file, graph);
+                // Check if the variable is a PARAMETER node
+                let isParameter = false;
+                for await (const node of graph.queryNodes({ nodeType: 'PARAMETER' })) {
+                    const paramNode = node;
+                    const nodeName = paramNode.name || paramNode.attrs?.name;
+                    const nodeFile = paramNode.file || paramNode.attrs?.file;
+                    if (nodeName === computedPropertyVar && nodeFile === file) {
+                        isParameter = true;
+                        break;
+                    }
+                }
+                // Determine resolution status based on value set
+                let resolutionStatus;
+                let resolvedPropertyNames = [];
+                if (valueSet.values.length === 0 && isParameter) {
+                    // Variable is a function parameter - cannot be statically resolved
+                    resolutionStatus = 'UNKNOWN_PARAMETER';
+                    stats.unknownParameter++;
+                }
+                else if (valueSet.values.length === 0 && valueSet.hasUnknown) {
+                    // Completely nondeterministic - runtime value (function call result, etc.)
+                    resolutionStatus = 'UNKNOWN_RUNTIME';
+                    stats.unknownRuntime++;
+                }
+                else if (valueSet.values.length === 0) {
+                    // No values found at all - treat as unknown
+                    resolutionStatus = 'UNKNOWN_RUNTIME';
+                    stats.unknownRuntime++;
+                }
+                else if (valueSet.values.length === 1 && !valueSet.hasUnknown) {
+                    // Single deterministic value
+                    resolutionStatus = 'RESOLVED';
+                    resolvedPropertyNames = valueSet.values.map(v => String(v));
+                    stats.resolved++;
+                }
+                else {
+                    // Multiple values (conditional) or partial resolution
+                    resolutionStatus = 'RESOLVED_CONDITIONAL';
+                    resolvedPropertyNames = valueSet.values.map(v => String(v));
+                    stats.conditional++;
+                }
+                // Update edge: delete old, create new with resolved data
+                // Following the same pattern as InstanceOfResolver
+                if (graph.deleteEdge) {
+                    await graph.deleteEdge(edge.src, edge.dst, 'FLOWS_INTO');
+                }
+                // Preserve original edge data and add resolution info
+                // For UNKNOWN cases, keep propertyName as '<computed>' and resolvedPropertyNames empty
+                await graph.addEdge({
+                    src: edge.src,
+                    dst: edge.dst,
+                    type: 'FLOWS_INTO',
+                    metadata: {
+                        mutationType,
+                        propertyName: resolvedPropertyNames[0] || '<computed>',
+                        computedPropertyVar,
+                        resolvedPropertyNames,
+                        resolutionStatus
+                    }
+                });
+            }
+        };
+        // Process VARIABLE nodes
+        for await (const node of graph.queryNodes({ nodeType: 'VARIABLE' })) {
+            await processNodeEdges(node);
+        }
+        // Process CONSTANT nodes
+        for await (const node of graph.queryNodes({ nodeType: 'CONSTANT' })) {
+            await processNodeEdges(node);
+        }
+        return stats;
+    }
 }
 export default ValueDomainAnalyzer;

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

@@ -1 +1 @@
-{"version":3,"file":"IncrementalModuleIndexer.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/IncrementalModuleIndexer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAyBhF,qBAAa,wBAAyB,SAAQ,MAAM;IAClD,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAED;;OAEG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;IACH,OAAO,CAAC,UAAU;IAuBlB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IASzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAqCd,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAgI7D"}
+{"version":3,"file":"IncrementalModuleIndexer.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/IncrementalModuleIndexer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAyBhF,qBAAa,wBAAyB,SAAQ,MAAM;IAClD,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAED;;OAEG;IACH,OAAO,CAAC,aAAa;IA0BrB;;OAEG;IACH,OAAO,CAAC,UAAU;IAuBlB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IASzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAqCd,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAyI7D"}

package/dist/plugins/indexing/IncrementalModuleIndexer.js

@@ -119,11 +119,12 @@ export class IncrementalModuleIndexer extends Plugin {
             return imports;
         }
         catch (err) {
-            console.error(`   ⚠️  Failed to parse imports from ${relative(projectRoot, filePath)}: ${err.message}`);
+            // Parse error will be logged by execute() when it needs logger context
             return [];
         }
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { manifest, graph } = context;
             // Cast manifest to expected shape
@@ -139,17 +140,18 @@ export class IncrementalModuleIndexer extends Plugin {
             let edgesCreated = 0;
             let totalImportsParsed = 0;
             let unresolvedImports = 0;
-            console.log(`📦 Starting incremental indexing from: ${relative(projectPath, entryFile)}\n`);
+            logger.info('Starting incremental indexing', { entryFile: relative(projectPath, entryFile) });
             while (queue.length > 0) {
                 const file = queue.shift();
                 if (processed.has(file))
                     continue;
                 processed.add(file);
-                // Create MODULE node
+                // Create MODULE node with semantic ID
                 const fileHash = this.calculateFileHash(file);
                 const relativePath = relative(projectPath, file);
+                const semanticId = `${relativePath}->global->MODULE->module`;
                 const moduleNode = {
-                    id: `${file}:MODULE:${file}:0`,
+                    id: semanticId,
                     type: 'MODULE',
                     name: relativePath,
                     file: file,
@@ -169,10 +171,12 @@ export class IncrementalModuleIndexer extends Plugin {
                 const imports = this.parseImports(file, projectPath);
                 totalImportsParsed += imports.length;
                 for (const importFile of imports) {
-                    // Store for later edge creation
+                    // Store for later edge creation with semantic ID format
+                    const importRelativePath = relative(projectPath, importFile);
+                    const importSemanticId = `${importRelativePath}->global->MODULE->module`;
                     pendingImports.push({
                         src: moduleNode.id,
-                        dst: `${importFile}:MODULE:${importFile}:0`
+                        dst: importSemanticId
                     });
                     if (!processed.has(importFile)) {
                         queue.push(importFile);
@@ -209,13 +213,15 @@ export class IncrementalModuleIndexer extends Plugin {
                     // Ignore parse errors for unresolved count
                 }
                 if (processed.size % 10 === 0) {
-                    process.stdout.write(`\r   📦 Indexed ${processed.size} modules (${queue.length} in queue)...`);
+                    logger.debug('Indexing progress', { indexed: processed.size, queueLength: queue.length });
                 }
             }
-            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`);
+            logger.info('Modules indexed', { count: processed.size });
+            logger.debug('Import statistics', {
+                totalImportsParsed,
+                unresolvedImports,
+                pendingEdges: pendingImports.length
+            });
             // Now create all IMPORTS edges after all MODULE nodes exist
             for (const { src, dst } of pendingImports) {
                 await graph.addEdge({
@@ -226,12 +232,15 @@ export class IncrementalModuleIndexer extends Plugin {
                 });
                 edgesCreated++;
             }
-            console.log(`   📊 Created ${nodesCreated} MODULE nodes and ${edgesCreated} edges`);
-            console.log(`   📈 IMPORTS edges created: ${pendingImports.length}\n`);
+            logger.info('Indexing complete', {
+                nodesCreated,
+                edgesCreated,
+                importsEdgesCreated: pendingImports.length
+            });
             return createSuccessResult({ nodes: nodesCreated, edges: edgesCreated }, { filesScanned: processed.size });
         }
         catch (error) {
-            console.error(`[IncrementalModuleIndexer] Error:`, error);
+            logger.error('Indexing failed', { error });
             return createErrorResult(error);
         }
     }

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

@@ -9,11 +9,26 @@ export declare class JSModuleIndexer extends Plugin {
     private cache;
     private testPatterns;
     private markTestFiles;
+    private includePatterns?;
+    private excludePatterns?;
+    private projectPath;
     constructor();
     /**
      * Check if file is a test file based on path patterns
      */
     private isTestFile;
+    /**
+     * Check if a file should be skipped based on include/exclude patterns.
+     *
+     * Logic:
+     * 1. If file matches any exclude pattern -> SKIP
+     * 2. If include patterns specified AND file doesn't match any -> SKIP
+     * 3. Otherwise -> PROCESS
+     *
+     * @param absolutePath - Absolute path to the file
+     * @returns true if file should be skipped, false if it should be processed
+     */
+    private shouldSkipFile;
     get metadata(): PluginMetadata;
     private calculateFileHash;
     /**

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

@@ -1 +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"}
+{"version":3,"file":"JSModuleIndexer.d.ts","sourceRoot":"","sources":["../../../src/plugins/indexing/JSModuleIndexer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,EAAE,MAAM,EAAqB,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgEhF,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;IAE/B,OAAO,CAAC,eAAe,CAAC,CAAW;IACnC,OAAO,CAAC,eAAe,CAAC,CAAW;IACnC,OAAO,CAAC,WAAW,CAAc;;IAYjC;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,cAAc;IA0BtB,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;CA6N7D"}