@liendev/parser 0.45.0 → 0.47.0

package/README.md

@@ -6,7 +6,7 @@ This package provides the core parsing and analysis capabilities used by Lien's
 
 ## Features
 
-- **AST Parsing** — Tree-sitter-based parsing for TypeScript, JavaScript, Python, PHP, Rust, and Go
+- **AST Parsing** — Tree-sitter-based parsing for TypeScript, JavaScript, Python, PHP, Rust, Go, Java, C#, Ruby, and Kotlin
 - **Semantic Chunking** — Split code into meaningful chunks respecting function/class boundaries
 - **Complexity Analysis** — Cyclomatic, cognitive, and Halstead complexity metrics
 - **Dependency Analysis** — Import/export tracking with transitive dependent resolution
@@ -24,8 +24,12 @@ This package provides the core parsing and analysis capabilities used by Lien's
 | PHP | Yes | Yes | Yes |
 | Rust | Yes | Yes | Yes |
 | Go | Yes | Yes | Yes |
+| Java | Yes | Yes | Yes |
+| C# | Yes | Yes | Yes |
+| Ruby | Yes | Yes | Yes |
+| Kotlin | Yes | Yes | Yes |
 
-Line-based chunking and symbol extraction are available for additional languages including Java, C#, Ruby, and Vue.
+Line-based chunking and symbol extraction are available for additional languages including Vue, Liquid, C/C++, Swift, Scala, and Markdown.
 
 ## Usage
 

