@lsctech/polaris 0.1.0

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCSymbolsFromTree = extractCSymbolsFromTree;
+function extractCSymbolsFromTree(tree) {
+    const symbols = [];
+    walkNode(tree.rootNode, symbols);
+    const deduped = dedupeSymbols(symbols);
+    deduped.sort(compareExtractedSymbols);
+    return {
+        language: "c",
+        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 === "preproc_include") {
+        const include = extractIncludeName(node.text);
+        if (!include) {
+            return null;
+        }
+        return buildSymbol(node, "import", include, null);
+    }
+    if (node.type === "struct_specifier") {
+        const name = extractStructName(node);
+        return buildSymbol(node, "class", name, null);
+    }
+    if (node.type === "function_definition" || node.type === "declaration") {
+        const functionNode = node.type === "declaration" ? findDescendant(node, "function_declarator") : node;
+        if (!functionNode) {
+            return null;
+        }
+        const name = extractFunctionName(functionNode);
+        const signature = sanitizeSignature(node.text);
+        return buildSymbol(node, "function", name, signature);
+    }
+    return null;
+}
+function buildSymbol(node, kind, name, signature) {
+    if (!name) {
+        return null;
+    }
+    return {
+        kind,
+        name,
+        signature,
+        exported: /\bextern\b/.test(node.text),
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column,
+    };
+}
+function extractIncludeName(text) {
+    const match = text.match(/#include\s*[<"]([^>"]+)[>"]/);
+    return match?.[1] ?? null;
+}
+function extractStructName(node) {
+    const nameNode = node.childForFieldName?.("name");
+    if (nameNode?.text?.trim()) {
+        return nameNode.text.trim();
+    }
+    const match = node.text.match(/\bstruct\s+([A-Za-z_][A-Za-z0-9_]*)/);
+    return match?.[1] ?? null;
+}
+function extractFunctionName(node) {
+    const byField = node.childForFieldName?.("declarator") ?? node.childForFieldName?.("name");
+    if (byField) {
+        const found = extractIdentifier(byField);
+        if (found) {
+            return found;
+        }
+    }
+    return extractIdentifier(node);
+}
+function extractIdentifier(node) {
+    if (IDENTIFIER_NODE_TYPES.has(node.type) && node.text.trim().length > 0) {
+        return node.text.trim();
+    }
+    for (const child of node.namedChildren ?? []) {
+        const found = extractIdentifier(child);
+        if (found) {
+            return found;
+        }
+    }
+    const match = node.text.match(/\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+    return match?.[1] ?? null;
+}
+function findDescendant(node, type) {
+    if (node.type === type) {
+        return node;
+    }
+    for (const child of node.namedChildren ?? []) {
+        const found = findDescendant(child, type);
+        if (found) {
+            return found;
+        }
+    }
+    return 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));
+}
+const IDENTIFIER_NODE_TYPES = new Set(["identifier", "field_identifier", "type_identifier"]);

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

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

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = loadTreeSitterRuntime;
+let cachedRuntime = null;
+let cachedRuntimePromise = null;
+async function loadTreeSitterRuntime() {
+    if (cachedRuntime) {
+        return cachedRuntime;
+    }
+    if (cachedRuntimePromise) {
+        return await cachedRuntimePromise;
+    }
+    cachedRuntimePromise = (async () => {
+        const loaded = await loadTreeSitterModules();
+        const parser = new loaded.parserConstructor();
+        parser.setLanguage(loaded.language);
+        const runtime = {
+            parse(source) {
+                return parser.parse(source);
+            },
+        };
+        cachedRuntime = runtime;
+        cachedRuntimePromise = null;
+        return runtime;
+    })();
+    return await cachedRuntimePromise;
+}
+async function loadTreeSitterModules() {
+    const dynamicImport = createDynamicImporter();
+    const [treeSitterModule, cModule] = await Promise.all([dynamicImport("tree-sitter"), dynamicImport("tree-sitter-c")]);
+    return {
+        parserConstructor: resolveParserConstructor(treeSitterModule),
+        language: resolveGrammar(cModule, "tree-sitter-c"),
+    };
+}
+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/cpp/adapter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CppAdapter = void 0;
+exports.createCppAdapter = createCppAdapter;
+const node_path_1 = require("node:path");
+const extract_js_1 = require("./extract.js");
+const runtime_js_1 = require("./runtime.js");
+const DEFAULT_EXTENSIONS = [".cpp", ".cc", ".cxx", ".hpp"];
+class CppAdapter {
+    loadRuntime;
+    languageId = "cpp";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "high";
+    limitations = [
+        "Extracts declaration-level symbols only (classes, functions, methods, includes).",
+        "Does not perform macro expansion or template instantiation.",
+    ];
+    constructor(loadRuntime) {
+        this.loadRuntime = loadRuntime;
+    }
+    async extractSymbols(filePath, source) {
+        const language = detectLanguage(filePath);
+        if (!language) {
+            throw new Error(`Unsupported C++ file extension: ${(0, node_path_1.extname)(filePath)}`);
+        }
+        const runtime = await this.loadRuntime();
+        const tree = runtime.parse(source, language);
+        return (0, extract_js_1.extractCppSymbolsFromTree)(tree);
+    }
+    resolveImportSpecifier(specifier, _context) {
+        const trimmed = specifier.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        return trimmed;
+    }
+}
+exports.CppAdapter = CppAdapter;
+function createCppAdapter(options = {}) {
+    return new CppAdapter(options.loadRuntime ?? runtime_js_1.loadTreeSitterRuntime);
+}
+function detectLanguage(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    return extension === ".cpp" || extension === ".cc" || extension === ".cxx" || extension === ".hpp" ? "cpp" : null;
+}

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCppSymbolsFromTree = extractCppSymbolsFromTree;
+function extractCppSymbolsFromTree(tree) {
+    const classNames = collectClassNames(tree.rootNode);
+    const symbols = [];
+    walkNode(tree.rootNode, symbols, classNames);
+    const deduped = dedupeSymbols(symbols);
+    deduped.sort(compareExtractedSymbols);
+    return {
+        language: "cpp",
+        symbols: deduped,
+    };
+}
+function collectClassNames(root) {
+    const names = new Set();
+    function walk(node) {
+        if (node.type === "class_specifier" || node.type === "struct_specifier") {
+            const name = extractTypeName(node);
+            if (name)
+                names.add(name);
+        }
+        for (const child of node.namedChildren ?? []) {
+            walk(child);
+        }
+    }
+    walk(root);
+    return names;
+}
+function walkNode(node, output, classNames) {
+    const current = toExtractedSymbol(node, classNames);
+    if (current) {
+        output.push(current);
+    }
+    for (const child of node.namedChildren ?? []) {
+        walkNode(child, output, classNames);
+    }
+}
+function toExtractedSymbol(node, classNames) {
+    if (node.type === "preproc_include") {
+        const include = extractIncludeName(node.text);
+        if (!include) {
+            return null;
+        }
+        return buildSymbol(node, "import", include, null);
+    }
+    if (node.type === "class_specifier" || node.type === "struct_specifier") {
+        const name = extractTypeName(node);
+        return buildSymbol(node, "class", name, null);
+    }
+    if (node.type === "function_definition" || node.type === "declaration") {
+        const functionDeclarator = node.type === "declaration"
+            ? findDescendant(node, "function_declarator") ?? findDescendant(node, "function_declarator")
+            : findDescendant(node, "function_declarator") ?? node;
+        if (!functionDeclarator) {
+            return null;
+        }
+        const extracted = extractFunctionName(functionDeclarator.text);
+        if (!extracted) {
+            return null;
+        }
+        const signature = sanitizeSignature(node.text);
+        const symbolKind = isMethod(node, extracted.rawName, classNames) ? "method" : "function";
+        return buildSymbol(node, symbolKind, extracted.name, signature);
+    }
+    return null;
+}
+function buildSymbol(node, kind, name, signature) {
+    if (!name) {
+        return null;
+    }
+    return {
+        kind,
+        name,
+        signature,
+        exported: /\b(public|extern)\b/.test(node.text),
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column,
+    };
+}
+function extractIncludeName(text) {
+    const match = text.match(/#include\s*[<"]([^>"]+)[>"]/);
+    return match?.[1] ?? null;
+}
+function extractTypeName(node) {
+    const nameNode = node.childForFieldName?.("name");
+    if (nameNode?.text?.trim()) {
+        return nameNode.text.trim();
+    }
+    const byText = node.text.match(/\b(class|struct)\s+([A-Za-z_][A-Za-z0-9_]*)/);
+    return byText?.[2] ?? null;
+}
+function extractFunctionName(text) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    const match = compact.match(/([~A-Za-z_][A-Za-z0-9_:~]*)\s*\(/);
+    if (!match) {
+        return null;
+    }
+    const rawName = match[1];
+    const simple = rawName.includes("::") ? rawName.split("::").at(-1) ?? rawName : rawName;
+    return { name: simple, rawName };
+}
+// Returns true only when the qualifier before the last '::' names a known class/struct,
+// or the node is lexically nested inside a class/struct specifier.
+function isMethod(node, rawName, classNames) {
+    if (rawName.includes("::")) {
+        const qualifier = rawName.split("::")[0];
+        return classNames.has(qualifier);
+    }
+    let current = node.parent ?? null;
+    while (current) {
+        if (current.type === "class_specifier" || current.type === "struct_specifier") {
+            return true;
+        }
+        current = current.parent ?? null;
+    }
+    return false;
+}
+function findDescendant(node, type) {
+    if (node.type === type) {
+        return node;
+    }
+    for (const child of node.namedChildren ?? []) {
+        const found = findDescendant(child, type);
+        if (found) {
+            return found;
+        }
+    }
+    return 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/cpp/index.js

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

package/dist/graph/adapter/cpp/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, cppModule] = await Promise.all([
+        dynamicImport("tree-sitter"),
+        dynamicImport("tree-sitter-cpp"),
+    ]);
+    return {
+        parserConstructor: resolveParserConstructor(treeSitterModule),
+        language: resolveGrammar(cppModule, "tree-sitter-cpp"),
+    };
+}
+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/csharp/adapter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSharpAdapter = void 0;
+exports.createCSharpAdapter = createCSharpAdapter;
+const node_path_1 = require("node:path");
+const extract_js_1 = require("./extract.js");
+const runtime_js_1 = require("./runtime.js");
+const DEFAULT_EXTENSIONS = [".cs"];
+class CSharpAdapter {
+    loadRuntime;
+    languageId = "csharp";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "high";
+    limitations = [
+        "Extracts declaration-level symbols only (classes, methods, static methods, using directives).",
+        "Does not perform generic type or semantic symbol resolution.",
+    ];
+    constructor(loadRuntime) {
+        this.loadRuntime = loadRuntime;
+    }
+    async extractSymbols(filePath, source) {
+        const language = detectLanguage(filePath);
+        if (!language) {
+            throw new Error(`Unsupported C# file extension: ${(0, node_path_1.extname)(filePath)}`);
+        }
+        const runtime = await this.loadRuntime();
+        const tree = runtime.parse(source, language);
+        return (0, extract_js_1.extractCSharpSymbolsFromTree)(tree);
+    }
+    resolveImportSpecifier(specifier, _context) {
+        const trimmed = specifier.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        return trimmed;
+    }
+}
+exports.CSharpAdapter = CSharpAdapter;
+function createCSharpAdapter(options = {}) {
+    return new CSharpAdapter(options.loadRuntime ?? runtime_js_1.loadTreeSitterRuntime);
+}
+function detectLanguage(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    return extension === ".cs" ? "csharp" : null;
+}

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCSharpSymbolsFromTree = extractCSharpSymbolsFromTree;
+function extractCSharpSymbolsFromTree(tree) {
+    const symbols = [];
+    walkNode(tree.rootNode, symbols);
+    const deduped = dedupeSymbols(symbols);
+    deduped.sort(compareExtractedSymbols);
+    return {
+        language: "csharp",
+        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 === "using_directive") {
+        const name = extractUsingName(node);
+        return buildSymbol(node, "import", name, null);
+    }
+    if (node.type === "class_declaration") {
+        const name = extractName(node);
+        return buildSymbol(node, "class", name, null);
+    }
+    if (node.type === "method_declaration") {
+        const name = extractName(node);
+        const signature = sanitizeSignature(node.text);
+        const kind = isStatic(node) ? "function" : "method";
+        return buildSymbol(node, kind, name, signature);
+    }
+    return null;
+}
+function buildSymbol(node, kind, name, signature) {
+    if (!name) {
+        return null;
+    }
+    const exported = checkExported(node);
+    return {
+        kind,
+        name,
+        signature,
+        exported,
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column,
+    };
+}
+function checkExported(node) {
+    const modifiers = node.childForFieldName?.("modifiers");
+    if (modifiers?.text) {
+        return /\bpublic\b/.test(modifiers.text);
+    }
+    const headerText = getNodeHeader(node.text);
+    return /\bpublic\b/.test(headerText);
+}
+function getNodeHeader(text) {
+    const openBrace = text.indexOf("{");
+    if (openBrace !== -1) {
+        return text.substring(0, openBrace);
+    }
+    return text;
+}
+function extractUsingName(node) {
+    const match = node.text.match(/\busing\s+(?:static\s+)?(?:[A-Za-z_][A-Za-z0-9_]*\s*=\s*)?([A-Za-z_][A-Za-z0-9_.]*)\s*;/);
+    return match?.[1] ?? null;
+}
+function extractName(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 methodMatch = node.text.match(/\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+    if (methodMatch) {
+        return methodMatch[1];
+    }
+    const classMatch = node.text.match(/\bclass\s+([A-Za-z_][A-Za-z0-9_]*)/);
+    return classMatch?.[1] ?? null;
+}
+function isStatic(node) {
+    const modifiers = node.childForFieldName?.("modifiers");
+    if (modifiers?.text) {
+        return /\bstatic\b/.test(modifiers.text);
+    }
+    const headerText = getNodeHeader(node.text);
+    return /\bstatic\b/.test(headerText);
+}
+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 IDENTIFIER_NODE_TYPES = new Set(["identifier"]);

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

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