@grafema/core 0.1.0-alpha.1

package/dist/plugins/analysis/ast/visitors/FunctionVisitor.js

@@ -0,0 +1,172 @@
+/**
+ * FunctionVisitor - handles function declarations and arrow functions
+ *
+ * Handles:
+ * - FunctionDeclaration
+ * - ArrowFunctionExpression (module-level)
+ */
+import { ASTVisitor } from './ASTVisitor.js';
+export class FunctionVisitor extends ASTVisitor {
+    analyzeFunctionBody;
+    /**
+     * @param module - Current module being analyzed
+     * @param collections - Must contain arrays and counter refs
+     * @param analyzeFunctionBody - Callback to analyze function internals
+     */
+    constructor(module, collections, analyzeFunctionBody) {
+        super(module, collections);
+        this.analyzeFunctionBody = analyzeFunctionBody;
+    }
+    getHandlers() {
+        const { module } = this;
+        const functions = this.collections.functions ?? [];
+        const parameters = this.collections.parameters ?? [];
+        const scopes = this.collections.scopes ?? [];
+        const functionCounterRef = (this.collections.functionCounterRef ?? { value: 0 });
+        const moduleScopeCtx = this.collections.moduleScopeCtx;
+        const analyzeFunctionBody = this.analyzeFunctionBody;
+        const collections = this.collections;
+        // Helper function to generate stable anonymous function name
+        const generateAnonymousName = () => {
+            if (!moduleScopeCtx)
+                return 'anonymous';
+            const index = moduleScopeCtx.siblingCounters.get('anonymous') || 0;
+            moduleScopeCtx.siblingCounters.set('anonymous', index + 1);
+            return `anonymous[${index}]`;
+        };
+        // Helper function to create PARAMETER nodes for function params
+        const createParameterNodes = (params, functionId, file, line) => {
+            if (!parameters)
+                return; // Guard for backward compatibility
+            params.forEach((param, index) => {
+                // Handle different parameter types
+                if (param.type === 'Identifier') {
+                    const paramId = `PARAMETER#${param.name}#${file}#${line}:${index}`;
+                    parameters.push({
+                        id: paramId,
+                        type: 'PARAMETER',
+                        name: param.name,
+                        file: file,
+                        line: param.loc?.start.line || line,
+                        index: index,
+                        parentFunctionId: functionId
+                    });
+                }
+                else if (param.type === 'AssignmentPattern') {
+                    // Default parameter: function(a = 1)
+                    const assignmentParam = param;
+                    if (assignmentParam.left.type === 'Identifier') {
+                        const paramId = `PARAMETER#${assignmentParam.left.name}#${file}#${line}:${index}`;
+                        parameters.push({
+                            id: paramId,
+                            type: 'PARAMETER',
+                            name: assignmentParam.left.name,
+                            file: file,
+                            line: assignmentParam.left.loc?.start.line || line,
+                            index: index,
+                            hasDefault: true,
+                            parentFunctionId: functionId
+                        });
+                    }
+                }
+                else if (param.type === 'RestElement') {
+                    // Rest parameter: function(...args)
+                    const restParam = param;
+                    if (restParam.argument.type === 'Identifier') {
+                        const paramId = `PARAMETER#${restParam.argument.name}#${file}#${line}:${index}`;
+                        parameters.push({
+                            id: paramId,
+                            type: 'PARAMETER',
+                            name: restParam.argument.name,
+                            file: file,
+                            line: restParam.argument.loc?.start.line || line,
+                            index: index,
+                            isRest: true,
+                            parentFunctionId: functionId
+                        });
+                    }
+                }
+                // ObjectPattern and ArrayPattern (destructuring parameters) can be added later
+            });
+        };
+        return {
+            // Regular function declarations
+            FunctionDeclaration: (path) => {
+                const node = path.node;
+                if (!node.id)
+                    return; // Skip anonymous function declarations
+                const functionId = `FUNCTION#${node.id.name}#${module.file}#${node.loc.start.line}`;
+                functions.push({
+                    id: functionId,
+                    stableId: functionId,
+                    type: 'FUNCTION',
+                    name: node.id.name,
+                    file: module.file,
+                    line: node.loc.start.line,
+                    async: node.async || false,
+                    generator: node.generator || false
+                });
+                // Create PARAMETER nodes for function parameters
+                createParameterNodes(node.params, functionId, module.file, node.loc.start.line);
+                // Create SCOPE for function body
+                const functionBodyScopeId = `SCOPE#${node.id.name}:body#${module.file}#${node.loc.start.line}`;
+                scopes.push({
+                    id: functionBodyScopeId,
+                    type: 'SCOPE',
+                    scopeType: 'function_body',
+                    name: `${node.id.name}:body`,
+                    conditional: false,
+                    file: module.file,
+                    line: node.loc.start.line,
+                    parentFunctionId: functionId
+                });
+                // Analyze function body
+                analyzeFunctionBody(path, functionBodyScopeId, module, collections);
+                // Stop traversal - analyzeFunctionBody already processed contents
+                path.skip();
+            },
+            // Arrow functions (module-level, assigned to variables or as callbacks)
+            ArrowFunctionExpression: (path) => {
+                const node = path.node;
+                const line = node.loc.start.line;
+                const column = node.loc.start.column;
+                // Determine arrow function name (use scope-level counter for stable semanticId)
+                let functionName = generateAnonymousName();
+                // If arrow function is assigned to variable: const add = () => {}
+                const parent = path.parent;
+                if (parent.type === 'VariableDeclarator') {
+                    const declarator = parent;
+                    if (declarator.id.type === 'Identifier') {
+                        functionName = declarator.id.name;
+                    }
+                }
+                const functionId = `FUNCTION#${functionName}#${module.file}#${line}:${column}:${functionCounterRef.value++}`;
+                functions.push({
+                    id: functionId,
+                    stableId: functionId,
+                    type: 'FUNCTION',
+                    name: functionName,
+                    file: module.file,
+                    line,
+                    column,
+                    async: node.async || false,
+                    arrowFunction: true
+                });
+                // Create PARAMETER nodes for arrow function parameters
+                createParameterNodes(node.params, functionId, module.file, line);
+                // Create SCOPE for arrow function body
+                const bodyScope = `SCOPE#${functionName}:body#${module.file}#${line}:${column}`;
+                scopes.push({
+                    id: bodyScope,
+                    type: 'SCOPE',
+                    name: `${functionName}:body`,
+                    file: module.file,
+                    line,
+                    scopeType: 'function-body',
+                    parentFunctionId: functionId
+                });
+                analyzeFunctionBody(path, bodyScope, module, collections);
+            }
+        };
+    }
+}

