@saluzi/codegraph 0.1.0

package/dist/extraction/languages/javascript.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascriptExtractor = void 0;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+exports.javascriptExtractor = {
+    functionTypes: ['function_declaration', 'arrow_function', 'function_expression'],
+    classTypes: ['class_declaration'],
+    methodTypes: ['method_definition', 'field_definition'],
+    interfaceTypes: [],
+    structTypes: [],
+    enumTypes: [],
+    typeAliasTypes: [],
+    importTypes: ['import_statement'],
+    callTypes: ['call_expression'],
+    variableTypes: ['lexical_declaration', 'variable_declaration'],
+    nameField: 'name',
+    bodyField: 'body',
+    resolveBody: (node, bodyField) => {
+        // field_definition (arrow function class fields) nest the body inside
+        // an arrow_function or function_expression child:
+        //   field_definition → arrow_function → body (statement_block)
+        // Also handles wrapper patterns like: field = throttle((e) => { ... })
+        //   field_definition → call_expression → arguments → arrow_function → body
+        if (node.type === 'field_definition') {
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (!child)
+                    continue;
+                if (child.type === 'arrow_function' || child.type === 'function_expression') {
+                    return (0, tree_sitter_helpers_1.getChildByField)(child, bodyField);
+                }
+                if (child.type === 'call_expression') {
+                    const args = (0, tree_sitter_helpers_1.getChildByField)(child, 'arguments');
+                    if (args) {
+                        for (let j = 0; j < args.namedChildCount; j++) {
+                            const arg = args.namedChild(j);
+                            if (arg && (arg.type === 'arrow_function' || arg.type === 'function_expression')) {
+                                return (0, tree_sitter_helpers_1.getChildByField)(arg, bodyField);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return null;
+    },
+    paramsField: 'parameters',
+    getSignature: (node, source) => {
+        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'parameters');
+        return params ? (0, tree_sitter_helpers_1.getNodeText)(params, source) : undefined;
+    },
+    isExported: (node, _source) => {
+        let current = node.parent;
+        while (current) {
+            if (current.type === 'export_statement')
+                return true;
+            current = current.parent;
+        }
+        return false;
+    },
+    isAsync: (node) => {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.type === 'async')
+                return true;
+        }
+        return false;
+    },
+    isConst: (node) => {
+        if (node.type === 'lexical_declaration') {
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child?.type === 'const')
+                    return true;
+            }
+        }
+        return false;
+    },
+    extractImport: (node, source) => {
+        const sourceField = node.childForFieldName('source');
+        if (sourceField) {
+            const moduleName = source.substring(sourceField.startIndex, sourceField.endIndex).replace(/['"]/g, '');
+            if (moduleName) {
+                return { moduleName, signature: source.substring(node.startIndex, node.endIndex).trim() };
+            }
+        }
+        return null;
+    },
+};
+//# sourceMappingURL=javascript.js.map

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

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

package/dist/extraction/languages/kotlin.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinExtractor = void 0;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+/** Check if a node matches the `fun interface` misparse pattern */
+function isFunInterfaceNode(node) {
+    let hasFun = false;
+    let hasInterfaceType = false;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'fun' && !child.isNamed)
+            hasFun = true;
+        if (child.type === 'user_type') {
+            const typeId = child.namedChildren.find((c) => c.type === 'type_identifier');
+            if (typeId && typeId.text === 'interface')
+                hasInterfaceType = true;
+        }
+        // Pattern 2b: user_type("interface") is inside an ERROR child
+        if (child.type === 'ERROR') {
+            for (let j = 0; j < child.childCount; j++) {
+                const gc = child.child(j);
+                if (gc && gc.type === 'user_type') {
+                    const typeId = gc.namedChildren.find((c) => c.type === 'type_identifier');
+                    if (typeId && typeId.text === 'interface')
+                        hasInterfaceType = true;
+                }
+            }
+        }
+    }
+    return hasFun && hasInterfaceType;
+}
+exports.kotlinExtractor = {
+    functionTypes: ['function_declaration'],
+    classTypes: ['class_declaration'],
+    methodTypes: ['function_declaration'], // Methods are functions inside classes
+    interfaceTypes: [], // Handled via classifyClassNode
+    structTypes: [], // Kotlin uses data classes
+    enumTypes: [], // Handled via classifyClassNode
+    enumMemberTypes: ['enum_entry'],
+    typeAliasTypes: ['type_alias'],
+    importTypes: ['import_header'],
+    callTypes: ['call_expression'],
+    variableTypes: ['property_declaration'],
+    fieldTypes: ['property_declaration'],
+    extraClassNodeTypes: ['object_declaration'],
+    nameField: 'simple_identifier',
+    bodyField: 'function_body',
+    visitNode: (node, ctx) => {
+        // Handle Kotlin `fun interface` declarations.
+        // Tree-sitter-kotlin doesn't support `fun interface` syntax (Kotlin 1.4+).
+        // It produces two different misparse patterns:
+        //   Pattern 1 (simple): ERROR node + sibling lambda_literal for body
+        //   Pattern 2 (complex): function_declaration misparse with ERROR child
+        // Skip lambda_literal bodies that were already consumed by a fun interface ERROR node
+        if (node.type === 'lambda_literal') {
+            const prev = node.previousSibling;
+            if (prev && prev.type === 'ERROR' && isFunInterfaceNode(prev))
+                return true;
+            return false;
+        }
+        if (node.type !== 'ERROR' && node.type !== 'function_declaration')
+            return false;
+        // Skip ERROR nodes that are class bodies (start with `{`). These contain parent
+        // methods + trailing `fun interface` tokens. The methods are extracted via
+        // resolveBody; handling the ERROR here would consume the whole body.
+        if (node.type === 'ERROR') {
+            const firstChild = node.child(0);
+            if (firstChild && firstChild.type === '{')
+                return false;
+        }
+        if (!isFunInterfaceNode(node))
+            return false;
+        // Extract the interface name.
+        // For function_declaration misparses (patterns 2a/2b), the real name is inside
+        // an ERROR child — direct simple_identifier children are the misparsed method name.
+        let nameText = null;
+        if (node.type === 'function_declaration') {
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child && child.type === 'ERROR') {
+                    for (let j = 0; j < child.childCount; j++) {
+                        const gc = child.child(j);
+                        if (gc && gc.type === 'simple_identifier') {
+                            nameText = gc.text;
+                            break;
+                        }
+                    }
+                    if (nameText)
+                        break;
+                }
+            }
+        }
+        // Fallback: direct simple_identifier child (Pattern 1: ERROR node at top level)
+        if (!nameText) {
+            for (let i = 0; i < node.childCount; i++) {
+                const child = node.child(i);
+                if (child && child.type === 'simple_identifier') {
+                    nameText = child.text;
+                    break;
+                }
+            }
+        }
+        if (!nameText)
+            return false;
+        // Create the interface node
+        const ifaceNode = ctx.createNode('interface', nameText, node);
+        if (!ifaceNode)
+            return false;
+        ctx.pushScope(ifaceNode.id);
+        if (node.type === 'ERROR') {
+            // Pattern 1: body is in the next sibling lambda_literal
+            const nextSibling = node.nextSibling;
+            if (nextSibling && nextSibling.type === 'lambda_literal') {
+                for (let i = 0; i < nextSibling.namedChildCount; i++) {
+                    const child = nextSibling.namedChild(i);
+                    if (child && child.type === 'statements') {
+                        for (let j = 0; j < child.namedChildCount; j++) {
+                            const stmt = child.namedChild(j);
+                            if (stmt)
+                                ctx.visitNode(stmt);
+                        }
+                    }
+                }
+            }
+        }
+        // Pattern 2 (function_declaration): nested classes are siblings at source_file level,
+        // already visited by the normal traversal. The single abstract method is misparsed
+        // and cannot be reliably recovered, but the interface node itself is the key value.
+        ctx.popScope();
+        return true;
+    },
+    paramsField: 'function_value_parameters',
+    returnField: 'type',
+    resolveBody: (node, _bodyField) => {
+        // Kotlin's tree-sitter grammar doesn't use field names, so getChildByField fails.
+        // Find body by type: function_body for functions/methods, class_body for classes,
+        // enum_class_body for enums.
+        //
+        // Special case: when a class/interface contains a nested `fun interface`, tree-sitter
+        // misparsed the parent's body as an ERROR node (starting with `{`) and creates
+        // a class_body sibling for the nested interface's body. Prefer the ERROR body
+        // so the parent's methods are extracted.
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && child.type === 'ERROR') {
+                const firstChild = child.child(0);
+                if (firstChild && firstChild.type === '{') {
+                    return child;
+                }
+            }
+            if (child && (child.type === 'function_body' || child.type === 'class_body' || child.type === 'enum_class_body')) {
+                return child;
+            }
+        }
+        return null;
+    },
+    classifyClassNode: (node) => {
+        // Kotlin reuses class_declaration for classes, interfaces, and enums.
+        // Detect by checking for keyword children:
+        //   interface Foo { }       → has 'interface' keyword child
+        //   enum class Level { }    → has 'enum' keyword child
+        //   class / data class / abstract class → default 'class'
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (!child)
+                continue;
+            if (child.type === 'interface')
+                return 'interface';
+            if (child.type === 'enum')
+                return 'enum';
+        }
+        return 'class';
+    },
+    getReceiverType: (node, source) => {
+        // Kotlin extension functions: fun Type.method() { }
+        // AST: function_declaration > user_type, ".", simple_identifier
+        // The user_type before the dot is the receiver type.
+        let foundUserType = null;
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (!child)
+                continue;
+            if (child.type === 'user_type') {
+                foundUserType = child;
+            }
+            else if (child.type === '.' && foundUserType) {
+                // The user_type before the dot is the receiver type
+                const typeId = foundUserType.namedChildren.find((c) => c.type === 'type_identifier');
+                return typeId ? (0, tree_sitter_helpers_1.getNodeText)(typeId, source) : (0, tree_sitter_helpers_1.getNodeText)(foundUserType, source);
+            }
+            else if (child.type === 'simple_identifier' || child.type === 'function_value_parameters') {
+                // Past the function name — no receiver
+                break;
+            }
+        }
+        return undefined;
+    },
+    getSignature: (node, source) => {
+        // Kotlin function signature: fun name(params): ReturnType
+        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'function_value_parameters');
+        const returnType = (0, tree_sitter_helpers_1.getChildByField)(node, 'type');
+        if (!params)
+            return undefined;
+        let sig = (0, tree_sitter_helpers_1.getNodeText)(params, source);
+        if (returnType) {
+            sig += ': ' + (0, tree_sitter_helpers_1.getNodeText)(returnType, source);
+        }
+        return sig;
+    },
+    getVisibility: (node) => {
+        // Check for visibility modifiers in Kotlin
+        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';
+                if (text.includes('internal'))
+                    return 'internal';
+            }
+        }
+        return 'public'; // Kotlin defaults to public
+    },
+    isStatic: (_node) => {
+        // Kotlin doesn't have static, uses companion objects
+        return false;
+    },
+    isAsync: (node) => {
+        // Kotlin uses suspend keyword for coroutines
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.type === 'modifiers' && child.text.includes('suspend')) {
+                return true;
+            }
+        }
+        return false;
+    },
+    extractImport: (node, source) => {
+        const importText = source.substring(node.startIndex, node.endIndex).trim();
+        const identifier = node.namedChildren.find((c) => c.type === 'identifier');
+        if (identifier) {
+            return { moduleName: source.substring(identifier.startIndex, identifier.endIndex), signature: importText };
+        }
+        return null;
+    },
+};
+//# sourceMappingURL=kotlin.js.map

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

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

