@saluzi/codegraph 0.1.0

package/dist/extraction/languages/c-cpp.d.ts

@@ -0,0 +1,4 @@
+import type { LanguageExtractor } from '../tree-sitter-types'
+export declare const cExtractor: LanguageExtractor
+export declare const cppExtractor: LanguageExtractor
+//# sourceMappingURL=c-cpp.d.ts.map

package/dist/extraction/languages/c-cpp.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cppExtractor = exports.cExtractor = void 0;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+exports.cExtractor = {
+    functionTypes: ['function_definition'],
+    classTypes: [],
+    methodTypes: [],
+    interfaceTypes: [],
+    structTypes: ['struct_specifier'],
+    enumTypes: ['enum_specifier'],
+    enumMemberTypes: ['enumerator'],
+    typeAliasTypes: ['type_definition'], // typedef
+    importTypes: ['preproc_include'],
+    callTypes: ['call_expression'],
+    variableTypes: ['declaration'],
+    nameField: 'declarator',
+    bodyField: 'body',
+    paramsField: 'parameters',
+    resolveTypeAliasKind: (node, _source) => {
+        // C typedef: `typedef enum { ... } name;` or `typedef struct { ... } name;`
+        // The inner enum_specifier/struct_specifier is anonymous, but we want the typedef name
+        // to become the enum/struct node name.
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (!child)
+                continue;
+            if (child.type === 'enum_specifier' && (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
+                return 'enum';
+            if (child.type === 'struct_specifier' && (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
+                return 'struct';
+        }
+        return undefined;
+    },
+    extractImport: (node, source) => {
+        const importText = source.substring(node.startIndex, node.endIndex).trim();
+        // C includes: #include <stdio.h>, #include "myheader.h"
+        const systemLib = node.namedChildren.find((c) => c.type === 'system_lib_string');
+        if (systemLib) {
+            return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(systemLib, source).replace(/^<|>$/g, ''), signature: importText };
+        }
+        const stringLiteral = node.namedChildren.find((c) => c.type === 'string_literal');
+        if (stringLiteral) {
+            const stringContent = stringLiteral.namedChildren.find((c) => c.type === 'string_content');
+            if (stringContent) {
+                return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(stringContent, source), signature: importText };
+            }
+        }
+        return null;
+    },
+};
+exports.cppExtractor = {
+    functionTypes: ['function_definition'],
+    classTypes: ['class_specifier'],
+    methodTypes: ['function_definition'],
+    interfaceTypes: [],
+    structTypes: ['struct_specifier'],
+    enumTypes: ['enum_specifier'],
+    enumMemberTypes: ['enumerator'],
+    typeAliasTypes: ['type_definition', 'alias_declaration'], // typedef and using
+    importTypes: ['preproc_include'],
+    callTypes: ['call_expression'],
+    variableTypes: ['declaration'],
+    nameField: 'declarator',
+    bodyField: 'body',
+    paramsField: 'parameters',
+    getVisibility: (node) => {
+        // Check for access specifier in parent
+        const parent = node.parent;
+        if (parent) {
+            for (let i = 0; i < parent.childCount; i++) {
+                const child = parent.child(i);
+                if (child?.type === 'access_specifier') {
+                    const text = child.text;
+                    if (text.includes('public'))
+                        return 'public';
+                    if (text.includes('private'))
+                        return 'private';
+                    if (text.includes('protected'))
+                        return 'protected';
+                }
+            }
+        }
+        return undefined;
+    },
+    resolveTypeAliasKind: (node, _source) => {
+        // C++ typedef: `typedef enum { ... } name;` or `typedef struct { ... } name;`
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (!child)
+                continue;
+            if (child.type === 'enum_specifier' && (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
+                return 'enum';
+            if (child.type === 'struct_specifier' && (0, tree_sitter_helpers_1.getChildByField)(child, 'body'))
+                return 'struct';
+        }
+        return undefined;
+    },
+    isMisparsedFunction: (name) => {
+        // C++ macros like NLOHMANN_JSON_NAMESPACE_BEGIN cause tree-sitter to misparse
+        // namespace blocks as function_definitions (e.g. name = "namespace detail").
+        // Also filter C++ keywords that tree-sitter occasionally misinterprets as
+        // function/method names (e.g. switch statements inside macro-confused scopes).
+        if (name.startsWith('namespace'))
+            return true;
+        const cppKeywords = ['switch', 'if', 'for', 'while', 'do', 'case', 'return'];
+        return cppKeywords.includes(name);
+    },
+    extractImport: (node, source) => {
+        const importText = source.substring(node.startIndex, node.endIndex).trim();
+        // C++ includes: #include <iostream>, #include "myheader.h"
+        const systemLib = node.namedChildren.find((c) => c.type === 'system_lib_string');
+        if (systemLib) {
+            return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(systemLib, source).replace(/^<|>$/g, ''), signature: importText };
+        }
+        const stringLiteral = node.namedChildren.find((c) => c.type === 'string_literal');
+        if (stringLiteral) {
+            const stringContent = stringLiteral.namedChildren.find((c) => c.type === 'string_content');
+            if (stringContent) {
+                return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(stringContent, source), signature: importText };
+            }
+        }
+        return null;
+    },
+};
+//# sourceMappingURL=c-cpp.js.map