package/dist/plugins/analysis/ast/visitors/ImportExportVisitor.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ImportExportVisitor - handles import and export declarations
+ *
+ * Handles:
+ * - ImportDeclaration: import { foo } from './module'
+ * - ExportDefaultDeclaration: export default foo
+ * - ExportNamedDeclaration: export { foo, bar }
+ * - ExportAllDeclaration: export * from './module'
+ */
+import type { Node } from '@babel/types';
+import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
+import type { VariableInfo } from './VariableVisitor.js';
+/**
+ * Callback type for extracting variable names from patterns
+ */
+export type ExtractVariableNamesCallback = (pattern: Node) => VariableInfo[];
+export declare class ImportExportVisitor extends ASTVisitor {
+    private extractVariableNamesFromPattern;
+    /**
+     * @param module - Current module being analyzed
+     * @param collections - Must contain 'imports' and 'exports' arrays
+     * @param extractVariableNamesFromPattern - Helper from JSASTAnalyzer
+     */
+    constructor(module: VisitorModule, collections: VisitorCollections, extractVariableNamesFromPattern: ExtractVariableNamesCallback);
+    getImportHandlers(): VisitorHandlers;
+    getExportHandlers(): VisitorHandlers;
+    getHandlers(): VisitorHandlers;
+}
+//# sourceMappingURL=ImportExportVisitor.d.ts.map