package/dist/extraction/languages/lua.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.luaExtractor = void 0;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+// Node names follow the vendored ABI-15 grammar (@tree-sitter-grammars/
+// tree-sitter-lua), NOT the older tree-sitter-wasms build — see grammars.ts.
+/** First descendant of a given type (breadth-first), or null. */
+function findDescendant(node, type) {
+    const queue = [...node.namedChildren];
+    while (queue.length) {
+        const n = queue.shift();
+        if (n.type === type)
+            return n;
+        queue.push(...n.namedChildren);
+    }
+    return null;
+}
+/**
+ * If `callNode` is a `require(...)` call, return the module name; otherwise null.
+ * Lua/Luau have no import statement — modules are loaded by calling the global
+ * `require`. Handles both:
+ *   - string requires:  `require("net.http")` / `require "net.http"`  → "net.http"
+ *   - Roblox/Luau path requires: `require(script.Parent.Signal)`      → "Signal"
+ *     (the dominant idiom in Roblox code, where the argument is an instance path
+ *     rather than a string — use the trailing field as the module name).
+ */
+function requireModule(callNode, source) {
+    // function_call > name: <callee>, arguments: arguments
+    const name = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'name');
+    // A dotted/colon callee (e.g. `socket.connect`) is dot/method_index_expression,
+    // never a bare `require`.
+    if (!name || name.type !== 'identifier')
+        return null;
+    if ((0, tree_sitter_helpers_1.getNodeText)(name, source) !== 'require')
+        return null;
+    const args = (0, tree_sitter_helpers_1.getChildByField)(callNode, 'arguments');
+    if (!args)
+        return null;
+    // String require — `string > content: string_content` gives the bare name.
+    const content = findDescendant(args, 'string_content');
+    if (content)
+        return (0, tree_sitter_helpers_1.getNodeText)(content, source).trim() || null;
+    const str = findDescendant(args, 'string');
+    if (str) {
+        const mod = (0, tree_sitter_helpers_1.getNodeText)(str, source)
+            .trim()
+            .replace(/^\[\[/, '')
+            .replace(/\]\]$/, '')
+            .replace(/^["']/, '')
+            .replace(/["']$/, '');
+        if (mod)
+            return mod;
+    }
+    // Roblox/Luau instance-path require: `require(script.Parent.Signal)` → "Signal".
+    const idx = findDescendant(args, 'dot_index_expression') ?? findDescendant(args, 'method_index_expression');
+    if (idx) {
+        const field = (0, tree_sitter_helpers_1.getChildByField)(idx, 'field') ?? (0, tree_sitter_helpers_1.getChildByField)(idx, 'method');
+        if (field)
+            return (0, tree_sitter_helpers_1.getNodeText)(field, source).trim() || null;
+    }
+    return null;
+}
+exports.luaExtractor = {
+    // function_declaration covers global (`function f`), table (`function t.f`),
+    // method (`function t:m`), and local (`local function f`) forms — the form is
+    // distinguished by the `name:` child (identifier / dot_index_expression /
+    // method_index_expression) and a `local` token, not by separate node types.
+    // Anonymous `function() ... end` (function_definition) has no name and is
+    // captured via its enclosing variable instead.
+    functionTypes: ['function_declaration'],
+    classTypes: [], // Lua has no classes/structs/interfaces/enums — tables are used for everything
+    methodTypes: [],
+    interfaceTypes: [],
+    structTypes: [],
+    enumTypes: [],
+    typeAliasTypes: [],
+    importTypes: [], // `require` is a function_call — handled in visitNode below
+    callTypes: ['function_call'],
+    variableTypes: ['variable_declaration'], // see the `lua` branch in extractVariable
+    nameField: 'name',
+    bodyField: 'body',
+    paramsField: 'parameters',
+    getSignature: (node, source) => {
+        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'parameters');
+        return params ? (0, tree_sitter_helpers_1.getNodeText)(params, source) : undefined;
+    },
+    // `function t.f()` / `function t:m()` are methods on table `t`: return the
+    // table as the receiver so they extract as methods with a `t::f` qualified
+    // name. Plain `function f()` / `local function f()` have no receiver and stay
+    // functions. (For `a.b.c`, the receiver is the nested `a.b`.)
+    getReceiverType: (node, source) => {
+        const name = (0, tree_sitter_helpers_1.getChildByField)(node, 'name');
+        if (name && (name.type === 'dot_index_expression' || name.type === 'method_index_expression')) {
+            const table = (0, tree_sitter_helpers_1.getChildByField)(name, 'table');
+            if (table)
+                return (0, tree_sitter_helpers_1.getNodeText)(table, source);
+        }
+        return undefined;
+    },
+    // Emit import nodes for `require(...)`. The local-declaration form is handled
+    // explicitly because the variable branch skips the initializer subtree; bare
+    // and global `require` calls are caught when the walker reaches the
+    // function_call node.
+    visitNode: (node, ctx) => {
+        const source = ctx.source;
+        const emit = (callNode) => {
+            const mod = requireModule(callNode, source);
+            if (!mod)
+                return;
+            const imp = ctx.createNode('import', mod, callNode, {
+                signature: (0, tree_sitter_helpers_1.getNodeText)(callNode, source).trim().slice(0, 100),
+            });
+            if (imp && ctx.nodeStack.length > 0) {
+                const parentId = ctx.nodeStack[ctx.nodeStack.length - 1];
+                if (parentId) {
+                    ctx.addUnresolvedReference({
+                        fromNodeId: parentId,
+                        referenceName: mod,
+                        referenceKind: 'imports',
+                        line: callNode.startPosition.row + 1,
+                        column: callNode.startPosition.column,
+                    });
+                }
+            }
+        };
+        // Bare / global `require("x")` — claim it so it isn't double-counted as a call.
+        if (node.type === 'function_call') {
+            if (requireModule(node, source)) {
+                emit(node);
+                return true;
+            }
+            return false;
+        }
+        // `local x = require("x")` — variable_declaration wraps an assignment_statement
+        // whose initializer subtree the variable branch will skip, so dig it out here.
+        if (node.type === 'variable_declaration') {
+            const assign = node.namedChildren.find((c) => c.type === 'assignment_statement');
+            const exprList = assign?.namedChildren.find((c) => c.type === 'expression_list');
+            if (exprList) {
+                for (const val of exprList.namedChildren) {
+                    if (val.type === 'function_call')
+                        emit(val);
+                }
+            }
+            return false;
+        }
+        return false;
+    },
+};
+//# sourceMappingURL=lua.js.map

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

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

package/dist/extraction/languages/luau.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.luauExtractor = void 0;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+const lua_1 = require("./lua");
+// Luau (https://luau.org) is a gradually-typed superset of Lua. The
+// tree-sitter-luau grammar reuses the same node names as the vendored Lua
+// grammar (function_declaration, variable_declaration, function_call,
+// dot/method_index_expression, …), so the Luau extractor extends the Lua one
+// and adds the type-system pieces Luau introduces:
+//   - `type X = ...` / `export type X = ...`  → type_definition (type_alias)
+//   - typed parameters and return types        → richer signatures
+//
+// require detection, receiver-splitting (t.f / t:m → methods), and local
+// variable extraction are inherited unchanged from luaExtractor. The shared
+// `extractVariable` core branch is gated on `lua` || `luau`.
+exports.luauExtractor = {
+    ...lua_1.luaExtractor,
+    // `type X = ...` and `export type X = ...`
+    typeAliasTypes: ['type_definition'],
+    // Only Luau `export type` is exported; the keyword leads the node.
+    isExported: (node, source) => source.slice(node.startIndex, node.startIndex + 7) === 'export ',
+    // Params + Luau return type (the named child after `parameters`, before the body).
+    getSignature: (node, source) => {
+        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'parameters');
+        if (!params)
+            return undefined;
+        let sig = (0, tree_sitter_helpers_1.getNodeText)(params, source);
+        const kids = node.namedChildren;
+        const idx = kids.findIndex((c) => c.startIndex === params.startIndex);
+        const ret = idx >= 0 ? kids[idx + 1] : null;
+        if (ret && ret.type !== 'block')
+            sig += `: ${(0, tree_sitter_helpers_1.getNodeText)(ret, source)}`;
+        return sig;
+    },
+};
+//# sourceMappingURL=luau.js.map

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

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

package/dist/extraction/languages/pascal.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pascalExtractor = void 0;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+exports.pascalExtractor = {
+    functionTypes: ['declProc'],
+    classTypes: ['declClass'],
+    methodTypes: ['declProc'],
+    interfaceTypes: ['declIntf'],
+    structTypes: [],
+    enumTypes: ['declEnum'],
+    typeAliasTypes: ['declType'],
+    importTypes: ['declUses'],
+    callTypes: ['exprCall'],
+    variableTypes: ['declField', 'declConst'],
+    nameField: 'name',
+    bodyField: 'body',
+    paramsField: 'args',
+    returnField: 'type',
+    getSignature: (node, source) => {
+        const args = (0, tree_sitter_helpers_1.getChildByField)(node, 'args');
+        const returnType = node.namedChildren.find((c) => c.type === 'typeref');
+        if (!args && !returnType)
+            return undefined;
+        let sig = '';
+        if (args)
+            sig = (0, tree_sitter_helpers_1.getNodeText)(args, source);
+        if (returnType) {
+            sig += ': ' + (0, tree_sitter_helpers_1.getNodeText)(returnType, source);
+        }
+        return sig || undefined;
+    },
+    getVisibility: (node) => {
+        let current = node.parent;
+        while (current) {
+            if (current.type === 'declSection') {
+                for (let i = 0; i < current.childCount; i++) {
+                    const child = current.child(i);
+                    if (child?.type === 'kPublic' || child?.type === 'kPublished')
+                        return 'public';
+                    if (child?.type === 'kPrivate')
+                        return 'private';
+                    if (child?.type === 'kProtected')
+                        return 'protected';
+                }
+            }
+            current = current.parent;
+        }
+        return undefined;
+    },
+    isExported: (_node, _source) => {
+        // In Pascal, symbols declared in the interface section are exported
+        return false;
+    },
+    isStatic: (node) => {
+        for (let i = 0; i < node.childCount; i++) {
+            if (node.child(i)?.type === 'kClass')
+                return true;
+        }
+        return false;
+    },
+    isConst: (node) => {
+        return node.type === 'declConst';
+    },
+};
+//# sourceMappingURL=pascal.js.map

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

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