package/dist/extraction/languages/csharp.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types'
+export declare const csharpExtractor: LanguageExtractor
+//# sourceMappingURL=csharp.d.ts.map

package/dist/extraction/languages/csharp.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpExtractor = void 0;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+exports.csharpExtractor = {
+    functionTypes: [],
+    classTypes: ['class_declaration'],
+    methodTypes: ['method_declaration', 'constructor_declaration'],
+    interfaceTypes: ['interface_declaration'],
+    structTypes: ['struct_declaration'],
+    enumTypes: ['enum_declaration'],
+    enumMemberTypes: ['enum_member_declaration'],
+    typeAliasTypes: [],
+    importTypes: ['using_directive'],
+    callTypes: ['invocation_expression'],
+    variableTypes: ['local_declaration_statement'],
+    fieldTypes: ['field_declaration'],
+    propertyTypes: ['property_declaration'],
+    nameField: 'name',
+    bodyField: 'body',
+    paramsField: 'parameter_list',
+    getVisibility: (node) => {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.type === 'modifier') {
+                const text = child.text;
+                if (text === 'public')
+                    return 'public';
+                if (text === 'private')
+                    return 'private';
+                if (text === 'protected')
+                    return 'protected';
+                if (text === 'internal')
+                    return 'internal';
+            }
+        }
+        return 'private'; // C# defaults to private
+    },
+    isStatic: (node) => {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.type === 'modifier' && child.text === 'static') {
+                return true;
+            }
+        }
+        return false;
+    },
+    isAsync: (node) => {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.type === 'modifier' && child.text === 'async') {
+                return true;
+            }
+        }
+        return false;
+    },
+    extractImport: (node, source) => {
+        const importText = source.substring(node.startIndex, node.endIndex).trim();
+        // C# using directives: using System, using System.Collections.Generic, using static X, using Alias = X
+        const qualifiedName = node.namedChildren.find((c) => c.type === 'qualified_name');
+        if (qualifiedName) {
+            return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(qualifiedName, source), signature: importText };
+        }
+        // Simple namespace like "using System;" - get the first identifier
+        const identifier = node.namedChildren.find((c) => c.type === 'identifier');
+        if (identifier) {
+            return { moduleName: (0, tree_sitter_helpers_1.getNodeText)(identifier, source), signature: importText };
+        }
+        return null;
+    },
+};
+//# sourceMappingURL=csharp.js.map

