@lsctech/polaris 0.1.0

package/dist/graph/adapter/csharp/runtime.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = loadTreeSitterRuntime;
+let cachedRuntime = null;
+async function loadTreeSitterRuntime() {
+    if (cachedRuntime) {
+        return cachedRuntime;
+    }
+    const loaded = await loadTreeSitterModules();
+    const parser = new loaded.parserConstructor();
+    parser.setLanguage(loaded.language);
+    cachedRuntime = {
+        parse(source) {
+            return parser.parse(source);
+        },
+    };
+    return cachedRuntime;
+}
+async function loadTreeSitterModules() {
+    const dynamicImport = createDynamicImporter();
+    const [treeSitterModule, csharpModule] = await Promise.all([
+        dynamicImport("tree-sitter"),
+        dynamicImport("tree-sitter-c-sharp"),
+    ]);
+    return {
+        parserConstructor: resolveParserConstructor(treeSitterModule),
+        language: resolveGrammar(csharpModule, "tree-sitter-c-sharp"),
+    };
+}
+function createDynamicImporter() {
+    const importer = new Function("specifier", "return import(specifier);");
+    return (specifier) => importer(specifier);
+}
+function resolveParserConstructor(moduleValue) {
+    if (typeof moduleValue === "function") {
+        return moduleValue;
+    }
+    if (moduleValue && typeof moduleValue === "object") {
+        const directDefault = moduleValue.default;
+        if (typeof directDefault === "function") {
+            return directDefault;
+        }
+        const namedParser = moduleValue.Parser;
+        if (typeof namedParser === "function") {
+            return namedParser;
+        }
+    }
+    throw new Error("Unable to resolve tree-sitter parser constructor.");
+}
+function resolveGrammar(moduleValue, packageName) {
+    if (moduleValue && typeof moduleValue === "object") {
+        const directDefault = moduleValue.default;
+        if (directDefault) {
+            return directDefault;
+        }
+    }
+    if (moduleValue) {
+        return moduleValue;
+    }
+    throw new Error(`Unable to resolve ${packageName} grammar.`);
+}

package/dist/graph/adapter/dart/adapter.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DartAdapter = void 0;
+exports.createDartAdapter = createDartAdapter;
+const node_path_1 = require("node:path");
+const extract_js_1 = require("./extract.js");
+const runtime_js_1 = require("./runtime.js");
+const DEFAULT_EXTENSIONS = [".dart"];
+class DartAdapter {
+    loadRuntime;
+    languageId = "dart";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "medium";
+    limitations = [
+        "Extracts declaration-level symbols only (classes, top-level functions, class methods, imports).",
+        "Does not perform call/reference extraction in phase 1.",
+    ];
+    constructor(loadRuntime) {
+        this.loadRuntime = loadRuntime;
+    }
+    async extractSymbols(filePath, source) {
+        const language = detectLanguage(filePath);
+        if (!language) {
+            throw new Error(`Unsupported Dart file extension: ${(0, node_path_1.extname)(filePath)}`);
+        }
+        const runtime = await this.loadRuntime();
+        const tree = runtime.parse(source, language);
+        return (0, extract_js_1.extractDartSymbolsFromTree)(tree);
+    }
+    resolveImportSpecifier(specifier, context) {
+        const trimmed = specifier.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        if (trimmed.startsWith("package:") || trimmed.startsWith("dart:")) {
+            return trimmed;
+        }
+        if (trimmed.startsWith(".")) {
+            if ((0, node_path_1.extname)(trimmed).length > 0) {
+                return trimmed;
+            }
+            const candidate = context.candidateExtensions?.[0] ?? ".dart";
+            const normalized = candidate.startsWith(".") ? candidate : `.${candidate}`;
+            return `${trimmed}${normalized}`;
+        }
+        return trimmed;
+    }
+}
+exports.DartAdapter = DartAdapter;
+function createDartAdapter(options = {}) {
+    return new DartAdapter(options.loadRuntime ?? runtime_js_1.loadTreeSitterRuntime);
+}
+function detectLanguage(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    return extension === ".dart" ? "dart" : null;
+}