package/dist/plugins/analysis/ast/visitors/ImportExportVisitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportExportVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/ImportExportVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAaV,IAAI,EACL,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAChH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;AAuC7E,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,OAAO,CAAC,+BAA+B,CAA+B;IAEtE;;;;OAIG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,+BAA+B,EAAE,4BAA4B;IAM/D,iBAAiB,IAAI,eAAe;IA+CpC,iBAAiB,IAAI,eAAe;IAqHpC,WAAW,IAAI,eAAe;CAM/B"}

package/dist/plugins/analysis/ast/visitors/ImportExportVisitor.js

@@ -0,0 +1,180 @@
+/**
+ * ImportExportVisitor - handles import and export declarations
+ *
+ * Handles:
+ * - ImportDeclaration: import { foo } from './module'
+ * - ExportDefaultDeclaration: export default foo
+ * - ExportNamedDeclaration: export { foo, bar }
+ * - ExportAllDeclaration: export * from './module'
+ */
+import { ASTVisitor } from './ASTVisitor.js';
+export class ImportExportVisitor extends ASTVisitor {
+    extractVariableNamesFromPattern;
+    /**
+     * @param module - Current module being analyzed
+     * @param collections - Must contain 'imports' and 'exports' arrays
+     * @param extractVariableNamesFromPattern - Helper from JSASTAnalyzer
+     */
+    constructor(module, collections, extractVariableNamesFromPattern) {
+        super(module, collections);
+        this.extractVariableNamesFromPattern = extractVariableNamesFromPattern;
+    }
+    getImportHandlers() {
+        const { imports } = this.collections;
+        return {
+            ImportDeclaration: (path) => {
+                const node = path.node;
+                const source = node.source.value;
+                // Collect imported names
+                const specifiers = [];
+                node.specifiers.forEach((spec) => {
+                    if (spec.type === 'ImportSpecifier') {
+                        // import { foo, bar } from './module'
+                        const importSpec = spec;
+                        const importedName = importSpec.imported.type === 'Identifier'
+                            ? importSpec.imported.name
+                            : importSpec.imported.value;
+                        specifiers.push({
+                            imported: importedName,
+                            local: importSpec.local.name
+                        });
+                    }
+                    else if (spec.type === 'ImportDefaultSpecifier') {
+                        // import foo from './module'
+                        const defaultSpec = spec;
+                        specifiers.push({
+                            imported: 'default',
+                            local: defaultSpec.local.name
+                        });
+                    }
+                    else if (spec.type === 'ImportNamespaceSpecifier') {
+                        // import * as foo from './module'
+                        const namespaceSpec = spec;
+                        specifiers.push({
+                            imported: '*',
+                            local: namespaceSpec.local.name
+                        });
+                    }
+                });
+                imports.push({
+                    source,
+                    specifiers,
+                    line: node.loc.start.line
+                });
+            }
+        };
+    }
+    getExportHandlers() {
+        const { exports } = this.collections;
+        const extractVariableNamesFromPattern = this.extractVariableNamesFromPattern;
+        return {
+            ExportDefaultDeclaration: (path) => {
+                const node = path.node;
+                exports.push({
+                    type: 'default',
+                    line: node.loc.start.line,
+                    declaration: node.declaration
+                });
+            },
+            ExportNamedDeclaration: (path) => {
+                const node = path.node;
+                // export { foo, bar } from './module'
+                if (node.source) {
+                    const specifiers = node.specifiers.map((spec) => {
+                        const exportSpec = spec;
+                        const exportedName = exportSpec.exported.type === 'Identifier'
+                            ? exportSpec.exported.name
+                            : exportSpec.exported.value;
+                        const localName = exportSpec.local.type === 'Identifier'
+                            ? exportSpec.local.name
+                            : exportedName;
+                        return {
+                            exported: exportedName,
+                            local: localName
+                        };
+                    });
+                    exports.push({
+                        type: 'named',
+                        line: node.loc.start.line,
+                        specifiers,
+                        source: node.source.value
+                    });
+                }
+                // export { foo, bar }
+                else if (node.specifiers.length > 0) {
+                    const specifiers = node.specifiers.map((spec) => {
+                        const exportSpec = spec;
+                        const exportedName = exportSpec.exported.type === 'Identifier'
+                            ? exportSpec.exported.name
+                            : exportSpec.exported.value;
+                        return {
+                            exported: exportedName,
+                            local: exportSpec.local.name
+                        };
+                    });
+                    exports.push({
+                        type: 'named',
+                        line: node.loc.start.line,
+                        specifiers
+                    });
+                }
+                // export const foo = 42 or export function bar() {}
+                else if (node.declaration) {
+                    const declaration = node.declaration;
+                    // export function foo() {}
+                    if (declaration.type === 'FunctionDeclaration') {
+                        const funcDecl = declaration;
+                        if (funcDecl.id) {
+                            exports.push({
+                                type: 'named',
+                                line: node.loc.start.line,
+                                name: funcDecl.id.name
+                            });
+                        }
+                    }
+                    // export const foo = 42, bar = 43
+                    else if (declaration.type === 'VariableDeclaration') {
+                        const varDecl = declaration;
+                        varDecl.declarations.forEach((declarator) => {
+                            // Handle destructuring: export const { a, b } = obj
+                            const variables = extractVariableNamesFromPattern(declarator.id);
+                            variables.forEach((varInfo) => {
+                                exports.push({
+                                    type: 'named',
+                                    line: node.loc.start.line,
+                                    name: varInfo.name
+                                });
+                            });
+                        });
+                    }
+                    // export class Foo {}
+                    else if (declaration.type === 'ClassDeclaration') {
+                        const classDecl = declaration;
+                        if (classDecl.id) {
+                            exports.push({
+                                type: 'named',
+                                line: node.loc.start.line,
+                                name: classDecl.id.name
+                            });
+                        }
+                    }
+                }
+            },
+            ExportAllDeclaration: (path) => {
+                const node = path.node;
+                // export * from './module'
+                exports.push({
+                    type: 'all',
+                    line: node.loc.start.line,
+                    source: node.source.value
+                });
+            }
+        };
+    }
+    getHandlers() {
+        return {
+            ...this.getImportHandlers(),
+            ...this.getExportHandlers()
+        };
+    }
+}