package/dist/extraction/languages/dart.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types'
+export declare const dartExtractor: LanguageExtractor
+//# sourceMappingURL=dart.d.ts.map

package/dist/extraction/languages/dart.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartExtractor = void 0;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+exports.dartExtractor = {
+    functionTypes: ['function_signature'],
+    classTypes: ['class_definition'],
+    methodTypes: ['method_signature'],
+    interfaceTypes: [],
+    structTypes: [],
+    enumTypes: ['enum_declaration'],
+    enumMemberTypes: ['enum_constant'],
+    typeAliasTypes: ['type_alias'],
+    importTypes: ['import_or_export'],
+    callTypes: [], // Dart calls use identifier+selector, handled via extractBareCall
+    variableTypes: [],
+    extraClassNodeTypes: ['mixin_declaration', 'extension_declaration'],
+    resolveBody: (node, bodyField) => {
+        // Dart: function_body is a next sibling of function_signature/method_signature
+        if (node.type === 'function_signature' || node.type === 'method_signature') {
+            const next = node.nextNamedSibling;
+            if (next?.type === 'function_body')
+                return next;
+            return null;
+        }
+        // For class/mixin/extension: try standard field, then class_body/extension_body
+        const standard = node.childForFieldName(bodyField);
+        if (standard)
+            return standard;
+        return node.namedChildren.find((c) => c.type === 'class_body' || c.type === 'extension_body') || null;
+    },
+    nameField: 'name',
+    bodyField: 'body', // class_definition uses 'body' field
+    paramsField: 'formal_parameter_list',
+    returnField: 'type',
+    getSignature: (node, source) => {
+        // For function_signature: extract params + return type
+        // For method_signature: delegate to inner function_signature
+        let sig = node;
+        if (node.type === 'method_signature') {
+            const inner = node.namedChildren.find((c) => c.type === 'function_signature' || c.type === 'getter_signature' || c.type === 'setter_signature');
+            if (inner)
+                sig = inner;
+        }
+        const params = sig.namedChildren.find((c) => c.type === 'formal_parameter_list');
+        const retType = sig.namedChildren.find((c) => c.type === 'type_identifier' || c.type === 'void_type');
+        if (!params && !retType)
+            return undefined;
+        let result = '';
+        if (retType)
+            result += (0, tree_sitter_helpers_1.getNodeText)(retType, source) + ' ';
+        if (params)
+            result += (0, tree_sitter_helpers_1.getNodeText)(params, source);
+        return result.trim() || undefined;
+    },
+    getVisibility: (node) => {
+        // Dart convention: _ prefix means private, otherwise public
+        let nameNode = null;
+        if (node.type === 'method_signature') {
+            const inner = node.namedChildren.find((c) => c.type === 'function_signature' || c.type === 'getter_signature' || c.type === 'setter_signature');
+            if (inner)
+                nameNode = inner.namedChildren.find((c) => c.type === 'identifier') || null;
+        }
+        else {
+            nameNode = node.childForFieldName('name');
+        }
+        if (nameNode && nameNode.text.startsWith('_'))
+            return 'private';
+        return 'public';
+    },
+    isAsync: (node) => {
+        // In Dart, 'async' is on the function_body (next sibling), not the signature
+        const nextSibling = node.nextNamedSibling;
+        if (nextSibling?.type === 'function_body') {
+            for (let i = 0; i < nextSibling.childCount; i++) {
+                const child = nextSibling.child(i);
+                if (child?.type === 'async')
+                    return true;
+            }
+        }
+        return false;
+    },
+    isStatic: (node) => {
+        // For method_signature, check for 'static' child
+        if (node.type === 'method_signature') {
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child?.type === 'static')
+                    return true;
+            }
+        }
+        return false;
+    },
+    extractImport: (node, source) => {
+        const importText = source.substring(node.startIndex, node.endIndex).trim();
+        let moduleName = '';
+        // Dart imports: import 'dart:async'; import 'package:foo/bar.dart' as bar;
+        const libraryImport = node.namedChildren.find((c) => c.type === 'library_import');
+        if (libraryImport) {
+            const importSpec = libraryImport.namedChildren.find((c) => c.type === 'import_specification');
+            if (importSpec) {
+                const configurableUri = importSpec.namedChildren.find((c) => c.type === 'configurable_uri');
+                if (configurableUri) {
+                    const uri = configurableUri.namedChildren.find((c) => c.type === 'uri');
+                    if (uri) {
+                        const stringLiteral = uri.namedChildren.find((c) => c.type === 'string_literal');
+                        if (stringLiteral) {
+                            moduleName = (0, tree_sitter_helpers_1.getNodeText)(stringLiteral, source).replace(/['"]/g, '');
+                        }
+                    }
+                }
+            }
+        }
+        // Also handle exports: export 'src/foo.dart';
+        if (!moduleName) {
+            const libraryExport = node.namedChildren.find((c) => c.type === 'library_export');
+            if (libraryExport) {
+                const configurableUri = libraryExport.namedChildren.find((c) => c.type === 'configurable_uri');
+                if (configurableUri) {
+                    const uri = configurableUri.namedChildren.find((c) => c.type === 'uri');
+                    if (uri) {
+                        const stringLiteral = uri.namedChildren.find((c) => c.type === 'string_literal');
+                        if (stringLiteral) {
+                            moduleName = (0, tree_sitter_helpers_1.getNodeText)(stringLiteral, source).replace(/['"]/g, '');
+                        }
+                    }
+                }
+            }
+        }
+        if (moduleName) {
+            return { moduleName, signature: importText };
+        }
+        return null;
+    },
+    extractBareCall: (node, _source) => {
+        // Dart calls are: identifier + selector(argument_part), not a dedicated call node.
+        // Match on selector nodes that contain argument_part.
+        if (node.type === 'selector') {
+            const hasArgPart = node.namedChildren.some((c) => c.type === 'argument_part');
+            if (!hasArgPart)
+                return undefined;
+            const prev = node.previousNamedSibling;
+            if (!prev)
+                return undefined;
+            // Simple function/constructor call: prev is identifier (e.g., runApp(...), MyWidget(...))
+            if (prev.type === 'identifier') {
+                return prev.text;
+            }
+            // Method call: prev is selector with accessor (e.g., obj.method(...), Navigator.push(...))
+            if (prev.type === 'selector') {
+                const accessor = prev.namedChildren.find((c) => c.type === 'unconditional_assignable_selector' || c.type === 'conditional_assignable_selector');
+                if (accessor) {
+                    const methodId = accessor.namedChildren.find((c) => c.type === 'identifier');
+                    if (methodId) {
+                        // Include receiver for first call in chain (receiver is a direct identifier)
+                        const accessorPrev = prev.previousNamedSibling;
+                        if (accessorPrev?.type === 'identifier') {
+                            return accessorPrev.text + '.' + methodId.text;
+                        }
+                        return methodId.text;
+                    }
+                }
+            }
+            // super.method() / this.method(): prev is bare unconditional_assignable_selector
+            if (prev.type === 'unconditional_assignable_selector' || prev.type === 'conditional_assignable_selector') {
+                const methodId = prev.namedChildren.find((c) => c.type === 'identifier');
+                if (methodId)
+                    return methodId.text;
+            }
+            return undefined;
+        }
+        // new MyWidget() — explicit constructor call
+        if (node.type === 'new_expression') {
+            const typeId = node.namedChildren.find((c) => c.type === 'type_identifier');
+            if (typeId)
+                return typeId.text;
+            return undefined;
+        }
+        // const EdgeInsets.all(8.0) — const constructor call
+        if (node.type === 'const_object_expression') {
+            const typeId = node.namedChildren.find((c) => c.type === 'type_identifier');
+            const nameId = node.namedChildren.find((c) => c.type === 'identifier');
+            if (typeId && nameId)
+                return typeId.text + '.' + nameId.text;
+            if (typeId)
+                return typeId.text;
+            return undefined;
+        }
+        return undefined;
+    },
+};
+//# sourceMappingURL=dart.js.map

package/dist/extraction/languages/go.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types'
+export declare const goExtractor: LanguageExtractor
+//# sourceMappingURL=go.d.ts.map

package/dist/extraction/languages/go.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goExtractor = void 0;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+exports.goExtractor = {
+    functionTypes: ['function_declaration'],
+    classTypes: [], // Go doesn't have classes
+    methodTypes: ['method_declaration'],
+    interfaceTypes: [], // Handled via type_spec → resolveTypeAliasKind
+    structTypes: [], // Handled via type_spec → resolveTypeAliasKind
+    enumTypes: [],
+    typeAliasTypes: ['type_spec'], // Go type declarations
+    importTypes: ['import_declaration'],
+    callTypes: ['call_expression'],
+    variableTypes: ['var_declaration', 'short_var_declaration', 'const_declaration'],
+    methodsAreTopLevel: true,
+    nameField: 'name',
+    bodyField: 'body',
+    paramsField: 'parameters',
+    returnField: 'result',
+    getSignature: (node, source) => {
+        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'parameters');
+        const result = (0, tree_sitter_helpers_1.getChildByField)(node, 'result');
+        if (!params)
+            return undefined;
+        let sig = (0, tree_sitter_helpers_1.getNodeText)(params, source);
+        if (result) {
+            sig += ' ' + (0, tree_sitter_helpers_1.getNodeText)(result, source);
+        }
+        return sig;
+    },
+    resolveTypeAliasKind: (node, _source) => {
+        // Go type_spec: `type Foo struct { ... }` or `type Bar interface { ... }`
+        // The inner type is in the 'type' field of the type_spec node
+        const typeChild = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+        if (!typeChild)
+            return undefined;
+        if (typeChild.type === 'struct_type')
+            return 'struct';
+        if (typeChild.type === 'interface_type')
+            return 'interface';
+        return undefined;
+    },
+    getReceiverType: (node, source) => {
+        // Go method_declaration has a "receiver" field: func (sl *scrapeLoop) run(...)
+        // The receiver is a parameter_list containing a parameter_declaration
+        // with a type that may be a pointer_type (*scrapeLoop) or plain type (scrapeLoop)
+        const receiver = (0, tree_sitter_helpers_1.getChildByField)(node, 'receiver');
+        if (!receiver)
+            return undefined;
+        // Find the type identifier inside the receiver
+        const text = (0, tree_sitter_helpers_1.getNodeText)(receiver, source);
+        // Extract type name from patterns like "(sl *Type)", "(sl Type)", "(*Type)", "(Type)"
+        const match = text.match(/\*?\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/);
+        return match?.[1];
+    },
+};
+//# sourceMappingURL=go.js.map

package/dist/extraction/languages/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Per-language extraction configurations.
+ *
+ * Each file exports a LanguageExtractor config object.
+ * This barrel builds the EXTRACTORS map consumed by TreeSitterExtractor.
+ */
+import { Language } from '../../types'
+import type { LanguageExtractor } from '../tree-sitter-types'
+export declare const EXTRACTORS: Partial<Record<Language, LanguageExtractor>>
+//# sourceMappingURL=index.d.ts.map

package/dist/extraction/languages/index.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Per-language extraction configurations.
+ *
+ * Each file exports a LanguageExtractor config object.
+ * This barrel builds the EXTRACTORS map consumed by TreeSitterExtractor.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTRACTORS = void 0;
+const typescript_1 = require("./typescript");
+const javascript_1 = require("./javascript");
+const python_1 = require("./python");
+const go_1 = require("./go");
+const rust_1 = require("./rust");
+const java_1 = require("./java");
+const c_cpp_1 = require("./c-cpp");
+const csharp_1 = require("./csharp");
+const php_1 = require("./php");
+const ruby_1 = require("./ruby");
+const swift_1 = require("./swift");
+const kotlin_1 = require("./kotlin");
+const dart_1 = require("./dart");
+const pascal_1 = require("./pascal");
+const scala_1 = require("./scala");
+const lua_1 = require("./lua");
+const luau_1 = require("./luau");
+exports.EXTRACTORS = {
+    typescript: typescript_1.typescriptExtractor,
+    tsx: typescript_1.typescriptExtractor,
+    javascript: javascript_1.javascriptExtractor,
+    jsx: javascript_1.javascriptExtractor,
+    python: python_1.pythonExtractor,
+    go: go_1.goExtractor,
+    rust: rust_1.rustExtractor,
+    java: java_1.javaExtractor,
+    c: c_cpp_1.cExtractor,
+    cpp: c_cpp_1.cppExtractor,
+    csharp: csharp_1.csharpExtractor,
+    php: php_1.phpExtractor,
+    ruby: ruby_1.rubyExtractor,
+    swift: swift_1.swiftExtractor,
+    kotlin: kotlin_1.kotlinExtractor,
+    dart: dart_1.dartExtractor,
+    pascal: pascal_1.pascalExtractor,
+    scala: scala_1.scalaExtractor,
+    lua: lua_1.luaExtractor,
+    luau: luau_1.luauExtractor,
+};
+//# sourceMappingURL=index.js.map

package/dist/extraction/languages/java.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types'
+export declare const javaExtractor: LanguageExtractor
+//# sourceMappingURL=java.d.ts.map

package/dist/extraction/languages/java.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javaExtractor = void 0;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+exports.javaExtractor = {
+    functionTypes: [],
+    classTypes: ['class_declaration'],
+    methodTypes: ['method_declaration', 'constructor_declaration'],
+    interfaceTypes: ['interface_declaration'],
+    structTypes: [],
+    enumTypes: ['enum_declaration'],
+    enumMemberTypes: ['enum_constant'],
+    typeAliasTypes: [],
+    importTypes: ['import_declaration'],
+    callTypes: ['method_invocation'],
+    variableTypes: ['local_variable_declaration'],
+    fieldTypes: ['field_declaration'],
+    nameField: 'name',
+    bodyField: 'body',
+    paramsField: 'parameters',
+    returnField: 'type',
+    getSignature: (node, source) => {
+        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'parameters');
+        const returnType = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+        if (!params)
+            return undefined;
+        const paramsText = (0, tree_sitter_helpers_1.getNodeText)(params, source);
+        return returnType ? (0, tree_sitter_helpers_1.getNodeText)(returnType, source) + ' ' + paramsText : paramsText;
+    },
+    getVisibility: (node) => {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.type === 'modifiers') {
+                const text = child.text;
+                if (text.includes('public'))
+                    return 'public';
+                if (text.includes('private'))
+                    return 'private';
+                if (text.includes('protected'))
+                    return 'protected';
+            }
+        }
+        return undefined;
+    },
+    isStatic: (node) => {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.type === 'modifiers' && child.text.includes('static')) {
+                return true;
+            }
+        }
+        return false;
+    },
+    extractImport: (node, source) => {
+        const importText = source.substring(node.startIndex, node.endIndex).trim();
+        const scopedId = node.namedChildren.find((c) => c.type === 'scoped_identifier');
+        if (scopedId) {
+            const moduleName = source.substring(scopedId.startIndex, scopedId.endIndex);
+            return { moduleName, signature: importText };
+        }
+        return null;
+    },
+};
+//# sourceMappingURL=java.js.map

package/dist/extraction/languages/javascript.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types'
+export declare const javascriptExtractor: LanguageExtractor
+//# sourceMappingURL=javascript.d.ts.map