package/dist/graph/adapter/dart/extract.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDartSymbolsFromTree = extractDartSymbolsFromTree;
+function extractDartSymbolsFromTree(tree) {
+    const symbols = [];
+    walkNode(tree.rootNode, symbols);
+    const deduped = dedupeSymbols(symbols);
+    deduped.sort(compareExtractedSymbols);
+    return {
+        language: "dart",
+        symbols: deduped,
+    };
+}
+function walkNode(node, output) {
+    const current = toExtractedSymbol(node);
+    if (current) {
+        output.push(current);
+    }
+    for (const child of node.namedChildren ?? []) {
+        walkNode(child, output);
+    }
+}
+function toExtractedSymbol(node) {
+    if (node.type === "class_definition") {
+        return buildSymbol(node, "class", extractClassName(node), null);
+    }
+    if (node.type === "import_or_export") {
+        return buildSymbol(node, "import", extractImportSpecifier(node), null);
+    }
+    if (FUNCTION_LIKE_TYPES.has(node.type)) {
+        const kind = hasClassAncestor(node) ? "method" : "function";
+        return buildSymbol(node, kind, extractFunctionName(node), sanitizeSignature(node.text));
+    }
+    return null;
+}
+function buildSymbol(node, kind, name, signature) {
+    if (!name) {
+        return null;
+    }
+    return {
+        kind,
+        name,
+        signature,
+        exported: !name.startsWith("_"),
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column,
+    };
+}
+function extractClassName(node) {
+    const byField = node.childForFieldName?.("name");
+    if (byField?.text?.trim()) {
+        return byField.text.trim();
+    }
+    for (const child of node.namedChildren ?? []) {
+        if (IDENTIFIER_NODE_TYPES.has(child.type) && child.text.trim().length > 0) {
+            return child.text.trim();
+        }
+    }
+    const byText = node.text.match(/\bclass\s+([A-Za-z_][A-Za-z0-9_]*)\b/);
+    return byText?.[1] ?? null;
+}
+function extractFunctionName(node) {
+    const byField = node.childForFieldName?.("name");
+    if (byField?.text?.trim()) {
+        return byField.text.trim();
+    }
+    for (const child of node.namedChildren ?? []) {
+        if (IDENTIFIER_NODE_TYPES.has(child.type) && child.text.trim().length > 0) {
+            return child.text.trim();
+        }
+    }
+    const byText = node.text.match(/\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+    return byText?.[1] ?? null;
+}
+function extractImportSpecifier(node) {
+    const byField = node.childForFieldName?.("uri");
+    if (byField?.text) {
+        return normalizeQuotedSpecifier(byField.text);
+    }
+    const match = node.text.match(/^\s*(?:import|export)\s+['"]([^'"]+)['"]/m);
+    return match?.[1] ?? null;
+}
+function normalizeQuotedSpecifier(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("'") && trimmed.endsWith("'")) || (trimmed.startsWith("\"") && trimmed.endsWith("\""))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed.length === 0 ? null : trimmed;
+}
+function hasClassAncestor(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === "class_definition") {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function sanitizeSignature(signature) {
+    const compact = signature.replace(/\s+/g, " ").trim();
+    return compact.length === 0 ? null : compact;
+}
+function dedupeSymbols(symbols) {
+    const byFingerprint = new Map();
+    for (const symbol of symbols) {
+        const fingerprint = [
+            symbol.kind,
+            symbol.name,
+            symbol.startLine,
+            symbol.startColumn,
+            symbol.endLine,
+            symbol.endColumn,
+        ].join(":");
+        byFingerprint.set(fingerprint, symbol);
+    }
+    return Array.from(byFingerprint.values());
+}
+function compareExtractedSymbols(left, right) {
+    return (left.startLine - right.startLine ||
+        left.startColumn - right.startColumn ||
+        left.endLine - right.endLine ||
+        left.endColumn - right.endColumn ||
+        left.kind.localeCompare(right.kind) ||
+        left.name.localeCompare(right.name));
+}
+const FUNCTION_LIKE_TYPES = new Set(["function_signature", "method_signature"]);
+const IDENTIFIER_NODE_TYPES = new Set(["identifier", "type_identifier"]);

package/dist/graph/adapter/dart/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = exports.extractDartSymbolsFromTree = exports.createDartAdapter = exports.DartAdapter = void 0;
+var adapter_js_1 = require("./adapter.js");
+Object.defineProperty(exports, "DartAdapter", { enumerable: true, get: function () { return adapter_js_1.DartAdapter; } });
+Object.defineProperty(exports, "createDartAdapter", { enumerable: true, get: function () { return adapter_js_1.createDartAdapter; } });
+var extract_js_1 = require("./extract.js");
+Object.defineProperty(exports, "extractDartSymbolsFromTree", { enumerable: true, get: function () { return extract_js_1.extractDartSymbolsFromTree; } });
+var runtime_js_1 = require("./runtime.js");
+Object.defineProperty(exports, "loadTreeSitterRuntime", { enumerable: true, get: function () { return runtime_js_1.loadTreeSitterRuntime; } });

package/dist/graph/adapter/dart/runtime.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = loadTreeSitterRuntime;
+let cachedRuntime = null;
+async function loadTreeSitterRuntime() {
+    if (cachedRuntime) {
+        return cachedRuntime;
+    }
+    const loaded = await loadTreeSitterModules();
+    const parser = new loaded.parserConstructor();
+    parser.setLanguage(loaded.language);
+    cachedRuntime = {
+        parse(source) {
+            return parser.parse(source);
+        },
+    };
+    return cachedRuntime;
+}
+async function loadTreeSitterModules() {
+    const dynamicImport = createDynamicImporter();
+    const [treeSitterModule, dartModule] = await Promise.all([
+        dynamicImport("tree-sitter"),
+        dynamicImport("tree-sitter-dart"),
+    ]);
+    return {
+        parserConstructor: resolveParserConstructor(treeSitterModule),
+        language: resolveGrammar(dartModule, "tree-sitter-dart"),
+    };
+}
+function createDynamicImporter() {
+    const importer = new Function("specifier", "return import(specifier);");
+    return (specifier) => importer(specifier);
+}
+function resolveParserConstructor(moduleValue) {
+    if (typeof moduleValue === "function") {
+        return moduleValue;
+    }
+    if (moduleValue && typeof moduleValue === "object") {
+        const directDefault = moduleValue.default;
+        if (typeof directDefault === "function") {
+            return directDefault;
+        }
+        const namedParser = moduleValue.Parser;
+        if (typeof namedParser === "function") {
+            return namedParser;
+        }
+    }
+    throw new Error("Unable to resolve tree-sitter parser constructor.");
+}
+function resolveGrammar(moduleValue, packageName) {
+    if (moduleValue && typeof moduleValue === "object") {
+        const directDefault = moduleValue.default;
+        if (directDefault) {
+            return directDefault;
+        }
+    }
+    if (moduleValue) {
+        return moduleValue;
+    }
+    throw new Error(`Unable to resolve ${packageName} grammar.`);
+}

package/dist/graph/adapter/go/adapter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoAdapter = void 0;
+exports.createGoAdapter = createGoAdapter;
+const node_path_1 = require("node:path");
+const extract_js_1 = require("./extract.js");
+const runtime_js_1 = require("./runtime.js");
+const DEFAULT_EXTENSIONS = [".go"];
+class GoAdapter {
+    loadRuntime;
+    languageId = "go";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "high";
+    limitations = [
+        "Extracts declaration-level symbols only (structs/interfaces, functions, methods, imports).",
+        "Does not perform package/module resolution or call/reference extraction.",
+    ];
+    constructor(loadRuntime) {
+        this.loadRuntime = loadRuntime;
+    }
+    async extractSymbols(filePath, source) {
+        const language = detectLanguage(filePath);
+        if (!language) {
+            throw new Error(`Unsupported Go file extension: ${(0, node_path_1.extname)(filePath)}`);
+        }
+        const runtime = await this.loadRuntime();
+        const tree = runtime.parse(source, language);
+        return (0, extract_js_1.extractGoSymbolsFromTree)(tree);
+    }
+    resolveImportSpecifier(specifier, _context) {
+        const trimmed = specifier.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        return trimmed;
+    }
+}
+exports.GoAdapter = GoAdapter;
+function createGoAdapter(options = {}) {
+    return new GoAdapter(options.loadRuntime ?? runtime_js_1.loadTreeSitterRuntime);
+}
+function detectLanguage(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    return extension === ".go" ? "go" : null;
+}

package/dist/graph/adapter/go/extract.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractGoSymbolsFromTree = extractGoSymbolsFromTree;
+function extractGoSymbolsFromTree(tree) {
+    const symbols = [];
+    walkNode(tree.rootNode, symbols);
+    const deduped = dedupeSymbols(symbols);
+    deduped.sort(compareExtractedSymbols);
+    return {
+        language: "go",
+        symbols: deduped,
+    };
+}
+function walkNode(node, output) {
+    const current = toExtractedSymbol(node);
+    if (current) {
+        output.push(current);
+    }
+    for (const child of node.namedChildren ?? []) {
+        walkNode(child, output);
+    }
+}
+function toExtractedSymbol(node) {
+    if (node.type === "import_spec") {
+        const name = extractImportPath(node);
+        return buildSymbol(node, "import", name, null);
+    }
+    if (node.type === "type_spec") {
+        const extracted = extractTypeName(node);
+        if (!extracted) {
+            return null;
+        }
+        return buildSymbol(node, "class", extracted, null);
+    }
+    if (node.type === "function_declaration") {
+        return buildSymbol(node, "function", extractFunctionName(node), sanitizeSignature(node.text));
+    }
+    if (node.type === "method_declaration") {
+        return buildSymbol(node, "method", extractFunctionName(node), sanitizeSignature(node.text));
+    }
+    return null;
+}
+function buildSymbol(node, kind, name, signature) {
+    if (!name) {
+        return null;
+    }
+    return {
+        kind,
+        name,
+        signature,
+        exported: /^[A-Z]/.test(name),
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column,
+    };
+}
+function extractImportPath(node) {
+    const byField = node.childForFieldName?.("path");
+    if (byField?.text) {
+        return byField.text.replace(/^"|"$/g, "");
+    }
+    const byText = node.text.match(/"([^"]+)"/);
+    return byText?.[1] ?? null;
+}
+function extractTypeName(node) {
+    const typeNode = node.childForFieldName?.("type");
+    if (!typeNode || (typeNode.type !== "struct_type" && typeNode.type !== "interface_type")) {
+        return null;
+    }
+    const byField = node.childForFieldName?.("name");
+    if (byField?.text?.trim()) {
+        return byField.text.trim();
+    }
+    const byText = node.text.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s+(struct|interface)\b/);
+    return byText?.[1] ?? null;
+}
+function extractFunctionName(node) {
+    const byField = node.childForFieldName?.("name");
+    if (byField?.text?.trim()) {
+        return byField.text.trim();
+    }
+    const byText = node.text.match(/\bfunc\b(?:\s*\([^)]*\))?\s*([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+    return byText?.[1] ?? null;
+}
+function sanitizeSignature(signature) {
+    const compact = signature.replace(/\s+/g, " ").trim();
+    return compact.length === 0 ? null : compact;
+}
+function dedupeSymbols(symbols) {
+    const byFingerprint = new Map();
+    for (const symbol of symbols) {
+        const fingerprint = [
+            symbol.kind,
+            symbol.name,
+            symbol.startLine,
+            symbol.startColumn,
+            symbol.endLine,
+            symbol.endColumn,
+        ].join(":");
+        byFingerprint.set(fingerprint, symbol);
+    }
+    return Array.from(byFingerprint.values());
+}
+function compareExtractedSymbols(left, right) {
+    return (left.startLine - right.startLine ||
+        left.startColumn - right.startColumn ||
+        left.endLine - right.endLine ||
+        left.endColumn - right.endColumn ||
+        left.kind.localeCompare(right.kind) ||
+        left.name.localeCompare(right.name));
+}

package/dist/graph/adapter/go/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = exports.extractGoSymbolsFromTree = exports.createGoAdapter = exports.GoAdapter = void 0;
+var adapter_js_1 = require("./adapter.js");
+Object.defineProperty(exports, "GoAdapter", { enumerable: true, get: function () { return adapter_js_1.GoAdapter; } });
+Object.defineProperty(exports, "createGoAdapter", { enumerable: true, get: function () { return adapter_js_1.createGoAdapter; } });
+var extract_js_1 = require("./extract.js");
+Object.defineProperty(exports, "extractGoSymbolsFromTree", { enumerable: true, get: function () { return extract_js_1.extractGoSymbolsFromTree; } });
+var runtime_js_1 = require("./runtime.js");
+Object.defineProperty(exports, "loadTreeSitterRuntime", { enumerable: true, get: function () { return runtime_js_1.loadTreeSitterRuntime; } });

package/dist/graph/adapter/go/runtime.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = loadTreeSitterRuntime;
+let cachedRuntime = null;
+async function loadTreeSitterRuntime() {
+    if (cachedRuntime) {
+        return cachedRuntime;
+    }
+    const loaded = await loadTreeSitterModules();
+    const parser = new loaded.parserConstructor();
+    parser.setLanguage(loaded.language);
+    cachedRuntime = {
+        parse(source) {
+            return parser.parse(source);
+        },
+    };
+    return cachedRuntime;
+}
+async function loadTreeSitterModules() {
+    const dynamicImport = createDynamicImporter();
+    const [treeSitterModule, goModule] = await Promise.all([dynamicImport("tree-sitter"), dynamicImport("tree-sitter-go")]);
+    return {
+        parserConstructor: resolveParserConstructor(treeSitterModule),
+        language: resolveGrammar(goModule, "tree-sitter-go"),
+    };
+}
+function createDynamicImporter() {
+    const importer = new Function("specifier", "return import(specifier);");
+    return (specifier) => importer(specifier);
+}
+function resolveParserConstructor(moduleValue) {
+    if (typeof moduleValue === "function") {
+        return moduleValue;
+    }
+    if (moduleValue && typeof moduleValue === "object") {
+        const directDefault = moduleValue.default;
+        if (typeof directDefault === "function") {
+            return directDefault;
+        }
+        const namedParser = moduleValue.Parser;
+        if (typeof namedParser === "function") {
+            return namedParser;
+        }
+    }
+    throw new Error("Unable to resolve tree-sitter parser constructor.");
+}
+function resolveGrammar(moduleValue, packageName) {
+    if (moduleValue && typeof moduleValue === "object") {
+        const directDefault = moduleValue.default;
+        if (directDefault) {
+            return directDefault;
+        }
+    }
+    if (moduleValue) {
+        return moduleValue;
+    }
+    throw new Error(`Unable to resolve ${packageName} grammar.`);
+}

package/dist/graph/adapter/kotlin-java/extract-common.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkNodes = walkNodes;
+exports.createSymbol = createSymbol;
+exports.extractDeclaredName = extractDeclaredName;
+exports.sanitizeSignature = sanitizeSignature;
+exports.dedupeAndSortSymbols = dedupeAndSortSymbols;
+exports.isMethodContext = isMethodContext;
+function walkNodes(node, visit) {
+    visit(node);
+    for (const child of node.namedChildren ?? []) {
+        walkNodes(child, visit);
+    }
+}
+function createSymbol(node, kind, name, signature, exported) {
+    if (!name) {
+        return null;
+    }
+    return {
+        kind,
+        name,
+        signature,
+        exported,
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column,
+    };
+}
+function extractDeclaredName(node, identifierNodeTypes, fallbackPattern) {
+    const byField = node.childForFieldName?.("name");
+    if (byField?.text?.trim()) {
+        return byField.text.trim();
+    }
+    for (const child of node.namedChildren ?? []) {
+        if (identifierNodeTypes.has(child.type) && child.text.trim().length > 0) {
+            return child.text.trim();
+        }
+    }
+    if (fallbackPattern) {
+        return node.text.match(fallbackPattern)?.[1] ?? null;
+    }
+    return null;
+}
+function sanitizeSignature(signature) {
+    const compact = signature.replace(/\s+/g, " ").trim();
+    return compact.length === 0 ? null : compact;
+}
+function dedupeAndSortSymbols(symbols) {
+    const byFingerprint = new Map();
+    for (const symbol of symbols) {
+        const fingerprint = [
+            symbol.kind,
+            symbol.name,
+            symbol.startLine,
+            symbol.startColumn,
+            symbol.endLine,
+            symbol.endColumn,
+        ].join(":");
+        byFingerprint.set(fingerprint, symbol);
+    }
+    const deduped = Array.from(byFingerprint.values());
+    deduped.sort(compareSymbols);
+    return deduped;
+}
+function isMethodContext(node, containerNodeTypes) {
+    let current = node.parent;
+    while (current) {
+        if (containerNodeTypes.has(current.type)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function compareSymbols(left, right) {
+    return (left.startLine - right.startLine ||
+        left.startColumn - right.startColumn ||
+        left.endLine - right.endLine ||
+        left.endColumn - right.endColumn ||
+        left.kind.localeCompare(right.kind) ||
+        left.name.localeCompare(right.name));
+}

package/dist/graph/adapter/kotlin-java/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = exports.extractKotlinSymbolsFromTree = exports.extractJavaSymbolsFromTree = exports.createKotlinAdapter = exports.KotlinAdapter = exports.createJavaAdapter = exports.JavaAdapter = void 0;
+var java_adapter_js_1 = require("./java-adapter.js");
+Object.defineProperty(exports, "JavaAdapter", { enumerable: true, get: function () { return java_adapter_js_1.JavaAdapter; } });
+Object.defineProperty(exports, "createJavaAdapter", { enumerable: true, get: function () { return java_adapter_js_1.createJavaAdapter; } });
+var kotlin_adapter_js_1 = require("./kotlin-adapter.js");
+Object.defineProperty(exports, "KotlinAdapter", { enumerable: true, get: function () { return kotlin_adapter_js_1.KotlinAdapter; } });
+Object.defineProperty(exports, "createKotlinAdapter", { enumerable: true, get: function () { return kotlin_adapter_js_1.createKotlinAdapter; } });
+var java_extract_js_1 = require("./java-extract.js");
+Object.defineProperty(exports, "extractJavaSymbolsFromTree", { enumerable: true, get: function () { return java_extract_js_1.extractJavaSymbolsFromTree; } });
+var kotlin_extract_js_1 = require("./kotlin-extract.js");
+Object.defineProperty(exports, "extractKotlinSymbolsFromTree", { enumerable: true, get: function () { return kotlin_extract_js_1.extractKotlinSymbolsFromTree; } });
+var runtime_js_1 = require("./runtime.js");
+Object.defineProperty(exports, "loadTreeSitterRuntime", { enumerable: true, get: function () { return runtime_js_1.loadTreeSitterRuntime; } });