package/dist/plugins/analysis/ast/visitors/TypeScriptVisitor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * TypeScriptVisitor - handles TypeScript-specific AST nodes
+ *
+ * Handles:
+ * - TSInterfaceDeclaration
+ * - TSTypeAliasDeclaration
+ * - TSEnumDeclaration
+ */
+import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
+export declare class TypeScriptVisitor extends ASTVisitor {
+    constructor(module: VisitorModule, collections: VisitorCollections);
+    getHandlers(): VisitorHandlers;
+}
+//# sourceMappingURL=TypeScriptVisitor.d.ts.map

package/dist/plugins/analysis/ast/visitors/TypeScriptVisitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeScriptVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/TypeScriptVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AA8EhH,qBAAa,iBAAkB,SAAQ,UAAU;gBACnC,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,kBAAkB;IAIlE,WAAW,IAAI,eAAe;CAmI/B"}

package/dist/plugins/analysis/ast/visitors/TypeScriptVisitor.js

@@ -0,0 +1,200 @@
+/**
+ * TypeScriptVisitor - handles TypeScript-specific AST nodes
+ *
+ * Handles:
+ * - TSInterfaceDeclaration
+ * - TSTypeAliasDeclaration
+ * - TSEnumDeclaration
+ */
+import { ASTVisitor } from './ASTVisitor.js';
+/**
+ * Extracts a string representation of a TypeScript type node
+ */
+function typeNodeToString(node) {
+    if (!node || typeof node !== 'object')
+        return 'unknown';
+    const typeNode = node;
+    switch (typeNode.type) {
+        case 'TSStringKeyword':
+            return 'string';
+        case 'TSNumberKeyword':
+            return 'number';
+        case 'TSBooleanKeyword':
+            return 'boolean';
+        case 'TSAnyKeyword':
+            return 'any';
+        case 'TSUnknownKeyword':
+            return 'unknown';
+        case 'TSVoidKeyword':
+            return 'void';
+        case 'TSNullKeyword':
+            return 'null';
+        case 'TSUndefinedKeyword':
+            return 'undefined';
+        case 'TSNeverKeyword':
+            return 'never';
+        case 'TSObjectKeyword':
+            return 'object';
+        case 'TSSymbolKeyword':
+            return 'symbol';
+        case 'TSBigIntKeyword':
+            return 'bigint';
+        case 'TSTypeReference':
+            const typeName = typeNode.typeName;
+            if (typeName?.type === 'Identifier') {
+                return typeName.name || 'unknown';
+            }
+            return 'unknown';
+        case 'TSArrayType':
+            return `${typeNodeToString(typeNode.elementType)}[]`;
+        case 'TSUnionType':
+            const unionTypes = typeNode.types;
+            return unionTypes.map(t => typeNodeToString(t)).join(' | ');
+        case 'TSIntersectionType':
+            const intersectionTypes = typeNode.types;
+            return intersectionTypes.map(t => typeNodeToString(t)).join(' & ');
+        case 'TSLiteralType':
+            const literal = typeNode.literal;
+            if (literal?.type === 'StringLiteral') {
+                return `'${literal.value}'`;
+            }
+            else if (literal?.type === 'NumericLiteral') {
+                return String(literal.value);
+            }
+            else if (literal?.type === 'BooleanLiteral') {
+                return String(literal.value);
+            }
+            return 'unknown';
+        case 'TSFunctionType':
+            return 'function';
+        case 'TSTupleType':
+            const tupleTypes = typeNode.elementTypes;
+            return `[${tupleTypes.map(t => typeNodeToString(t)).join(', ')}]`;
+        case 'TSTypeLiteral':
+            return 'object';
+        default:
+            return 'unknown';
+    }
+}
+export class TypeScriptVisitor extends ASTVisitor {
+    constructor(module, collections) {
+        super(module, collections);
+    }
+    getHandlers() {
+        const { module } = this;
+        const { interfaces, typeAliases, enums } = this.collections;
+        return {
+            TSInterfaceDeclaration: (path) => {
+                const node = path.node;
+                if (!node.id)
+                    return;
+                const interfaceName = node.id.name;
+                const interfaceId = `INTERFACE#${interfaceName}#${module.file}#${node.loc.start.line}`;
+                // Extract extends
+                const extendsNames = [];
+                if (node.extends && node.extends.length > 0) {
+                    for (const ext of node.extends) {
+                        if (ext.expression.type === 'Identifier') {
+                            extendsNames.push(ext.expression.name);
+                        }
+                    }
+                }
+                // Extract properties
+                const properties = [];
+                if (node.body && node.body.body) {
+                    for (const member of node.body.body) {
+                        if (member.type === 'TSPropertySignature') {
+                            const prop = member;
+                            if (prop.key.type === 'Identifier') {
+                                properties.push({
+                                    name: prop.key.name,
+                                    type: prop.typeAnnotation ? typeNodeToString(prop.typeAnnotation.typeAnnotation) : undefined,
+                                    optional: prop.optional || false,
+                                    readonly: prop.readonly || false
+                                });
+                            }
+                        }
+                        else if (member.type === 'TSMethodSignature') {
+                            const method = member;
+                            if (method.key.type === 'Identifier') {
+                                properties.push({
+                                    name: method.key.name,
+                                    type: 'function',
+                                    optional: method.optional || false,
+                                    readonly: false
+                                });
+                            }
+                        }
+                    }
+                }
+                interfaces.push({
+                    id: interfaceId,
+                    type: 'INTERFACE',
+                    name: interfaceName,
+                    file: module.file,
+                    line: node.loc.start.line,
+                    column: node.loc.start.column,
+                    extends: extendsNames.length > 0 ? extendsNames : undefined,
+                    properties
+                });
+            },
+            TSTypeAliasDeclaration: (path) => {
+                const node = path.node;
+                if (!node.id)
+                    return;
+                const typeName = node.id.name;
+                const typeId = `TYPE#${typeName}#${module.file}#${node.loc.start.line}`;
+                // Extract the type being aliased
+                const aliasOf = typeNodeToString(node.typeAnnotation);
+                typeAliases.push({
+                    id: typeId,
+                    type: 'TYPE',
+                    name: typeName,
+                    file: module.file,
+                    line: node.loc.start.line,
+                    column: node.loc.start.column,
+                    aliasOf
+                });
+            },
+            TSEnumDeclaration: (path) => {
+                const node = path.node;
+                if (!node.id)
+                    return;
+                const enumName = node.id.name;
+                const enumId = `ENUM#${enumName}#${module.file}#${node.loc.start.line}`;
+                // Extract members
+                const members = [];
+                if (node.members) {
+                    for (const member of node.members) {
+                        if (member.id.type === 'Identifier') {
+                            const memberInfo = {
+                                name: member.id.name
+                            };
+                            // Extract value if present
+                            if (member.initializer) {
+                                const init = member.initializer;
+                                if (init.type === 'StringLiteral') {
+                                    memberInfo.value = init.value;
+                                }
+                                else if (init.type === 'NumericLiteral') {
+                                    memberInfo.value = init.value;
+                                }
+                            }
+                            members.push(memberInfo);
+                        }
+                    }
+                }
+                enums.push({
+                    id: enumId,
+                    type: 'ENUM',
+                    name: enumName,
+                    file: module.file,
+                    line: node.loc.start.line,
+                    column: node.loc.start.column,
+                    isConst: node.const || false,
+                    members
+                });
+            }
+        };
+    }
+}