package/dist/ast/extractors/symbol-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-helpers.d.ts","sourceRoot":"","sources":["../../../src/ast/extractors/symbol-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA0BjF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAerF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK/F"}
+{"version":3,"file":"symbol-helpers.d.ts","sourceRoot":"","sources":["../../../src/ast/extractors/symbol-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAqCjF;AASD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAerF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK/F"}

package/dist/ast/extractors/symbol-helpers.js

@@ -2,7 +2,22 @@
  * Extract function/method signature
  */
 export function extractSignature(node, content) {
-    // Get the first line of the function (up to opening brace or arrow)
+    // Preferred: bound the signature by where the function body begins. This is
+    // language-agnostic — it works for brace languages (`… ) {`), colon languages
+    // (Python `… ):`), and `end` languages (Ruby `def … )`). The legacy brace/arrow
+    // scan below walked an entire no-brace body into the "signature" (e.g. Python,
+    // Ruby), which this avoids.
+    const bodyNode = node.childForFieldName('body');
+    if (bodyNode) {
+        const signature = content
+            .slice(node.startIndex, bodyNode.startIndex)
+            .replace(/\s+/g, ' ') // collapse newlines/indentation (matches the old join-with-space)
+            .replace(/(\{|=>|:)\s*$/, '') // drop a dangling block-opener if it was captured
+            .trim();
+        return clampSignatureLength(signature);
+    }
+    // Fallback: nodes with no `body` field (e.g. Rust trait signatures, abstract
+    // interface methods). Preserve the original first-line / brace-scan behavior.
     const startLine = node.startPosition.row;
     const lines = content.split('\n');
     let signature = lines[startLine] || '';
@@ -16,11 +31,13 @@ export function extractSignature(node, content) {
     }
     // Clean up signature
     signature = signature.split('{')[0].split('=>')[0].trim();
-    // Limit length
-    if (signature.length > 200) {
-        signature = signature.substring(0, 197) + '...';
-    }
-    return signature;
+    return clampSignatureLength(signature);
+}
+/**
+ * Truncate an over-long signature to keep stored chunks compact.
+ */
+function clampSignatureLength(signature) {
+    return signature.length > 200 ? signature.substring(0, 197) + '...' : signature;
 }
 /**
  * Extract parameter list from function node

package/dist/ast/extractors/symbol-helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-helpers.js","sourceRoot":"","sources":["../../../src/ast/extractors/symbol-helpers.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAuB,EAAE,OAAe;IACvE,oEAAoE;IACpE,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC;IACzC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAEvC,wEAAwE;IACxE,IAAI,WAAW,GAAG,SAAS,CAAC;IAC5B,OACE,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG;QAClC,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC;QACxB,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,EACzB,CAAC;QACD,WAAW,EAAE,CAAC;QACd,SAAS,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;IAChD,CAAC;IAED,qBAAqB;IACrB,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAE1D,eAAe;IACf,IAAI,SAAS,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;QAC3B,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC;IAClD,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAuB,EAAE,QAAgB;IACzE,MAAM,UAAU,GAAa,EAAE,CAAC;IAEhC,uBAAuB;IACvB,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;IACxD,IAAI,CAAC,UAAU;QAAE,OAAO,UAAU,CAAC;IAEnC,2BAA2B;IAC3B,KAAK,MAAM,KAAK,IAAI,UAAU,CAAC,aAAa,EAAE,CAAC;QAC7C,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;YACtB,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAuB,EAAE,QAAgB;IACzE,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC;IAC7D,IAAI,CAAC,cAAc;QAAE,OAAO,SAAS,CAAC;IAEtC,OAAO,cAAc,CAAC,IAAI,CAAC;AAC7B,CAAC"}
+{"version":3,"file":"symbol-helpers.js","sourceRoot":"","sources":["../../../src/ast/extractors/symbol-helpers.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAuB,EAAE,OAAe;IACvE,4EAA4E;IAC5E,8EAA8E;IAC9E,gFAAgF;IAChF,+EAA+E;IAC/E,4BAA4B;IAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAChD,IAAI,QAAQ,EAAE,CAAC;QACb,MAAM,SAAS,GAAG,OAAO;aACtB,KAAK,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;aAC3C,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,kEAAkE;aACvF,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,kDAAkD;aAC/E,IAAI,EAAE,CAAC;QACV,OAAO,oBAAoB,CAAC,SAAS,CAAC,CAAC;IACzC,CAAC;IAED,6EAA6E;IAC7E,8EAA8E;IAC9E,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC;IACzC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAEvC,wEAAwE;IACxE,IAAI,WAAW,GAAG,SAAS,CAAC;IAC5B,OACE,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG;QAClC,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC;QACxB,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,EACzB,CAAC;QACD,WAAW,EAAE,CAAC;QACd,SAAS,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;IAChD,CAAC;IAED,qBAAqB;IACrB,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAE1D,OAAO,oBAAoB,CAAC,SAAS,CAAC,CAAC;AACzC,CAAC;AAED;;GAEG;AACH,SAAS,oBAAoB,CAAC,SAAiB;IAC7C,OAAO,SAAS,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AAClF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAuB,EAAE,QAAgB;IACzE,MAAM,UAAU,GAAa,EAAE,CAAC;IAEhC,uBAAuB;IACvB,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;IACxD,IAAI,CAAC,UAAU;QAAE,OAAO,UAAU,CAAC;IAEnC,2BAA2B;IAC3B,KAAK,MAAM,KAAK,IAAI,UAAU,CAAC,aAAa,EAAE,CAAC;QAC7C,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;YACtB,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAuB,EAAE,QAAgB;IACzE,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC;IAC7D,IAAI,CAAC,cAAc;QAAE,OAAO,SAAS,CAAC;IAEtC,OAAO,cAAc,CAAC,IAAI,CAAC;AAC7B,CAAC"}

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

@@ -0,0 +1,83 @@
+import type Parser from 'tree-sitter';
+import type { SymbolInfo } from '../types.js';
+import type { LanguageDefinition } from './types.js';
+import type { LanguageTraverser, DeclarationFunctionInfo } from '../traversers/types.js';
+import type { LanguageExportExtractor, LanguageImportExtractor, LanguageSymbolExtractor } from '../extractors/types.js';
+/**
+ * Kotlin AST traverser.
+ *
+ * Methods live inside `class_declaration` / `object_declaration` bodies
+ * (`class_body` / `enum_class_body`). `companion_object` is transparent — its
+ * members are traversed so their methods are captured (attributed to the
+ * enclosing class). Lambdas can appear in property initializers
+ * (`val f = { … }`).
+ */
+export declare class KotlinTraverser implements LanguageTraverser {
+    targetNodeTypes: string[];
+    containerTypes: string[];
+    declarationTypes: string[];
+    functionTypes: string[];
+    shouldExtractChildren(node: Parser.SyntaxNode): boolean;
+    isDeclarationWithFunction(node: Parser.SyntaxNode): boolean;
+    getContainerBody(node: Parser.SyntaxNode): Parser.SyntaxNode | null;
+    shouldTraverseChildren(node: Parser.SyntaxNode): boolean;
+    findParentContainerName(node: Parser.SyntaxNode): string | undefined;
+    findFunctionInDeclaration(node: Parser.SyntaxNode): DeclarationFunctionInfo;
+}
+/**
+ * Kotlin export extractor.
+ *
+ * Kotlin has no `export` keyword and is `public` by default — top-level
+ * declarations and (non-private/internal) members are importable. Interface
+ * members are implicitly public.
+ */
+export declare class KotlinExportExtractor implements LanguageExportExtractor {
+    extractExports(rootNode: Parser.SyntaxNode): string[];
+    private extractFromNode;
+    private extractMembers;
+    private propertyName;
+}
+/**
+ * Kotlin import extractor.
+ *
+ * Handles `import a.b.C`, wildcard `import a.b.*`, and aliased
+ * `import a.b.C as D`. The grammar nests `import_header` nodes inside an
+ * `import_list`; the engine's import scan descends one level to reach them
+ * (see `collectImportNodes` in ast/symbols.ts). Standard-library imports
+ * (kotlin.*, kotlinx.*, java.*, javax.*) are filtered out.
+ */
+export declare class KotlinImportExtractor implements LanguageImportExtractor {
+    readonly importNodeTypes: string[];
+    extractImportPath(node: Parser.SyntaxNode): string | null;
+    processImportSymbols(node: Parser.SyntaxNode): {
+        importPath: string;
+        symbols: string[];
+    } | null;
+    private getImportPath;
+}
+/**
+ * Kotlin symbol extractor.
+ *
+ * Handles `function_declaration`, `class_declaration` (class / interface / enum
+ * variants — distinguished by the keyword token), and `object_declaration`.
+ * `SymbolInfo.type` only has `function|method|class|interface`, so objects and
+ * enums map to `class` (keeping the keyword in the signature).
+ *
+ * Call sites: `call_expression` — `foo()` (simple_identifier) and `a.b.c()`
+ * (the member is the `simple_identifier` inside the trailing `navigation_suffix`).
+ */
+export declare class KotlinSymbolExtractor implements LanguageSymbolExtractor {
+    readonly symbolNodeTypes: string[];
+    extractSymbol(node: Parser.SyntaxNode, content: string, parentClass?: string): SymbolInfo | null;
+    extractCallSite(node: Parser.SyntaxNode): {
+        symbol: string;
+        line: number;
+        key: string;
+    } | null;
+    private extractFunctionInfo;
+    private extractClassInfo;
+    private extractObjectInfo;
+    private makeSymbol;
+}
+export declare const kotlinDefinition: LanguageDefinition;
+//# sourceMappingURL=kotlin.d.ts.map

package/dist/ast/languages/kotlin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kotlin.d.ts","sourceRoot":"","sources":["../../../src/ast/languages/kotlin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACzF,OAAO,KAAK,EACV,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,wBAAwB,CAAC;AA+HhC;;;;;;;;GAQG;AACH,qBAAa,eAAgB,YAAW,iBAAiB;IACvD,eAAe,WAA4B;IAE3C,cAAc,WAA+C;IAE7D,gBAAgB,WAA4B;IAE5C,aAAa,WAA4C;IAEzD,qBAAqB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,OAAO;IAIvD,yBAAyB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,OAAO;IAI3D,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,GAAG,IAAI;IAKnE,sBAAsB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,OAAO;IASxD,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,GAAG,SAAS;IAWpE,yBAAyB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,uBAAuB;CAS5E;AAMD;;;;;;GAMG;AACH,qBAAa,qBAAsB,YAAW,uBAAuB;IACnE,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,EAAE;IAgBrD,OAAO,CAAC,eAAe;IAmBvB,OAAO,CAAC,cAAc;IAwBtB,OAAO,CAAC,YAAY;CAKrB;AAmBD;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,YAAW,uBAAuB;IACnE,QAAQ,CAAC,eAAe,WAAqB;IAE7C,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,GAAG,IAAI;IAMzD,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI;IAoB/F,OAAO,CAAC,aAAa;CAMtB;AAMD;;;;;;;;;;GAUG;AACH,qBAAa,qBAAsB,YAAW,uBAAuB;IACnE,QAAQ,CAAC,eAAe,WAAuE;IAE/F,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAahG,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAoB9F,OAAO,CAAC,mBAAmB;IAqB3B,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,UAAU;CAcnB;AAMD,eAAO,MAAM,gBAAgB,EAAE,kBAoH9B,CAAC"}

package/dist/ast/languages/kotlin.js

@@ -0,0 +1,506 @@
+import Kotlin from 'tree-sitter-kotlin';
+import { calculateComplexity } from '../complexity/index.js';
+// =============================================================================
+// HELPERS
+//
+// The tree-sitter-kotlin grammar (fwcd) does NOT assign field names, so unlike
+// the Java definition we locate children by node TYPE rather than via
+// `childForFieldName`. These helpers centralize that.
+// =============================================================================
+/** First named child of a given type. */
+function childByType(node, type) {
+    return node.namedChildren.find(child => child.type === type) ?? null;
+}
+/** Whether a node has a child token of a given type (incl. anonymous keyword tokens). */
+function hasTokenChild(node, type) {
+    return node.children.some(child => child.type === type);
+}
+/**
+ * The function-valued initializer of a property, if the property's initializer
+ * is *directly* a lambda or anonymous function (`val f = { … }`). Checks the
+ * initializer (the last named child) rather than any descendant, so a lambda
+ * passed as a call argument (`val n = xs.count { it > 0 }`) is NOT treated as a
+ * function-valued property.
+ */
+function propertyInitializerFunction(node) {
+    const initializer = node.namedChildren.at(-1);
+    if (!initializer)
+        return null;
+    return initializer.type === 'lambda_literal' || initializer.type === 'anonymous_function'
+        ? initializer
+        : null;
+}
+/** The `function_body` child of a function_declaration ({ … } block OR `= expr`). */
+function functionBody(node) {
+    return childByType(node, 'function_body');
+}
+/**
+ * The function name: the first direct `simple_identifier` child of a
+ * function_declaration. (Extension-function receivers are `user_type` nodes, so
+ * the bare simple_identifier is the name in the common case.)
+ */
+function functionName(node) {
+    return childByType(node, 'simple_identifier')?.text;
+}
+/** The declared name of a class/object declaration (`type_identifier`). */
+function declarationName(node) {
+    return childByType(node, 'type_identifier')?.text;
+}
+const SIGNATURE_MAX = 200;
+function clamp(signature) {
+    return signature.length > SIGNATURE_MAX
+        ? signature.slice(0, SIGNATURE_MAX - 3) + '...'
+        : signature;
+}
+/**
+ * Function signature, bounded by where the body begins. `function_body` covers
+ * both block bodies (`{ … }`) and expression bodies (`= expr`, which starts at
+ * the `=`), so slicing up to its start yields a clean `fun foo(a: Int): Int`
+ * for both. Abstract/interface methods have no body — use the whole node.
+ */
+function functionSignature(node, content) {
+    const body = functionBody(node);
+    const end = body ? body.startIndex : node.endIndex;
+    const signature = content
+        .slice(node.startIndex, end)
+        .replace(/\s+/g, ' ')
+        .replace(/(\{|=)\s*$/, '') // drop a trailing block-opener / expression `=` if captured
+        .trim();
+    return clamp(signature);
+}
+/** Parameter texts from a function's `function_value_parameters`. */
+function functionParameters(node) {
+    const params = childByType(node, 'function_value_parameters');
+    if (!params)
+        return [];
+    return params.namedChildren.filter(p => p.text.trim()).map(p => p.text);
+}
+/**
+ * Return type: the type node that sits between the parameter list and the body.
+ * Kotlin's grammar emits it as `user_type` / `nullable_type` / `function_type`.
+ */
+function functionReturnType(node) {
+    const children = node.namedChildren;
+    const paramsIndex = children.findIndex(c => c.type === 'function_value_parameters');
+    if (paramsIndex === -1)
+        return undefined;
+    for (let i = paramsIndex + 1; i < children.length; i++) {
+        const c = children[i];
+        if (c.type === 'function_body')
+            break;
+        if (c.type === 'user_type' || c.type === 'nullable_type' || c.type === 'function_type') {
+            return c.text;
+        }
+    }
+    return undefined;
+}
+/** Visibility modifier text (`private` / `internal` / `protected` / `public`), if any. */
+function visibilityModifier(node) {
+    const modifiers = childByType(node, 'modifiers');
+    if (!modifiers)
+        return null;
+    return modifiers.namedChildren.find(c => c.type === 'visibility_modifier')?.text ?? null;
+}
+/**
+ * Kotlin declarations are `public` by default. We treat a declaration as
+ * "exported" (importable / part of the API) unless it is explicitly `private`
+ * or `internal`. `protected` members stay visible to subclasses, so we keep
+ * them. (Inverse of Java's "has a `public` modifier" check.)
+ */
+function isExported(node) {
+    const visibility = visibilityModifier(node);
+    return visibility !== 'private' && visibility !== 'internal';
+}
+// =============================================================================
+// TRAVERSER
+// =============================================================================
+/**
+ * Kotlin AST traverser.
+ *
+ * Methods live inside `class_declaration` / `object_declaration` bodies
+ * (`class_body` / `enum_class_body`). `companion_object` is transparent — its
+ * members are traversed so their methods are captured (attributed to the
+ * enclosing class). Lambdas can appear in property initializers
+ * (`val f = { … }`).
+ */
+export class KotlinTraverser {
+    targetNodeTypes = ['function_declaration'];
+    containerTypes = ['class_declaration', 'object_declaration'];
+    declarationTypes = ['property_declaration'];
+    functionTypes = ['lambda_literal', 'anonymous_function'];
+    shouldExtractChildren(node) {
+        return this.containerTypes.includes(node.type);
+    }
+    isDeclarationWithFunction(node) {
+        return node.type === 'property_declaration' && propertyInitializerFunction(node) !== null;
+    }
+    getContainerBody(node) {
+        if (!this.containerTypes.includes(node.type))
+            return null;
+        return childByType(node, 'class_body') ?? childByType(node, 'enum_class_body');
+    }
+    shouldTraverseChildren(node) {
+        return (node.type === 'source_file' ||
+            node.type === 'class_body' ||
+            node.type === 'enum_class_body' ||
+            node.type === 'companion_object');
+    }
+    findParentContainerName(node) {
+        let current = node.parent;
+        while (current) {
+            if (current.type === 'class_declaration' || current.type === 'object_declaration') {
+                return declarationName(current);
+            }
+            current = current.parent;
+        }
+        return undefined;
+    }
+    findFunctionInDeclaration(node) {
+        if (node.type !== 'property_declaration') {
+            return { hasFunction: false, functionNode: null };
+        }
+        const fn = propertyInitializerFunction(node);
+        return fn
+            ? { hasFunction: true, functionNode: fn }
+            : { hasFunction: false, functionNode: null };
+    }
+}
+// =============================================================================
+// EXPORT EXTRACTOR
+// =============================================================================
+/**
+ * Kotlin export extractor.
+ *
+ * Kotlin has no `export` keyword and is `public` by default — top-level
+ * declarations and (non-private/internal) members are importable. Interface
+ * members are implicitly public.
+ */
+export class KotlinExportExtractor {
+    extractExports(rootNode) {
+        const exports = [];
+        const seen = new Set();
+        const addExport = (name) => {
+            if (name && !seen.has(name)) {
+                seen.add(name);
+                exports.push(name);
+            }
+        };
+        rootNode.namedChildren.forEach(child => this.extractFromNode(child, addExport));
+        return exports;
+    }
+    extractFromNode(node, addExport) {
+        switch (node.type) {
+            case 'function_declaration':
+                if (isExported(node))
+                    addExport(functionName(node));
+                break;
+            case 'property_declaration':
+                if (isExported(node))
+                    addExport(this.propertyName(node));
+                break;
+            case 'class_declaration':
+            case 'object_declaration':
+                // A private/internal container exposes nothing — skip it and its members.
+                if (isExported(node)) {
+                    addExport(declarationName(node));
+                    this.extractMembers(node, addExport);
+                }
+                break;
+        }
+    }
+    extractMembers(container, addExport) {
+        const body = childByType(container, 'class_body') ?? childByType(container, 'enum_class_body');
+        if (!body)
+            return;
+        const isInterface = hasTokenChild(container, 'interface');
+        body.namedChildren.forEach(member => {
+            if (member.type === 'function_declaration') {
+                if (isInterface || isExported(member))
+                    addExport(functionName(member));
+            }
+            else if (member.type === 'property_declaration') {
+                if (isInterface || isExported(member))
+                    addExport(this.propertyName(member));
+            }
+            else if (member.type === 'companion_object') {
+                // Companion members are reached via the enclosing class name → part of its API.
+                member.namedChildren
+                    .filter(m => m.type === 'class_body')
+                    .forEach(cb => cb.namedChildren
+                    .filter(m => m.type === 'function_declaration' && isExported(m))
+                    .forEach(m => addExport(functionName(m))));
+            }
+        });
+    }
+    propertyName(node) {
+        // property_declaration → variable_declaration → simple_identifier
+        const variable = childByType(node, 'variable_declaration');
+        return (variable ? childByType(variable, 'simple_identifier') : null)?.text;
+    }
+}
+// =============================================================================
+// IMPORT EXTRACTOR
+// =============================================================================
+/**
+ * Kotlin/JVM standard-library prefixes that aren't useful as dependency edges.
+ * Note: `kotlinx.*` (coroutines, serialization, …) are separate external
+ * libraries, not the stdlib, so they are kept as real import edges.
+ */
+function isKotlinStdLib(importPath) {
+    return (importPath.startsWith('kotlin.') ||
+        importPath.startsWith('java.') ||
+        importPath.startsWith('javax.'));
+}
+/**
+ * Kotlin import extractor.
+ *
+ * Handles `import a.b.C`, wildcard `import a.b.*`, and aliased
+ * `import a.b.C as D`. The grammar nests `import_header` nodes inside an
+ * `import_list`; the engine's import scan descends one level to reach them
+ * (see `collectImportNodes` in ast/symbols.ts). Standard-library imports
+ * (kotlin.*, kotlinx.*, java.*, javax.*) are filtered out.
+ */
+export class KotlinImportExtractor {
+    importNodeTypes = ['import_header'];
+    extractImportPath(node) {
+        const path = this.getImportPath(node);
+        if (!path || isKotlinStdLib(path))
+            return null;
+        return path;
+    }
+    processImportSymbols(node) {
+        const path = this.getImportPath(node);
+        if (!path || isKotlinStdLib(path))
+            return null;
+        const parts = path.split('.');
+        const lastPart = parts[parts.length - 1];
+        if (lastPart === '*') {
+            const packagePath = parts.slice(0, -1).join('.');
+            const packageName = parts[parts.length - 2];
+            return { importPath: packagePath, symbols: packageName ? [packageName] : [] };
+        }
+        // `import a.b.C as D` — the imported symbol is the alias name when present.
+        // import_alias wraps the alias as a `type_identifier` (its text is `as D`).
+        const alias = childByType(node, 'import_alias');
+        const aliasName = alias ? childByType(alias, 'type_identifier')?.text : undefined;
+        return { importPath: path, symbols: [aliasName ?? lastPart] };
+    }
+    getImportPath(node) {
+        const identifier = childByType(node, 'identifier');
+        if (!identifier)
+            return null;
+        const hasWildcard = hasTokenChild(node, 'wildcard_import');
+        return hasWildcard ? `${identifier.text}.*` : identifier.text;
+    }
+}
+// =============================================================================
+// SYMBOL EXTRACTOR
+// =============================================================================
+/**
+ * Kotlin symbol extractor.
+ *
+ * Handles `function_declaration`, `class_declaration` (class / interface / enum
+ * variants — distinguished by the keyword token), and `object_declaration`.
+ * `SymbolInfo.type` only has `function|method|class|interface`, so objects and
+ * enums map to `class` (keeping the keyword in the signature).
+ *
+ * Call sites: `call_expression` — `foo()` (simple_identifier) and `a.b.c()`
+ * (the member is the `simple_identifier` inside the trailing `navigation_suffix`).
+ */
+export class KotlinSymbolExtractor {
+    symbolNodeTypes = ['function_declaration', 'class_declaration', 'object_declaration'];
+    extractSymbol(node, content, parentClass) {
+        switch (node.type) {
+            case 'function_declaration':
+                return this.extractFunctionInfo(node, content, parentClass);
+            case 'class_declaration':
+                return this.extractClassInfo(node);
+            case 'object_declaration':
+                return this.extractObjectInfo(node);
+            default:
+                return null;
+        }
+    }
+    extractCallSite(node) {
+        if (node.type !== 'call_expression')
+            return null;
+        const line = node.startPosition.row + 1;
+        const callee = node.namedChild(0);
+        if (!callee)
+            return null;
+        let name;
+        if (callee.type === 'simple_identifier') {
+            name = callee.text; // foo()
+        }
+        else if (callee.type === 'navigation_expression') {
+            // a.b.c() — the called member is the simple_identifier in the last navigation_suffix
+            const suffix = callee.namedChildren.filter(c => c.type === 'navigation_suffix').at(-1);
+            name = (suffix ? childByType(suffix, 'simple_identifier') : null)?.text;
+        }
+        if (!name)
+            return null;
+        return { symbol: name, line, key: `${name}:${line}` };
+    }
+    extractFunctionInfo(node, content, parentClass) {
+        const name = functionName(node);
+        if (!name)
+            return null;
+        return {
+            name,
+            type: parentClass ? 'method' : 'function',
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            parentClass,
+            signature: functionSignature(node, content),
+            parameters: functionParameters(node),
+            returnType: functionReturnType(node),
+            complexity: calculateComplexity(node),
+        };
+    }
+    extractClassInfo(node) {
+        const name = declarationName(node);
+        if (!name)
+            return null;
+        if (hasTokenChild(node, 'interface')) {
+            return this.makeSymbol(node, name, 'interface', `interface ${name}`);
+        }
+        if (hasTokenChild(node, 'enum')) {
+            return this.makeSymbol(node, name, 'class', `enum class ${name}`);
+        }
+        return this.makeSymbol(node, name, 'class', `class ${name}`);
+    }
+    extractObjectInfo(node) {
+        const name = declarationName(node);
+        if (!name)
+            return null;
+        return this.makeSymbol(node, name, 'class', `object ${name}`);
+    }
+    makeSymbol(node, name, type, signature) {
+        return {
+            name,
+            type,
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            signature,
+        };
+    }
+}
+// =============================================================================
+// LANGUAGE DEFINITION
+// =============================================================================
+export const kotlinDefinition = {
+    id: 'kotlin',
+    extensions: ['kt'],
+    grammar: Kotlin,
+    traverser: new KotlinTraverser(),
+    exportExtractor: new KotlinExportExtractor(),
+    importExtractor: new KotlinImportExtractor(),
+    symbolExtractor: new KotlinSymbolExtractor(),
+    complexity: {
+        decisionPoints: [
+            'if_expression',
+            'when_entry',
+            'for_statement',
+            'while_statement',
+            'do_while_statement',
+            'catch_block',
+            'elvis_expression',
+            'conjunction_expression', // &&
+            'disjunction_expression', // ||
+        ],
+        nestingTypes: [
+            'if_expression',
+            'when_expression',
+            'for_statement',
+            'while_statement',
+            'do_while_statement',
+            'catch_block',
+            'lambda_literal',
+            'anonymous_function',
+        ],
+        nonNestingTypes: ['when_entry', 'elvis_expression'],
+        lambdaTypes: ['lambda_literal', 'anonymous_function'],
+        operatorSymbols: new Set([
+            '+',
+            '-',
+            '*',
+            '/',
+            '%',
+            '==',
+            '!=',
+            '===',
+            '!==',
+            '<',
+            '>',
+            '<=',
+            '>=',
+            '=',
+            '+=',
+            '-=',
+            '*=',
+            '/=',
+            '%=',
+            '&&',
+            '||',
+            '!',
+            '?:',
+            '?.',
+            '.',
+            '::',
+            '->',
+            '..',
+            '(',
+            ')',
+            '[',
+            ']',
+            '{',
+            '}',
+        ]),
+        operatorKeywords: new Set([
+            'if',
+            'else',
+            'when',
+            'for',
+            'while',
+            'do',
+            'return',
+            'break',
+            'continue',
+            'throw',
+            'try',
+            'catch',
+            'finally',
+            'fun',
+            'class',
+            'object',
+            'interface',
+            'enum',
+            'val',
+            'var',
+            'is',
+            'as',
+            'in',
+            'by',
+            'import',
+            'package',
+            'override',
+            'abstract',
+            'open',
+            'sealed',
+            'data',
+            'suspend',
+            'companion',
+            'private',
+            'internal',
+            'protected',
+            'public',
+            'this',
+            'super',
+            'null',
+        ]),
+    },
+    symbols: {
+        callExpressionTypes: ['call_expression'],
+    },
+};
+//# sourceMappingURL=kotlin.js.map