@wuyanbin/ai-code-review-cli-remote 1.0.35 → 1.1.0

package/dist/core/symbols.js

@@ -0,0 +1,627 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_TYPE_LINES = void 0;
+exports.classifyNode = classifyNode;
+exports.enclosingDeclaration = enclosingDeclaration;
+exports.goPackageNameCandidates = goPackageNameCandidates;
+exports.collectImports = collectImports;
+exports.packageName = packageName;
+exports.collectReferences = collectReferences;
+exports.findDeclaration = findDeclaration;
+exports.renderRanges = renderRanges;
+exports.findDeclarationByRegex = findDeclarationByRegex;
+const tree_sitter_1 = require("./tree-sitter");
+/** 类型 / 值 / 类成员清单的渲染行数上限 */
+exports.MAX_TYPE_LINES = 40;
+function field(node, name) {
+    try {
+        return node.childForFieldName(name);
+    }
+    catch {
+        return null;
+    }
+}
+function firstChild(node, ...types) {
+    return (0, tree_sitter_1.namedChildren)(node).find((c) => types.includes(c.type)) ?? null;
+}
+function hasAnonymousChild(node, type) {
+    return node.children.some((c) => c !== null && c.type === type);
+}
+function stripQuotes(text) {
+    return text.trim().replace(/^['"`]/, "").replace(/['"`]$/, "");
+}
+function samePosition(a, b) {
+    return (a.startPosition.row === b.startPosition.row &&
+        a.startPosition.column === b.startPosition.column &&
+        a.endPosition.row === b.endPosition.row &&
+        a.endPosition.column === b.endPosition.column);
+}
+function makeDeclaration(stmt, kind, name, body) {
+    const start = (0, tree_sitter_1.startLine)(stmt);
+    const header = body ? Math.max(start, (0, tree_sitter_1.startLine)(body)) : start;
+    return {
+        name,
+        kind,
+        startLine: start,
+        endLine: (0, tree_sitter_1.endLine)(stmt),
+        headerEndLine: Math.min(header, (0, tree_sitter_1.endLine)(stmt)),
+        node: stmt,
+    };
+}
+/** `export function f` / `export const x`：把范围放大到 export 语句本身 */
+function liftExport(stmt) {
+    return stmt.parent?.type === "export_statement" ? stmt.parent : stmt;
+}
+const TS_FUNCTION_STATEMENTS = new Set([
+    "function_declaration",
+    "generator_function_declaration",
+    "method_definition",
+]);
+const TS_FUNCTION_EXPRESSIONS = new Set([
+    "arrow_function",
+    "function_expression",
+    "generator_function",
+    "function",
+]);
+const TS_CLASS_LIKE = new Set(["class_declaration", "abstract_class_declaration"]);
+/** 形状类声明：整体呈现（封顶 MAX_TYPE_LINES），不按成员拆分 */
+const TS_TYPE_LIKE = new Set([
+    "interface_declaration",
+    "enum_declaration",
+    "internal_module",
+    "type_alias_declaration",
+]);
+const GO_FUNCTION = new Set(["function_declaration", "method_declaration"]);
+const GO_VALUE = new Set(["const_declaration", "var_declaration"]);
+const JAVA_FUNCTION = new Set([
+    "method_declaration",
+    "constructor_declaration",
+]);
+const JAVA_CLASS_LIKE = new Set(["class_declaration", "record_declaration"]);
+const JAVA_TYPE_LIKE = new Set([
+    "interface_declaration",
+    "enum_declaration",
+    "annotation_type_declaration",
+]);
+/** 顶层按名字查找时，class 与 type 两类都算「类型声明」 */
+const JAVA_TOP_LEVEL_TYPES = new Set([...JAVA_CLASS_LIKE, ...JAVA_TYPE_LIKE]);
+function isTsLike(language) {
+    return (language === "typescript" || language === "tsx" || language === "javascript");
+}
+/**
+ * 判断节点本身是否是一个声明；回调形式的函数表达式返回 null，让调用方继续向上找
+ * 真正的外层函数。
+ */
+function classifyNode(node, language) {
+    if (isTsLike(language)) {
+        if (TS_FUNCTION_STATEMENTS.has(node.type)) {
+            return makeDeclaration(liftExport(node), "function", field(node, "name")?.text ?? null, field(node, "body"));
+        }
+        if (TS_FUNCTION_EXPRESSIONS.has(node.type) || node.type === "class") {
+            const parent = node.parent;
+            if (!parent)
+                return null;
+            const kind = node.type === "class" ? "class" : "function";
+            const body = field(node, "body");
+            if (parent.type === "variable_declarator") {
+                const stmt = parent.parent ?? parent;
+                return makeDeclaration(liftExport(stmt), kind, field(parent, "name")?.text ?? null, body);
+            }
+            if (parent.type === "pair") {
+                return makeDeclaration(parent, kind, field(parent, "key")?.text ?? null, body);
+            }
+            if (parent.type === "assignment_expression") {
+                const stmt = parent.parent?.type === "expression_statement" ? parent.parent : parent;
+                return makeDeclaration(stmt, kind, field(parent, "left")?.text ?? null, body);
+            }
+            if (parent.type === "public_field_definition") {
+                return makeDeclaration(parent, kind, field(parent, "name")?.text ?? null, body);
+            }
+            return null;
+        }
+        if (TS_CLASS_LIKE.has(node.type)) {
+            return makeDeclaration(liftExport(node), "class", field(node, "name")?.text ?? null, field(node, "body"));
+        }
+        if (TS_TYPE_LIKE.has(node.type)) {
+            return makeDeclaration(liftExport(node), "type", field(node, "name")?.text ?? null, null);
+        }
+        return null;
+    }
+    if (language === "go") {
+        if (GO_FUNCTION.has(node.type)) {
+            return makeDeclaration(node, "function", field(node, "name")?.text ?? null, field(node, "body"));
+        }
+        if (node.type === "type_declaration") {
+            const spec = firstChild(node, "type_spec", "type_alias");
+            return makeDeclaration(node, "type", spec ? field(spec, "name")?.text ?? null : null, null);
+        }
+        if (GO_VALUE.has(node.type) && node.parent?.type === "source_file") {
+            const spec = firstChild(node, "const_spec", "var_spec");
+            return makeDeclaration(node, "value", spec ? field(spec, "name")?.text ?? null : null, null);
+        }
+        return null;
+    }
+    // java
+    if (JAVA_FUNCTION.has(node.type)) {
+        return makeDeclaration(node, "function", field(node, "name")?.text ?? null, field(node, "body"));
+    }
+    if (JAVA_CLASS_LIKE.has(node.type)) {
+        return makeDeclaration(node, "class", field(node, "name")?.text ?? null, field(node, "body"));
+    }
+    if (JAVA_TYPE_LIKE.has(node.type)) {
+        return makeDeclaration(node, "type", field(node, "name")?.text ?? null, null);
+    }
+    return null;
+}
+/** 找包含指定行（1-based）的最内层声明；顶层语句、import 等返回 null */
+function enclosingDeclaration(root, language, line, lineLength = 0) {
+    const row = line - 1;
+    if (row < 0 || row > root.endPosition.row)
+        return null;
+    let node = null;
+    try {
+        node =
+            root.descendantForPosition({ row, column: 0 }, { row, column: Math.max(0, lineLength) }) ?? root.descendantForPosition({ row, column: 0 });
+    }
+    catch {
+        return null;
+    }
+    for (let current = node; current; current = current.parent) {
+        const decl = classifyNode(current, language);
+        if (decl)
+            return decl;
+    }
+    return null;
+}
+/** Go 包名缺省取路径末段；`/v2` 版本段跳过；带连字符的目录再给两个常见变体 */
+function goPackageNameCandidates(importPath) {
+    const segments = importPath.split("/").filter(Boolean);
+    let last = segments.pop() ?? importPath;
+    if (/^v\d+$/.test(last) && segments.length > 0)
+        last = segments.pop() ?? last;
+    const variants = new Set([
+        last,
+        last.replace(/^go-/, ""),
+        last.replace(/-go$/, ""),
+        last.replace(/-/g, ""),
+        last.replace(/[-.]/g, "_"),
+    ]);
+    return [...variants].filter(Boolean);
+}
+function collectImports(root, language) {
+    const bindings = [];
+    if (isTsLike(language)) {
+        for (const stmt of (0, tree_sitter_1.namedChildren)(root)) {
+            if (stmt.type === "import_statement") {
+                const sourceNode = field(stmt, "source");
+                if (!sourceNode)
+                    continue;
+                const source = stripQuotes(sourceNode.text);
+                const clause = firstChild(stmt, "import_clause");
+                if (!clause)
+                    continue;
+                for (const part of (0, tree_sitter_1.namedChildren)(clause)) {
+                    if (part.type === "identifier") {
+                        bindings.push({ local: part.text, imported: "default", source, kind: "default" });
+                    }
+                    else if (part.type === "namespace_import") {
+                        const id = firstChild(part, "identifier");
+                        if (id)
+                            bindings.push({ local: id.text, imported: null, source, kind: "namespace" });
+                    }
+                    else if (part.type === "named_imports") {
+                        for (const spec of (0, tree_sitter_1.namedChildren)(part)) {
+                            if (spec.type !== "import_specifier")
+                                continue;
+                            const name = field(spec, "name")?.text;
+                            if (!name)
+                                continue;
+                            const alias = field(spec, "alias")?.text;
+                            bindings.push({ local: alias ?? name, imported: name, source, kind: "named" });
+                        }
+                    }
+                }
+                continue;
+            }
+            if (stmt.type === "lexical_declaration" || stmt.type === "variable_declaration") {
+                for (const declarator of (0, tree_sitter_1.namedChildren)(stmt)) {
+                    if (declarator.type !== "variable_declarator")
+                        continue;
+                    const value = field(declarator, "value");
+                    if (!value || value.type !== "call_expression")
+                        continue;
+                    if (field(value, "function")?.text !== "require")
+                        continue;
+                    const args = field(value, "arguments");
+                    const str = args ? (0, tree_sitter_1.namedChildren)(args)[0] : null;
+                    if (!str || str.type !== "string")
+                        continue;
+                    const source = stripQuotes(str.text);
+                    const nameNode = field(declarator, "name");
+                    if (!nameNode)
+                        continue;
+                    if (nameNode.type === "identifier") {
+                        bindings.push({ local: nameNode.text, imported: null, source, kind: "namespace" });
+                    }
+                    else if (nameNode.type === "object_pattern") {
+                        for (const prop of (0, tree_sitter_1.namedChildren)(nameNode)) {
+                            if (prop.type === "shorthand_property_identifier_pattern") {
+                                bindings.push({ local: prop.text, imported: prop.text, source, kind: "named" });
+                            }
+                            else if (prop.type === "pair_pattern") {
+                                const key = field(prop, "key")?.text;
+                                const local = field(prop, "value")?.text;
+                                if (key && local)
+                                    bindings.push({ local, imported: key, source, kind: "named" });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return bindings;
+    }
+    if (language === "go") {
+        const specs = [];
+        for (const decl of (0, tree_sitter_1.namedChildren)(root)) {
+            if (decl.type !== "import_declaration")
+                continue;
+            for (const child of (0, tree_sitter_1.namedChildren)(decl)) {
+                if (child.type === "import_spec")
+                    specs.push(child);
+                else if (child.type === "import_spec_list") {
+                    specs.push(...(0, tree_sitter_1.namedChildren)(child).filter((c) => c.type === "import_spec"));
+                }
+            }
+        }
+        for (const spec of specs) {
+            const pathNode = field(spec, "path");
+            if (!pathNode)
+                continue;
+            const source = stripQuotes(pathNode.text);
+            const alias = field(spec, "name")?.text;
+            if (alias === "_" || alias === ".")
+                continue;
+            const locals = alias ? [alias] : goPackageNameCandidates(source);
+            for (const local of locals) {
+                bindings.push({ local, imported: null, source, kind: "package" });
+            }
+        }
+        return bindings;
+    }
+    for (const decl of (0, tree_sitter_1.namedChildren)(root)) {
+        if (decl.type !== "import_declaration")
+            continue;
+        if (hasAnonymousChild(decl, "static"))
+            continue;
+        const scoped = firstChild(decl, "scoped_identifier", "identifier");
+        if (!scoped)
+            continue;
+        const source = scoped.text;
+        if (hasAnonymousChild(decl, "asterisk")) {
+            bindings.push({ local: "*", imported: null, source, kind: "wildcard" });
+        }
+        else {
+            const last = source.split(".").pop() ?? source;
+            bindings.push({ local: last, imported: last, source, kind: "class" });
+        }
+    }
+    return bindings;
+}
+/** Go 的 package 名 / Java 的 package 路径；TS 无此概念返回 null */
+function packageName(root, language) {
+    if (language === "go") {
+        const clause = firstChild(root, "package_clause");
+        return clause ? firstChild(clause, "package_identifier")?.text ?? null : null;
+    }
+    if (language === "java") {
+        const decl = firstChild(root, "package_declaration");
+        return decl ? firstChild(decl, "scoped_identifier", "identifier")?.text ?? null : null;
+    }
+    return null;
+}
+const IDENTIFIER_TYPES = {
+    typescript: new Set(["identifier", "type_identifier", "property_identifier", "shorthand_property_identifier"]),
+    tsx: new Set(["identifier", "type_identifier", "property_identifier", "shorthand_property_identifier"]),
+    javascript: new Set(["identifier", "property_identifier", "shorthand_property_identifier"]),
+    go: new Set(["identifier", "type_identifier", "field_identifier", "package_identifier"]),
+    java: new Set(["identifier", "type_identifier"]),
+};
+/** 限定引用的父节点：[对象侧字段名, 成员侧字段名]；字段名为 null 时按首/末子节点 */
+const QUALIFIED_PARENTS = {
+    member_expression: ["object", "property"],
+    nested_type_identifier: ["module", "name"],
+    nested_identifier: [null, null],
+    selector_expression: ["operand", "field"],
+    qualified_type: ["package", "name"],
+    field_access: ["object", "field"],
+    method_invocation: ["object", "name"],
+    scoped_type_identifier: [null, null],
+    scoped_identifier: [null, null],
+};
+/** 收集落在给定行（1-based）上的标识符引用；只下探与目标行相交的子树 */
+function collectReferences(root, language, lines) {
+    if (lines.size === 0)
+        return [];
+    const rows = [...lines].map((l) => l - 1);
+    const minRow = Math.min(...rows);
+    const maxRow = Math.max(...rows);
+    const identifierTypes = IDENTIFIER_TYPES[language];
+    const seen = new Set();
+    const refs = [];
+    const push = (name, qualifier) => {
+        if (!name)
+            return;
+        const key = `${qualifier ?? ""}.${name}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        refs.push({ name, qualifier });
+    };
+    // 显式栈而不是递归：5000 层括号嵌套这种病态输入会撑爆调用栈，而异常一旦
+    // 逸出就会中断整次评审；先序、从左到右的顺序与递归版一致
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.endPosition.row < minRow || node.startPosition.row > maxRow)
+            continue;
+        const children = (0, tree_sitter_1.namedChildren)(node);
+        if (children.length > 0) {
+            for (let i = children.length - 1; i >= 0; i--)
+                stack.push(children[i]);
+            continue;
+        }
+        if (!identifierTypes.has(node.type) || !lines.has(node.startPosition.row + 1))
+            continue;
+        const parent = node.parent;
+        const spec = parent ? QUALIFIED_PARENTS[parent.type] : undefined;
+        if (parent && spec) {
+            const siblings = (0, tree_sitter_1.namedChildren)(parent);
+            const object = spec[0] ? field(parent, spec[0]) : siblings[0] ?? null;
+            const member = spec[1] ? field(parent, spec[1]) : siblings[siblings.length - 1] ?? null;
+            if (member && samePosition(member, node) && object && identifierTypes.has(object.type)) {
+                push(node.text, object.text);
+                continue;
+            }
+            // 对象侧（`Foo.BAZ` 里的 Foo）由成员侧那条限定引用覆盖，不再单独产出
+            if (object && samePosition(object, node) && member && identifierTypes.has(member.type)) {
+                continue;
+            }
+        }
+        push(node.text, null);
+    }
+    return refs;
+}
+function declaratorNames(node) {
+    return (0, tree_sitter_1.namedChildren)(node)
+        .filter((c) => c.type === "identifier" || c.type === "type_identifier")
+        .map((c) => c.text);
+}
+/** TS 顶层语句里按名字找声明（含 export 包装、const 箭头函数、default 导出） */
+function findTsTopLevel(root, language, name) {
+    for (const stmt of (0, tree_sitter_1.namedChildren)(root)) {
+        const isExport = stmt.type === "export_statement";
+        const target = isExport ? field(stmt, "declaration") ?? field(stmt, "value") : stmt;
+        if (!target)
+            continue;
+        if (name === "default") {
+            if (!isExport || !hasAnonymousChild(stmt, "default"))
+                continue;
+            if (target.type === "identifier")
+                return findTsTopLevel(root, language, target.text);
+            const decl = classifyNode(target, language);
+            return decl ?? makeDeclaration(stmt, "value", "default", null);
+        }
+        if (target.type === "lexical_declaration" || target.type === "variable_declaration") {
+            for (const declarator of (0, tree_sitter_1.namedChildren)(target)) {
+                if (declarator.type !== "variable_declarator")
+                    continue;
+                if (field(declarator, "name")?.text !== name)
+                    continue;
+                const value = field(declarator, "value");
+                if (value && (TS_FUNCTION_EXPRESSIONS.has(value.type) || value.type === "class")) {
+                    return classifyNode(value, language) ?? makeDeclaration(liftExport(target), "value", name, null);
+                }
+                return makeDeclaration(liftExport(target), "value", name, null);
+            }
+            continue;
+        }
+        if (field(target, "name")?.text === name) {
+            const decl = classifyNode(target, language);
+            if (decl)
+                return decl;
+        }
+    }
+    return null;
+}
+function findGoTopLevel(root, name) {
+    for (const stmt of (0, tree_sitter_1.namedChildren)(root)) {
+        if (stmt.type === "function_declaration" && field(stmt, "name")?.text === name) {
+            return classifyNode(stmt, "go");
+        }
+        if (stmt.type === "type_declaration") {
+            for (const spec of (0, tree_sitter_1.namedChildren)(stmt)) {
+                if ((spec.type === "type_spec" || spec.type === "type_alias") && field(spec, "name")?.text === name) {
+                    const node = (0, tree_sitter_1.namedChildren)(stmt).length > 1 ? spec : stmt;
+                    return makeDeclaration(node, "type", name, null);
+                }
+            }
+            continue;
+        }
+        if (GO_VALUE.has(stmt.type)) {
+            for (const spec of (0, tree_sitter_1.namedChildren)(stmt)) {
+                if (spec.type !== "const_spec" && spec.type !== "var_spec")
+                    continue;
+                if (declaratorNames(spec).includes(name)) {
+                    return makeDeclaration(spec, "value", name, null);
+                }
+            }
+        }
+    }
+    return null;
+}
+function javaMemberName(member) {
+    if (member.type === "field_declaration") {
+        return (0, tree_sitter_1.namedChildren)(member)
+            .filter((c) => c.type === "variable_declarator")
+            .map((c) => field(c, "name")?.text ?? "")
+            .filter(Boolean);
+    }
+    if (member.type === "enum_constant") {
+        return [field(member, "name")?.text ?? (0, tree_sitter_1.namedChildren)(member)[0]?.text ?? ""].filter(Boolean);
+    }
+    const name = field(member, "name")?.text;
+    return name ? [name] : [];
+}
+function javaBodyMembers(body) {
+    const members = [];
+    for (const child of (0, tree_sitter_1.namedChildren)(body)) {
+        if (child.type === "enum_body_declarations")
+            members.push(...(0, tree_sitter_1.namedChildren)(child));
+        else
+            members.push(child);
+    }
+    return members;
+}
+function findJavaTopLevel(root, name) {
+    for (const stmt of (0, tree_sitter_1.namedChildren)(root)) {
+        if (JAVA_TOP_LEVEL_TYPES.has(stmt.type) && field(stmt, "name")?.text === name) {
+            return classifyNode(stmt, "java");
+        }
+    }
+    return null;
+}
+function memberOf(decl, language, member) {
+    const body = field(decl.node, "body") ?? (decl.node.type === "export_statement" ? null : null);
+    const classNode = decl.node.type === "export_statement" ? field(decl.node, "declaration") ?? decl.node : decl.node;
+    const classBody = body ?? field(classNode, "body");
+    if (!classBody)
+        return null;
+    const members = language === "java" ? javaBodyMembers(classBody) : (0, tree_sitter_1.namedChildren)(classBody);
+    for (const m of members) {
+        if (m.type === "comment" || m.type === "line_comment" || m.type === "block_comment")
+            continue;
+        const names = language === "java" ? javaMemberName(m) : [field(m, "name")?.text ?? ""];
+        if (!names.includes(member))
+            continue;
+        const classified = classifyNode(m, language);
+        if (classified)
+            return classified;
+        return makeDeclaration(m, "value", member, null);
+    }
+    return null;
+}
+/** 在目标文件的语法树里按名字找顶层声明；member 用于 `Foo.BAR` 这类类成员引用 */
+function findDeclaration(root, language, name, member) {
+    let decl = null;
+    if (isTsLike(language))
+        decl = findTsTopLevel(root, language, name);
+    else if (language === "go")
+        decl = findGoTopLevel(root, name);
+    else
+        decl = findJavaTopLevel(root, name);
+    if (!decl)
+        return null;
+    const memberDecl = member && decl.kind === "class" ? memberOf(decl, language, member) : null;
+    return { decl, member: memberDecl };
+}
+function isPublicMember(member, language) {
+    if (language === "java") {
+        if (member.type === "enum_constant")
+            return true;
+        const modifiers = firstChild(member, "modifiers")?.text ?? "";
+        if (/\bprivate\b|\bprotected\b/.test(modifiers))
+            return false;
+        return /\bpublic\b/.test(modifiers) || modifiers === "";
+    }
+    const accessibility = member.children.find((c) => c !== null && c.type === "accessibility_modifier");
+    if (accessibility && /private|protected/.test(accessibility.text))
+        return false;
+    const name = field(member, "name")?.text ?? "";
+    return !name.startsWith("#");
+}
+/**
+ * 决定渲染哪些行（1-based 闭区间，已排序不重叠）：
+ *   函数 → 签名；类型/值 → 整体但封顶 MAX_TYPE_LINES；
+ *   类 → 类头 + 被引用成员的签名（无具体成员时列公开成员签名），封顶 MAX_TYPE_LINES。
+ */
+function renderRanges(found, language) {
+    const { decl, member } = found;
+    if (decl.kind === "function")
+        return [[decl.startLine, decl.headerEndLine]];
+    if (decl.kind !== "class") {
+        return [[decl.startLine, Math.min(decl.endLine, decl.startLine + exports.MAX_TYPE_LINES - 1)]];
+    }
+    const ranges = [[decl.startLine, decl.headerEndLine]];
+    let used = decl.headerEndLine - decl.startLine + 1;
+    const pushRange = (start, end) => {
+        const last = ranges[ranges.length - 1];
+        if (start <= last[1])
+            return; // 已在类头范围内
+        const capped = Math.min(end, start + Math.max(0, exports.MAX_TYPE_LINES - used) - 1);
+        if (capped < start)
+            return;
+        ranges.push([start, capped]);
+        used += capped - start + 1;
+    };
+    if (member) {
+        pushRange(member.startLine, member.headerEndLine);
+        return ranges;
+    }
+    const classNode = decl.node.type === "export_statement" ? field(decl.node, "declaration") ?? decl.node : decl.node;
+    const body = field(classNode, "body");
+    if (!body)
+        return ranges;
+    const members = language === "java" ? javaBodyMembers(body) : (0, tree_sitter_1.namedChildren)(body);
+    for (const m of members) {
+        if (used >= exports.MAX_TYPE_LINES)
+            break;
+        if (m.type === "comment" || m.type === "line_comment" || m.type === "block_comment")
+            continue;
+        if (!isPublicMember(m, language))
+            continue;
+        const classified = classifyNode(m, language);
+        const end = classified ? classified.headerEndLine : Math.min((0, tree_sitter_1.endLine)(m), (0, tree_sitter_1.startLine)(m));
+        pushRange((0, tree_sitter_1.startLine)(m), end);
+    }
+    return ranges;
+}
+/**
+ * 语法树不可用（超大文件解析超时、运行时缺失）时的兜底：按行正则找声明头。
+ * 只认「行首就是声明」的常见形态，找不到就返回空。
+ */
+function findDeclarationByRegex(lines, language, name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const patterns = isTsLike(language)
+        ? [
+            new RegExp(`^\\s*(export\\s+)?(default\\s+)?(declare\\s+)?(abstract\\s+)?(async\\s+)?(function\\*?\\s+${escaped}\\b|class\\s+${escaped}\\b|interface\\s+${escaped}\\b|type\\s+${escaped}\\b|enum\\s+${escaped}\\b|(const|let|var)\\s+${escaped}\\b)`),
+        ]
+        : language === "go"
+            ? [
+                new RegExp(`^\\s*func\\s+(\\([^)]*\\)\\s*)?${escaped}\\s*[\\[(]`),
+                new RegExp(`^\\s*type\\s+${escaped}\\b`),
+                new RegExp(`^\\s*(const|var)\\s+${escaped}\\b`),
+                new RegExp(`^\\s*${escaped}\\b[^=]*=`),
+            ]
+            : [
+                new RegExp(`^\\s*((public|private|protected|static|final|abstract|sealed|non-sealed)\\s+)*(class|interface|enum|record|@interface)\\s+${escaped}\\b`),
+            ];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.includes(name))
+            continue;
+        if (!patterns.some((p) => p.test(line)))
+            continue;
+        let end = i;
+        if (!/[{;=]/.test(line)) {
+            for (let j = i + 1; j < Math.min(lines.length, i + 5); j++) {
+                end = j;
+                if (/[{;]/.test(lines[j]))
+                    break;
+            }
+        }
+        return [[i + 1, end + 1]];
+    }
+    return [];
+}
+//# sourceMappingURL=symbols.js.map