package/dist/plugins/analysis/ast/visitors/VariableVisitor.d.ts

@@ -0,0 +1,45 @@
+/**
+ * VariableVisitor - handles module-level variable declarations
+ *
+ * Handles:
+ * - VariableDeclaration (const, let, var at module level)
+ * - NewExpression tracking for class instantiation
+ * - Destructuring patterns
+ */
+import type { Node } from '@babel/types';
+import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers, type CounterRef } from './ASTVisitor.js';
+/**
+ * Variable info extracted from pattern
+ */
+export interface VariableInfo {
+    name: string;
+    loc: {
+        start: {
+            line: number;
+            column: number;
+        };
+    };
+    propertyPath?: string[];
+    arrayIndex?: number;
+}
+/**
+ * Callback type for extracting variable names from patterns
+ */
+export type ExtractVariableNamesCallback = (pattern: Node) => VariableInfo[];
+/**
+ * Callback type for tracking variable assignments
+ */
+export type TrackVariableAssignmentCallback = (initNode: Node, variableId: string, variableName: string, module: VisitorModule, line: number, literals: unknown[], variableAssignments: unknown[], literalCounterRef: CounterRef) => void;
+export declare class VariableVisitor extends ASTVisitor {
+    private extractVariableNamesFromPattern;
+    private trackVariableAssignment;
+    /**
+     * @param module - Current module being analyzed
+     * @param collections - Must contain arrays and counter refs
+     * @param extractVariableNamesFromPattern - Helper for destructuring
+     * @param trackVariableAssignment - Helper for data flow tracking
+     */
+    constructor(module: VisitorModule, collections: VisitorCollections, extractVariableNamesFromPattern: ExtractVariableNamesCallback, trackVariableAssignment: TrackVariableAssignmentCallback);
+    getHandlers(): VisitorHandlers;
+}
+//# sourceMappingURL=VariableVisitor.d.ts.map

package/dist/plugins/analysis/ast/visitors/VariableVisitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VariableVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/VariableVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAKV,IAAI,EACL,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGjI;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE;QAAE,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACjD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,CAC5C,QAAQ,EAAE,IAAI,EACd,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,EAAE,EACnB,mBAAmB,EAAE,OAAO,EAAE,EAC9B,iBAAiB,EAAE,UAAU,KAC1B,IAAI,CAAC;AAoDV,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,OAAO,CAAC,+BAA+B,CAA+B;IACtE,OAAO,CAAC,uBAAuB,CAAkC;IAEjE;;;;;OAKG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,+BAA+B,EAAE,4BAA4B,EAC7D,uBAAuB,EAAE,+BAA+B;IAO1D,WAAW,IAAI,eAAe;CAmJ/B"}