token-goat 2.9.29 → 2.9.31

package/dist/{token-goat-chunk-KOPIR3KZ.mjs → token-goat-chunk-BA4HI6BW.mjs}

@@ -2,6 +2,11 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   SpanCollector,
+  bodyBraceAt,
+  bodyResumeAt,
+  bodySegments,
+  endOpenMember,
+  endOpenMembers,
   extractAbap,
   extractAbl,
   extractAsm,
@@ -24,21 +29,27 @@ import {
   extractSolidity,
   extractSwift,
   extractThrift,
-  extractWgsl
-} from "./token-goat-chunk-PGTH2U4C.mjs";
+  extractWgsl,
+  openMembersOf,
+  spanUnsettled
+} from "./token-goat-chunk-SOAFZNNZ.mjs";
 import {
   extractShellBannerHeading
-} from "./token-goat-chunk-VMFWNHGR.mjs";
-import "./token-goat-chunk-435UQTKD.mjs";
+} from "./token-goat-chunk-OXFMP75N.mjs";
+import "./token-goat-chunk-NISNMD7T.mjs";
+import "./token-goat-chunk-EVMZJ27Z.mjs";
+import "./token-goat-chunk-IK2DRMFX.mjs";
+import {
+  extractEnv,
+  extractIni
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
 import {
   GENERIC_CLAUSE,
-  assignBraceBlockSpans,
   assignFlatEndLines,
   buildLineIndex,
-  extractEnv,
-  extractIni,
+  closingQuoteRunEnd,
   findHtmlHeadingMatches,
-  findMatchingBraceEndLine,
   isInsideStringLiteral,
   lineTextAt,
   makeLineSymbol,
@@ -50,6 +61,7 @@ import {
   offsetToLine,
   precedingDocComment,
   propagateEndLinesToSymbols,
+  scalaCharLiteralLength,
   scanQuotedStringEnd,
   stripBlockCommentSpan,
   stripCstyleComments,
@@ -59,21 +71,27 @@ import {
   stripMultilineStringSpan,
   stripStringLiterals,
   stripXmlComments
-} from "./token-goat-chunk-7CPMDFGB.mjs";
-import "./token-goat-chunk-TGOXNAHW.mjs";
-import "./token-goat-chunk-XB5KKOCG.mjs";
+} from "./token-goat-chunk-OUKDTVNU.mjs";
+import "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
 import "./token-goat-chunk-YZAAZU2S.mjs";
 import "./token-goat-chunk-IVE6U7KV.mjs";
+import {
+  elementCursor,
+  findElements,
+  gtFinder
+} from "./token-goat-chunk-E45INMY3.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
 import {
   countContentLines,
   escapeRegExp,
   pushAll
-} from "./token-goat-chunk-XYWPOSCN.mjs";
-import "./token-goat-chunk-TCQANXYC.mjs";
-import "./token-goat-chunk-NMTKNYGF.mjs";
-import "./token-goat-chunk-MELOKFDJ.mjs";
-import "./token-goat-chunk-Y4AFKTHK.mjs";
-import "./token-goat-chunk-JTKCQMQA.mjs";
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -81,6 +99,682 @@ import {
 // src/languages/registry.ts
 init_define_import_meta_env();
 
+// src/languages/brace_spans.ts
+init_define_import_meta_env();
+function tripleQuoteDelimiters(opts) {
+  const delims = [];
+  if (opts?.tripleQuote === true) delims.push('"""');
+  if (opts?.tripleSingleQuote === true) delims.push("'''");
+  return delims;
+}
+function quoteRunLength(content, i) {
+  let n = 0;
+  while (content[i + n] === '"') n++;
+  return n;
+}
+function skipRawStringQuotes(content, from, min) {
+  return closingQuoteRunEnd(content, from, '"', min, "last");
+}
+function stepPowershellString(content, i, quote) {
+  const ch = content[i];
+  if (quote === '"' && ch === "`") return { next: i + 1, open: true };
+  return { next: i, open: ch !== quote };
+}
+function opensCsharpVerbatimString(content, i) {
+  const prev = content[i - 1];
+  return prev === "@" || prev === "$" && content[i - 2] === "@";
+}
+function toLineCommentPrefixes(prefix) {
+  if (prefix === void 0) return [];
+  return typeof prefix === "string" ? [prefix] : prefix;
+}
+function atLineComment(content, i, prefixes, exceptions) {
+  if (exceptions.some((e) => content.startsWith(e, i))) return false;
+  return prefixes.some((prefix) => content.startsWith(prefix, i));
+}
+function skipBlockComment(content, start, block, nested) {
+  let i = start + block[0].length;
+  let depth = 1;
+  while (i < content.length) {
+    if (nested && content.startsWith(block[0], i)) {
+      depth++;
+      i += block[0].length;
+      continue;
+    }
+    if (content.startsWith(block[1], i)) {
+      depth--;
+      i += block[1].length;
+      if (depth === 0) return i;
+      continue;
+    }
+    i++;
+  }
+  return -1;
+}
+function findMatchingBraceEndLine(content, openBraceIndex, totalLines, lineIndex, lineCommentPrefix, opts) {
+  const linePrefixes = toLineCommentPrefixes(lineCommentPrefix);
+  const lineExceptions = opts?.lineCommentExceptions ?? [];
+  const block = opts?.blockComment;
+  const backtick = opts?.backtickQuote === true;
+  const escapes = opts?.stringEscapes ?? "backslash";
+  const nestedBlock = opts?.nestedBlockComments === true;
+  const rawString = opts?.rawStringQuotes === true;
+  const rRaw = opts?.rRawStrings === true;
+  const tripleDelims = tripleQuoteDelimiters(opts);
+  const lineString = opts?.lineStringPrefix;
+  const interpolation = opts?.interpolation;
+  let interpolated = false;
+  let depth = 0;
+  let quote = null;
+  let verbatim = false;
+  for (let i = openBraceIndex; i < content.length; i++) {
+    const ch = content[i];
+    if (quote !== null) {
+      if (interpolated && interpolation !== void 0) {
+        const past = skipInterpolationAt(content, i, content.length, interpolation);
+        if (past !== null) {
+          i = past - 1;
+          continue;
+        }
+      }
+      if (verbatim) {
+        if (ch === quote) {
+          if (content[i + 1] === quote) {
+            i++;
+            continue;
+          }
+          quote = null;
+          verbatim = false;
+        }
+        continue;
+      }
+      if (escapes === "powershell") {
+        const step = stepPowershellString(content, i, quote);
+        i = step.next;
+        if (!step.open) quote = null;
+        continue;
+      }
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (block !== void 0 && content.startsWith(block[0], i)) {
+      const end = skipBlockComment(content, i, block, nestedBlock);
+      i = end === -1 ? content.length : end - 1;
+      continue;
+    }
+    if (atLineComment(content, i, linePrefixes, lineExceptions)) {
+      while (i < content.length && content[i] !== "\n") i++;
+      continue;
+    }
+    if (lineString !== void 0 && content.startsWith(lineString, i)) {
+      while (i < content.length && content[i] !== "\n") i++;
+      continue;
+    }
+    if (rRaw) {
+      const rOpen = matchRRawOpener(content, i);
+      if (rOpen !== null) {
+        const end = content.indexOf(rOpen.closer, rOpen.openerEnd);
+        i = end === -1 ? content.length : end + rOpen.closer.length - 1;
+        continue;
+      }
+    }
+    if (rawString && ch === '"') {
+      const run = quoteRunLength(content, i);
+      if (run >= 3) {
+        const end = skipRawStringQuotes(content, i + run, run);
+        i = end === -1 ? content.length : end - 1;
+        continue;
+      }
+    }
+    const tripleAt = tripleDelims.find((t) => content.startsWith(t, i));
+    if (tripleAt !== void 0) {
+      const end = closingQuoteRunEnd(content, i + 3, tripleAt[0] ?? '"', 3, opts?.tripleQuoteRunClose ?? "last");
+      i = end === -1 ? content.length : end - 1;
+      continue;
+    }
+    if (ch === "'" && opts?.symbolLiterals === true) {
+      const charLen = scalaCharLiteralLength(content, i);
+      if (charLen > 0) i += charLen - 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || backtick && ch === "`") {
+      quote = ch;
+      verbatim = escapes === "csharp" && ch === '"' && opensCsharpVerbatimString(content, i);
+      interpolated = interpolation !== void 0 && opensInterpolatedString(content, i, interpolation);
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return offsetToLine(lineIndex, i);
+      }
+    }
+  }
+  return opts?.noMatchValue ?? totalLines;
+}
+function assignBraceBlockSpans(symbols, content, opts = {}) {
+  const lineCommentPrefix = opts.lineComment;
+  const stringEscapes = opts.stringEscapes ?? "backslash";
+  const nestedBlockComments = opts.nestedBlockComments ?? false;
+  const tripleQuote = opts.tripleQuote ?? false;
+  const lineStringPrefix = opts.lineStringPrefix;
+  const firstLinePrefix = toLineCommentPrefixes(lineCommentPrefix)[0];
+  if (symbols.length === 0) return [...symbols];
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  const lineIndex = buildLineIndex(content);
+  const starts = [...new Set(symbols.map((s) => s.lineStart))].sort((a, b) => a - b);
+  const scanContent = opts.multilineLang === void 0 ? content : maskMultilineStrings(content, opts.multilineLang);
+  const blockComment = opts.blockComment !== void 0 ? opts.blockComment ?? void 0 : firstLinePrefix === "//" ? ["/*", "*/"] : firstLinePrefix === "#" ? ["<#", "#>"] : void 0;
+  const scanOpts = {
+    noMatchValue: -1,
+    stringEscapes,
+    tripleQuote,
+    rawStringQuotes: opts.rawStringQuotes ?? false,
+    tripleSingleQuote: opts.tripleSingleQuote ?? false,
+    tripleQuoteRunClose: opts.tripleQuoteRunClose ?? "last",
+    ...opts.interpolation === void 0 ? {} : { interpolation: opts.interpolation },
+    ...blockComment === void 0 ? {} : { blockComment, nestedBlockComments },
+    ...lineStringPrefix === void 0 ? {} : { lineStringPrefix },
+    ...opts.symbolLiterals === true ? { symbolLiterals: true } : {},
+    ...opts.lineCommentExceptions === void 0 ? {} : { lineCommentExceptions: opts.lineCommentExceptions }
+  };
+  return symbols.map((sym) => {
+    if (sym.lineEnd !== sym.lineStart) return sym;
+    const nextStart = starts.find((s) => s > sym.lineStart);
+    if (opts.expressionBodies === true) {
+      const arrowLast = Math.min(nextStart !== void 0 ? nextStart - 1 : totalLines, sym.lineStart + BRACE_SEARCH_MAX_LINES);
+      const arrowEnd = findArrowBodyEndLine(scanContent, lineIndex, sym.lineStart, arrowLast);
+      if (arrowEnd !== null) {
+        return arrowEnd <= sym.lineStart ? withWholeLineBody(sym, lines) : { ...sym, lineEnd: arrowEnd, body: lines.slice(sym.lineStart - 1, arrowEnd).join("\n") };
+      }
+    } else if (opts.expressionBodies === "kotlin") {
+      const eqEnd = findKotlinEqualsBodyEndLine(scanContent, lineIndex, sym.lineStart, nextStart !== void 0 ? nextStart - 1 : totalLines, opts.symbolLiterals === true);
+      if (eqEnd !== null) {
+        return eqEnd <= sym.lineStart ? withWholeLineBody(sym, lines) : { ...sym, lineEnd: eqEnd, body: lines.slice(sym.lineStart - 1, eqEnd).join("\n") };
+      }
+    }
+    const lastSearchLine = Math.min(nextStart !== void 0 ? nextStart - 1 : totalLines, sym.lineStart + BRACE_SEARCH_MAX_LINES);
+    const openIndex = findBlockOpenBrace(scanContent, lineIndex, sym.lineStart, lastSearchLine, lineCommentPrefix, TYPE_HEADER_KINDS.test(sym.kind) ? { ...scanOpts, typeHeader: true } : scanOpts);
+    if (openIndex === null) return sym;
+    if (opts.expressionBodies === "kotlin" && isAbstractValueFollowedByBareBlock(sym, scanContent, lineIndex, openIndex)) return sym;
+    const endLine = findMatchingBraceEndLine(
+      scanContent,
+      openIndex,
+      totalLines,
+      lineIndex,
+      lineCommentPrefix,
+      scanOpts
+    );
+    if (endLine === sym.lineStart) return withWholeLineBody(sym, lines);
+    if (endLine < sym.lineStart) return sym;
+    return { ...sym, lineEnd: endLine, body: lines.slice(sym.lineStart - 1, endLine).join("\n") };
+  });
+}
+function withWholeLineBody(sym, lines) {
+  const line = lines[sym.lineStart - 1];
+  if (line === void 0 || sym.body.includes("{") || !line.includes("{")) return sym;
+  return { ...sym, body: line.trimEnd() };
+}
+var BRACE_SEARCH_MAX_LINES = 10;
+function skipCsharpInterpolationHole(content, i, to) {
+  let depth = 0;
+  for (let k = i; k < to; k++) {
+    const lit = skipCsharpLiteral(content, k, to);
+    if (lit !== null) {
+      k = lit - 1;
+      continue;
+    }
+    const ch = content[k];
+    if (ch === "{") depth++;
+    else if (ch === "}" && --depth === 0) return k + 1;
+  }
+  return to;
+}
+function skipCsharpLiteral(content, i, to) {
+  const first = content[i];
+  if (first === "'") {
+    if (content[i + 1] === "\\") {
+      const close = content.indexOf("'", i + 3);
+      return close === -1 || close >= to ? null : close + 1;
+    }
+    return content[i + 2] === "'" ? i + 3 : null;
+  }
+  let j = i;
+  while ((content[j] === "$" || content[j] === "@") && j - i < 3) j++;
+  if (content[j] !== '"') return null;
+  const prefix = content.slice(i, j);
+  if (j > i && /[A-Za-z0-9_]/.test(content[i - 1] ?? "")) return null;
+  const interpolated = prefix.includes("$");
+  const verbatim = prefix.includes("@");
+  const run = quoteRunLength(content, j);
+  if (run >= 3) {
+    const end = skipRawStringQuotes(content, j + run, run);
+    return end === -1 ? to : end;
+  }
+  for (let k = j + 1; k < to; k++) {
+    const ch = content[k];
+    if (ch === void 0) break;
+    if (verbatim) {
+      if (ch === '"') {
+        if (content[k + 1] === '"') {
+          k++;
+          continue;
+        }
+        return k + 1;
+      }
+    } else if (ch === "\\") {
+      k++;
+      continue;
+    } else if (ch === '"') return k + 1;
+    if (interpolated) {
+      if (ch === "{") {
+        if (content[k + 1] === "{") {
+          k++;
+          continue;
+        }
+        k = skipCsharpInterpolationHole(content, k, to) - 1;
+      }
+    }
+  }
+  return to;
+}
+function findArrowBodyEndLine(content, lineIndex, startLine, lastSearchLine) {
+  const from = lineIndex[startLine - 1];
+  if (from === void 0) return null;
+  const to = lineIndex[lastSearchLine] ?? content.length;
+  let depth = 0;
+  let seenArrow = false;
+  for (let i = from; i < to; i++) {
+    const ch = content[i];
+    if (ch === void 0) break;
+    if (ch === "/" && content[i + 1] === "/") {
+      while (i + 1 < to && content[i + 1] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && content[i + 1] === "*") {
+      const end = content.indexOf("*/", i + 2);
+      if (end === -1) return null;
+      i = end + 1;
+      continue;
+    }
+    const lit = skipCsharpLiteral(content, i, to);
+    if (lit !== null) {
+      i = lit - 1;
+      continue;
+    }
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") {
+      if (depth > 0) depth--;
+    } else if (ch === "=" && content[i + 1] === ">" && depth === 0) {
+      seenArrow = true;
+      i++;
+    } else if (ch === "{") {
+      if (!seenArrow && depth === 0) return null;
+      depth++;
+    } else if (ch === "}") {
+      if (depth === 0) return null;
+      depth--;
+    } else if (ch === ";" && depth === 0) {
+      if (!seenArrow) return null;
+      let line = startLine;
+      for (let k = from; k < i; k++) if (content[k] === "\n") line++;
+      return line;
+    }
+  }
+  return null;
+}
+function skipKotlinTemplateHole(content, i, to, symbolLiterals = false) {
+  let depth = 0;
+  for (let k = i; k < to; k++) {
+    const lit = skipKotlinLiteral(content, k, to, symbolLiterals);
+    if (lit !== null) {
+      k = lit - 1;
+      continue;
+    }
+    const ch = content[k];
+    if (ch === "{") depth++;
+    else if (ch === "}" && --depth === 0) return k + 1;
+  }
+  return to;
+}
+function skipKotlinLiteral(content, i, to, symbolLiterals = false) {
+  const first = content[i];
+  if (first === "'" && symbolLiterals) {
+    const len = scalaCharLiteralLength(content, i);
+    return len > 0 ? i + len : null;
+  }
+  if (first === "'") {
+    for (let k = i + 1; k < to && content[k] !== "\n"; k++) {
+      if (content[k] === "\\") {
+        k++;
+        continue;
+      }
+      if (content[k] === "'") return k + 1;
+    }
+    return null;
+  }
+  if (first !== '"') return null;
+  const triple = content.startsWith('"""', i);
+  for (let k = i + (triple ? 3 : 1); k < to; k++) {
+    const ch = content[k];
+    if (triple) {
+      if (ch === '"' && content.startsWith('"""', k)) {
+        k += 3;
+        while (content[k] === '"') k++;
+        return k;
+      }
+    } else if (ch === "\\") {
+      k++;
+      continue;
+    } else if (ch === '"') return k + 1;
+    else if (ch === "\n") return k;
+    if (ch === "$" && content[k + 1] === "{") k = skipKotlinTemplateHole(content, k + 1, to, symbolLiterals) - 1;
+  }
+  return to;
+}
+function opensInterpolatedString(content, i, lang) {
+  const q = content[i];
+  const prev = content[i - 1] ?? "";
+  if (lang === "csharp") return q === '"' && (prev === "$" || prev === "@" && content[i - 2] === "$");
+  if (lang === "scala") return q === '"' && /[A-Za-z0-9_]/.test(prev);
+  if (lang === "dart") return !(prev === "r" && !/[A-Za-z0-9_$]/.test(content[i - 2] ?? ""));
+  return q === '"';
+}
+function skipInterpolationAt(content, i, to, lang) {
+  const ch = content[i];
+  if (lang === "swift") return ch === "\\" && content[i + 1] === "(" ? skipInterpolationHole(content, i + 1, to, lang) : null;
+  if (lang === "csharp") {
+    if (ch !== "{") return null;
+    return content[i + 1] === "{" ? i + 2 : skipInterpolationHole(content, i, to, lang);
+  }
+  return ch === "$" && content[i + 1] === "{" ? skipInterpolationHole(content, i + 1, to, lang) : null;
+}
+function skipInterpolationHole(content, i, to, lang) {
+  const open = content[i];
+  const close = open === "(" ? ")" : "}";
+  let depth = 0;
+  for (let k = i; k < to; k++) {
+    const lit = skipNestedLiteral(content, k, to, lang);
+    if (lit !== null) {
+      k = lit - 1;
+      continue;
+    }
+    const ch = content[k];
+    if (ch === open) depth++;
+    else if (ch === close && --depth === 0) return k + 1;
+  }
+  return to;
+}
+function skipNestedLiteral(content, i, to, lang) {
+  const ch = content[i];
+  if (lang === "csharp") return skipCsharpLiteral(content, i, to);
+  if (lang === "kotlin") return skipKotlinLiteral(content, i, to);
+  if (ch === "'" && lang === "scala") {
+    const len = scalaCharLiteralLength(content, i);
+    return len > 0 ? i + len : null;
+  }
+  if (ch !== '"' && !(ch === "'" && lang === "dart")) return null;
+  return skipInterpolatedString(content, i, to, lang, opensInterpolatedString(content, i, lang));
+}
+function skipInterpolatedString(content, i, to, lang, interpolated) {
+  const q = content[i];
+  if (content.startsWith(q + q + q, i)) {
+    const end = content.indexOf(q + q + q, i + 3);
+    return end === -1 || end >= to ? to : end + 3;
+  }
+  for (let k = i + 1; k < to; k++) {
+    const ch = content[k];
+    if (ch === "\n") return k;
+    if (interpolated) {
+      const past = skipInterpolationAt(content, k, to, lang);
+      if (past !== null) {
+        k = past - 1;
+        continue;
+      }
+    }
+    if (ch === "\\") {
+      k++;
+      continue;
+    }
+    if (ch === q) return k + 1;
+  }
+  return to;
+}
+function kotlinBodyContinues(content, lastSig, ifParenClosedAt, nextLineFrom) {
+  const c = content[lastSig];
+  const prev = content[lastSig - 1];
+  if (lastSig === ifParenClosedAt) return true;
+  if (c !== void 0 && "=*/%&|,.:".includes(c)) return true;
+  if ((c === "+" || c === "-") && prev !== c) return true;
+  if (c === ">" && prev === "-") return true;
+  if (/(?:^|[^A-Za-z0-9_])else$/.test(content.slice(Math.max(0, lastSig - 4), lastSig + 1))) return true;
+  const rest = content.slice(nextLineFrom);
+  const next = /^(?:[ \t\r]*(?:\/\/[^\n]*)?\n)*[ \t]*(\.|\?\.|\?:|&&|\|\||else\b|as\b|catch\b|finally\b)/.exec(rest);
+  return next !== null;
+}
+var NEXT_LINE_STARTS_WITH_EQUALS = /^(?:[ \t\r]*(?:\/\/[^\n]*)?\n)*[ \t]*=(?!=)/;
+function findKotlinEqualsBodyEndLine(content, lineIndex, startLine, lastLine, symbolLiterals = false) {
+  const from = lineIndex[startLine - 1];
+  if (from === void 0) return null;
+  const to = lineIndex[lastLine] ?? content.length;
+  let depth = 0;
+  let seenEq = false;
+  let line = startLine;
+  let lastSig = -1;
+  let ifParenClosedAt = -1;
+  const ifParens = [];
+  for (let i = from; i < to; i++) {
+    const ch = content[i];
+    if (ch === void 0) break;
+    if (ch === "\n") {
+      if (depth === 0) {
+        if (!seenEq && !NEXT_LINE_STARTS_WITH_EQUALS.test(content.slice(i + 1, to))) return null;
+        if (seenEq && !kotlinBodyContinues(content, lastSig, ifParenClosedAt, i + 1)) return line;
+      }
+      line++;
+      continue;
+    }
+    if (ch === " " || ch === "	" || ch === "\r") continue;
+    if (ch === "/" && content[i + 1] === "/") {
+      while (i + 1 < to && content[i + 1] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && content[i + 1] === "*") {
+      const end = content.indexOf("*/", i + 2);
+      if (end === -1) return null;
+      for (let k = i; k < end; k++) if (content[k] === "\n") line++;
+      i = end + 1;
+      continue;
+    }
+    const lit = skipKotlinLiteral(content, i, to, symbolLiterals);
+    if (lit !== null) {
+      for (let k = i; k < lit; k++) if (content[k] === "\n") line++;
+      lastSig = lit - 1;
+      i = lit - 1;
+      continue;
+    }
+    lastSig = i;
+    if (ch === "(" || ch === "[" || ch === "{") {
+      if (ch === "{" && !seenEq && depth === 0) return null;
+      ifParens.push(ch === "(" && /\bif\s*$/.test(content.slice(Math.max(from, i - 8), i)));
+      depth++;
+    } else if (ch === ")" || ch === "]" || ch === "}") {
+      if (depth === 0) return null;
+      depth--;
+      if (ifParens.pop() === true) ifParenClosedAt = i;
+    } else if (ch === "=" && !seenEq && depth === 0 && !"=!<>".includes(content[i - 1] ?? " ") && content[i + 1] !== "=") {
+      seenEq = true;
+    }
+  }
+  return seenEq && depth === 0 ? line : null;
+}
+function maskMultilineStrings(content, lang) {
+  let state = null;
+  const parts = [];
+  let pos = 0;
+  for (; ; ) {
+    const nl = content.indexOf("\n", pos);
+    const end = nl === -1 ? content.length : nl;
+    const lineEnd = end > pos && content[end - 1] === "\r" ? end - 1 : end;
+    const masked = stripMultilineStringSpan(content.slice(pos, lineEnd), state, lang);
+    state = masked.state;
+    parts.push(masked.code, content.slice(lineEnd, end));
+    if (nl === -1) break;
+    parts.push("\n");
+    pos = nl + 1;
+  }
+  return parts.join("");
+}
+function findBlockOpenBrace(content, lineIndex, startLine, lastSearchLine, lineCommentPrefix, opts) {
+  const blockComment = opts?.blockComment;
+  const stringEscapes = opts?.stringEscapes ?? "backslash";
+  const nestedBlockComments = opts?.nestedBlockComments === true;
+  const rawString = opts?.rawStringQuotes === true;
+  const tripleDelims = tripleQuoteDelimiters(opts);
+  const lineString = opts?.lineStringPrefix;
+  const linePrefixes = toLineCommentPrefixes(lineCommentPrefix);
+  const lineExceptions = opts?.lineCommentExceptions ?? [];
+  const from = lineIndex[startLine - 1];
+  if (from === void 0) return null;
+  const to = lineIndex[lastSearchLine] ?? content.length;
+  const interpolation = opts?.interpolation;
+  let interpolated = false;
+  let quote = null;
+  let parenDepth = 0;
+  let linesSeen = 0;
+  let atLineStart = false;
+  let verbatim = false;
+  for (let i = from; i < to; i++) {
+    const ch = content[i];
+    if (ch === void 0) break;
+    if (quote !== null) {
+      if (interpolated && interpolation !== void 0) {
+        const past = skipInterpolationAt(content, i, to, interpolation);
+        if (past !== null) {
+          i = past - 1;
+          continue;
+        }
+      }
+      if (verbatim) {
+        if (ch === quote) {
+          if (content[i + 1] === quote) {
+            i++;
+            continue;
+          }
+          quote = null;
+          verbatim = false;
+        }
+        continue;
+      }
+      if (stringEscapes === "powershell") {
+        const step = stepPowershellString(content, i, quote);
+        i = step.next;
+        if (!step.open) quote = null;
+        continue;
+      }
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "\n") {
+      linesSeen++;
+      atLineStart = true;
+      continue;
+    }
+    if (blockComment !== void 0 && content.startsWith(blockComment[0], i)) {
+      const end = skipBlockComment(content, i, blockComment, nestedBlockComments);
+      if (end === -1) return null;
+      i = end - 1;
+      continue;
+    }
+    if (atLineComment(content, i, linePrefixes, lineExceptions)) {
+      while (i + 1 < to && content[i + 1] !== "\n") i++;
+      continue;
+    }
+    if (atLineStart && !/\s/.test(ch)) {
+      atLineStart = false;
+      if (parenDepth === 0 && linesSeen >= 1 && startsWithBlockKeyword(content, i, to, opts?.typeHeader !== true)) return null;
+    }
+    if (lineString !== void 0 && content.startsWith(lineString, i)) {
+      while (i + 1 < to && content[i + 1] !== "\n") i++;
+      continue;
+    }
+    if (rawString && ch === '"') {
+      const run = quoteRunLength(content, i);
+      if (run >= 3) {
+        const end = skipRawStringQuotes(content, i + run, run);
+        if (end === -1) return null;
+        i = end - 1;
+        continue;
+      }
+    }
+    const tripleAt = tripleDelims.find((t) => content.startsWith(t, i));
+    if (tripleAt !== void 0) {
+      const end = closingQuoteRunEnd(content, i + 3, tripleAt[0] ?? '"', 3, opts?.tripleQuoteRunClose ?? "last");
+      if (end === -1) return null;
+      i = end - 1;
+      continue;
+    }
+    if (ch === "'" && opts?.symbolLiterals === true) {
+      const charLen = scalaCharLiteralLength(content, i);
+      if (charLen > 0) i += charLen - 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      verbatim = stringEscapes === "csharp" && ch === '"' && opensCsharpVerbatimString(content, i);
+      interpolated = interpolation !== void 0 && opensInterpolatedString(content, i, interpolation);
+      continue;
+    }
+    if (ch === "(" || ch === "[") parenDepth++;
+    else if (ch === ")" || ch === "]") {
+      if (parenDepth > 0) parenDepth--;
+    } else if (ch === ";") return null;
+    else if (ch === "}" && parenDepth === 0) return null;
+    else if (ch === "{") return i;
+  }
+  return null;
+}
+var BLOCK_OPENING_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "when",
+  "match",
+  "try",
+  "foreach",
+  "loop",
+  "guard",
+  "repeat",
+  "unless",
+  "until"
+]);
+function isAbstractValueFollowedByBareBlock(sym, content, lineIndex, openIndex) {
+  const openLine = offsetToLine(lineIndex, openIndex);
+  return /^va[lr]$/.test(sym.kind) && openLine > sym.lineStart && lineTextAt(content, lineIndex, openLine) === "{" && !lineTextAt(content, lineIndex, sym.lineStart).includes("=");
+}
+var TYPE_HEADER_KINDS = /^(?:class|object|interface|trait|enum|struct|protocol|record|extension)$/;
+var MEMBER_START_WORDS = /* @__PURE__ */ new Set(["init", "locally", "constructor", "companion"]);
+function startsWithBlockKeyword(content, i, to, members) {
+  const first = content[i];
+  if (first === void 0 || !/[A-Za-z_]/.test(first)) return false;
+  let j = i + 1;
+  while (j < to && /[A-Za-z0-9_]/.test(content[j])) j++;
+  const word = content.slice(i, j);
+  return BLOCK_OPENING_KEYWORDS.has(word) || members && MEMBER_START_WORDS.has(word);
+}
+
 // src/languages/csharp.ts
 init_define_import_meta_env();
 var IDENT = "@?[A-Za-z_][A-Za-z0-9_]*";
@@ -144,6 +838,13 @@ var PROPERTY_ARROW_RE = new RegExp(
 var CONSTRUCTOR_RE = new RegExp(
   `${MEMBER_INDENT}(?:(?:public|protected|private|internal|static)\\s+)*(${IDENT})\\s*\\(`
 );
+var FINALIZER_RE = new RegExp(`${MEMBER_INDENT}(?:(?:extern|unsafe)\\s+)*~\\s*(${IDENT})\\s*\\(`);
+var OPERATOR_RE = /\b(?:implicit|explicit)\s+operator\s([^(]+)\(|\boperator(\s+checked)?\s*([-+!~*/%&|^<>=]+|true|false)\s*\(/;
+var INDEXER_RE = /\bthis\s*\[/;
+var DECLARATION_PREFIX_RE = /^[\w@.<>,?[\]()\s]*$/;
+function isDeclarationPrefix(prefix) {
+  return DECLARATION_PREFIX_RE.test(prefix) && /\w/.test(prefix);
+}
 var CLASS_HEADER_RE = new RegExp(
   `^(?:(?:public|protected|private|internal|abstract|sealed|static|partial|readonly|ref|unsafe|file|new)\\s+)*(class|struct|interface|enum|record)(?:\\s+(?:class|struct))?\\s+(${IDENT})`
 );
@@ -159,9 +860,162 @@ function nextCodeLines(lines, from, count) {
   }
   return out;
 }
+function typeKind(keyword) {
+  return keyword === "struct" ? "struct" : keyword === "interface" ? "interface" : keyword === "enum" ? "enum" : "class";
+}
+function operatorName(opM) {
+  return opM[1] !== void 0 ? `operator ${opM[1].replace(/\s+/g, " ").trim()}` : `operator${opM[2] !== void 0 ? " checked " : ""}${opM[3] ?? ""}`;
+}
+function memberDecls(decl, parent) {
+  const delM = DELEGATE_RE.exec(decl);
+  if (delM) return [[stripVerbatim(delM[1] ?? ""), "type"]];
+  const eventM = EVENT_RE.exec(decl);
+  if (eventM) {
+    const out = [];
+    for (const part of splitEventDeclarators(decl.slice(eventM[0].length).split(/[;{]/)[0] ?? "")) {
+      const declM = EVENT_NAME_RE.exec(part.split("=")[0]?.trim() ?? "");
+      if (declM) out.push([stripVerbatim(declM[1] ?? ""), "var"]);
+    }
+    return out;
+  }
+  const ctorM = CONSTRUCTOR_RE.exec(decl);
+  if (ctorM && stripVerbatim(ctorM[1] ?? "") === parent) return [[parent, "method"]];
+  const propM = PROPERTY_RE.exec(decl) ?? PROPERTY_ARROW_RE.exec(decl);
+  if (propM) return [[stripVerbatim(propM[1] ?? ""), "var"]];
+  const finM = FINALIZER_RE.exec(decl);
+  if (finM && stripVerbatim(finM[1] ?? "") === parent) return [[`~${parent}`, "method"]];
+  const opM = OPERATOR_RE.exec(decl);
+  if (opM && isDeclarationPrefix(decl.slice(0, opM.index))) return [[operatorName(opM), "method"]];
+  const ixM = INDEXER_RE.exec(decl);
+  if (ixM && isDeclarationPrefix(decl.slice(0, ixM.index))) return [["this[]", "var"]];
+  const methM = METHOD_RE.exec(decl);
+  const mname = methM ? stripVerbatim(methM[1] ?? "") : "";
+  return mname && mname !== parent ? [[mname, "method"]] : [];
+}
+function inlineCsharpMembers(line, code, segs, parent, filePath, lineNum, level = 0) {
+  const members = [];
+  const opens = [];
+  for (const seg of segs) {
+    const text = line.slice(seg.start, seg.end).trim();
+    const decl = stripLeadingAttributes(text);
+    const classM = CLASS_HEADER_RE.exec(decl);
+    if (classM) {
+      const brace = bodyBraceAt(code, seg.start, seg.end);
+      if (seg.open && brace === -1) continue;
+      const name = stripVerbatim(classM[2] ?? "");
+      const typeSym = makeLineSymbol(filePath, name, typeKind(classM[1] ?? "class"), lineNum, text, parent);
+      members.push(typeSym);
+      if (brace !== -1) {
+        const inner = inlineCsharpMembers(line, code, bodySegments(code, brace + 1), name, filePath, lineNum, level + 1);
+        members.push(...inner.members);
+        if (seg.open) opens.push({ sym: typeSym, level, isType: true }, ...inner.opens);
+      }
+      continue;
+    }
+    for (const [name, kind] of memberDecls(decl, parent)) {
+      const sym = makeLineSymbol(filePath, name, kind, lineNum, text, parent);
+      members.push(sym);
+      if (seg.open) opens.push({ sym, level, isType: false });
+    }
+  }
+  return { members, opens };
+}
+var CS_REF_NOISE = /* @__PURE__ */ new Set([
+  "if",
+  "else",
+  "while",
+  "for",
+  "foreach",
+  "switch",
+  "case",
+  "catch",
+  "finally",
+  "using",
+  "lock",
+  "fixed",
+  "sizeof",
+  "typeof",
+  "nameof",
+  "default",
+  "checked",
+  "unchecked",
+  "delegate",
+  "return",
+  "throw",
+  "yield",
+  "base",
+  "this",
+  "new",
+  "var",
+  "async",
+  "await",
+  "get",
+  "set",
+  "init",
+  "add",
+  "remove",
+  "where",
+  "when",
+  "select",
+  "from",
+  "join",
+  "into",
+  "let",
+  "orderby",
+  "group",
+  "by",
+  "equals",
+  "on",
+  "ascending",
+  "descending",
+  "true",
+  "false",
+  "null",
+  "void",
+  "bool",
+  "byte",
+  "sbyte",
+  "short",
+  "ushort",
+  "int",
+  "uint",
+  "long",
+  "ulong",
+  "float",
+  "double",
+  "decimal",
+  "char",
+  "string",
+  "object",
+  "dynamic",
+  "public",
+  "private",
+  "protected",
+  "internal",
+  "static",
+  "readonly",
+  "volatile",
+  "virtual",
+  "override",
+  "abstract",
+  "sealed",
+  "extern",
+  "unsafe",
+  "partial",
+  "class",
+  "struct",
+  "interface",
+  "enum",
+  "record"
+]);
+var CS_NEW_CALL_RE = /\bnew\s+([A-Za-z_][A-Za-z0-9_.]*)(?:<[^>()]+>)?\s*(?:\(|(?=\{))/g;
+var CS_INVOCATION_RE = /(?:\b([A-Za-z_][A-Za-z0-9_]*)\s*(?:\.|\?\.)\s*|(?:\.|\?\.)\s*)?\b([A-Za-z_][A-Za-z0-9_]*)(?:\s*<[^>()\n]+>)?\s*\(/g;
+var CS_MULTILINE_INVOCATION_RE = /(?:\b([A-Za-z_][A-Za-z0-9_]*)\s*(?:\.|\?\.)\s*|(?:\.|\?\.)\s*)?\b([A-Za-z_][A-Za-z0-9_]*)(?:\s*<[^>()\n]+>)?\s*$/;
 function extractCsharp(content, filePath) {
   const symbols = [];
+  const refs = [];
   const imports = [];
+  const seenRefs = /* @__PURE__ */ new Set();
   const lines = content.split(/\r?\n/);
   const classStack = [];
   let braceDepth = 0;
@@ -169,6 +1023,10 @@ function extractCsharp(content, filePath) {
   let mlState = null;
   let inFalseBlock = false;
   let falseNesting = 0;
+  let currentMember;
+  let memberBodyEntered = false;
+  const settled = /* @__PURE__ */ new Set();
+  let openMembers = [];
   for (let i = 0; i < lines.length; i++) {
     const rawLine = lines[i] ?? "";
     const lineNum = i + 1;
@@ -210,25 +1068,31 @@ function extractCsharp(content, filePath) {
       const delegateParent = classStack.length > 0 ? classStack[classStack.length - 1].name : void 0;
       symbols.push(makeLineSymbol(filePath, stripVerbatim(delM[1] ?? ""), "type", lineNum, stripped.slice(0, 200), delegateParent, lines, "c"));
     }
+    const outerFrame = classStack.length > 0 ? classStack[classStack.length - 1] : null;
     const cm = CLASS_HEADER_RE.exec(stripLeadingAttributes(stripped));
     if (cm) {
-      const keyword = cm[1] ?? "class";
       const cname = stripVerbatim(cm[2] ?? "");
-      const kind = keyword === "struct" ? "struct" : keyword === "interface" ? "interface" : keyword === "enum" ? "enum" : "class";
-      const parent = classStack.length > 0 ? classStack[classStack.length - 1].name : void 0;
-      symbols.push(makeLineSymbol(filePath, cname, kind, lineNum, stripped.slice(0, 200), parent, lines, "c"));
+      symbols.push(makeLineSymbol(filePath, cname, typeKind(cm[1] ?? "class"), lineNum, stripped.slice(0, 200), outerFrame?.name, lines, "c"));
       classStack.push({ name: cname, startDepth: braceDepth, bodyEntered: false });
     }
+    let ctorM = null;
+    let finM = null;
+    let methM = null;
+    let propM = null;
+    let headerM = null;
+    let arrowM = null;
     const frame = classStack.length > 0 ? classStack[classStack.length - 1] : null;
     if (frame !== null) {
       const depthInClass = braceDepth - frame.startDepth;
       if (depthInClass === 1) {
         const lineNoAttr = stripLeadingAttributes(line);
-        const ctorM = CONSTRUCTOR_RE.exec(lineNoAttr);
+        ctorM = CONSTRUCTOR_RE.exec(lineNoAttr);
         if (ctorM && stripVerbatim(ctorM[1] ?? "") === frame.name) {
           const sigEnd = line.indexOf("{");
           const sig = sigEnd >= 0 ? line.slice(0, sigEnd).trimEnd() : line.trimEnd();
           symbols.push(makeLineSymbol(filePath, frame.name, "method", lineNum, sig.slice(0, 200), frame.name, lines, "c"));
+          currentMember = frame.name;
+          memberBodyEntered = line.includes("{");
         }
         let isPropertyLine = false;
         const eventM = EVENT_RE.exec(lineNoAttr);
@@ -240,41 +1104,217 @@ function extractCsharp(content, filePath) {
             if (declM) symbols.push(makeLineSymbol(filePath, stripVerbatim(declM[1] ?? ""), "var", lineNum, stripped.slice(0, 200), frame.name, lines, "c"));
           }
         }
-        const propM = isPropertyLine ? null : PROPERTY_RE.exec(lineNoAttr);
+        propM = isPropertyLine ? null : PROPERTY_RE.exec(lineNoAttr);
         if (propM) {
           isPropertyLine = true;
-          symbols.push(makeLineSymbol(filePath, stripVerbatim(propM[1] ?? ""), "var", lineNum, stripped.slice(0, 200), frame.name, lines, "c"));
+          const propName = stripVerbatim(propM[1] ?? "");
+          symbols.push(makeLineSymbol(filePath, propName, "var", lineNum, stripped.slice(0, 200), frame.name, lines, "c"));
+          currentMember = propName;
+          memberBodyEntered = line.includes("{");
         } else {
-          const headerM = PROPERTY_HEADER_RE.exec(lineNoAttr);
+          headerM = PROPERTY_HEADER_RE.exec(lineNoAttr);
           if (headerM) {
             const [braceLineNext = "", accessorLine = ""] = nextCodeLines(lines, i, 2);
             if (braceLineNext === "{" && (ALLMAN_ACCESSOR_RE.test(accessorLine) || ALLMAN_ACCESSOR_BODY_RE.test(accessorLine))) {
               isPropertyLine = true;
-              symbols.push(makeLineSymbol(filePath, stripVerbatim(headerM[1] ?? ""), "var", lineNum, stripped.slice(0, 200), frame.name, lines, "c"));
+              const propName = stripVerbatim(headerM[1] ?? "");
+              symbols.push(makeLineSymbol(filePath, propName, "var", lineNum, stripped.slice(0, 200), frame.name, lines, "c"));
+              currentMember = propName;
+              memberBodyEntered = false;
             }
           } else {
-            const arrowM = PROPERTY_ARROW_RE.exec(lineNoAttr);
+            arrowM = PROPERTY_ARROW_RE.exec(lineNoAttr);
             if (arrowM) {
               isPropertyLine = true;
-              symbols.push(makeLineSymbol(filePath, stripVerbatim(arrowM[1] ?? ""), "var", lineNum, stripped.slice(0, 200), frame.name, lines, "c"));
+              const propName = stripVerbatim(arrowM[1] ?? "");
+              symbols.push(makeLineSymbol(filePath, propName, "var", lineNum, stripped.slice(0, 200), frame.name, lines, "c"));
+              currentMember = propName;
+              memberBodyEntered = false;
             }
           }
         }
-        const methM = isPropertyLine ? null : METHOD_RE.exec(lineNoAttr);
+        let specialName = null;
+        let specialKind = "method";
+        finM = FINALIZER_RE.exec(lineNoAttr);
+        if (finM && stripVerbatim(finM[1] ?? "") === frame.name) specialName = `~${frame.name}`;
+        else finM = null;
+        const opM = specialName === null && !isPropertyLine ? OPERATOR_RE.exec(lineNoAttr) : null;
+        if (opM && isDeclarationPrefix(lineNoAttr.slice(0, opM.index))) specialName = operatorName(opM);
+        const ixM = specialName === null && !isPropertyLine ? INDEXER_RE.exec(lineNoAttr) : null;
+        if (ixM && isDeclarationPrefix(lineNoAttr.slice(0, ixM.index))) {
+          specialName = "this[]";
+          specialKind = "var";
+        }
+        if (specialName !== null) {
+          isPropertyLine = true;
+          const sigEnd = line.indexOf("{");
+          const sig = sigEnd >= 0 ? line.slice(0, sigEnd).trimEnd() : line.trimEnd();
+          symbols.push(makeLineSymbol(filePath, specialName, specialKind, lineNum, sig.slice(0, 200), frame.name, lines, "c"));
+          currentMember = specialName;
+          memberBodyEntered = line.includes("{");
+        }
+        methM = isPropertyLine ? null : METHOD_RE.exec(lineNoAttr);
         if (methM) {
           const mname = stripVerbatim(methM[1] ?? "");
           if (mname && mname !== frame.name) {
             const sigEnd = line.indexOf("{");
             const sig = sigEnd >= 0 ? line.slice(0, sigEnd).trimEnd() : line.trimEnd();
             symbols.push(makeLineSymbol(filePath, mname, "method", lineNum, sig.slice(0, 200), frame.name, lines, "c"));
+            currentMember = mname;
+            memberBodyEntered = line.includes("{");
+          }
+        }
+      }
+    }
+    const isInterpolatedLine = rawLine.includes('$"') || rawLine.includes('$@"') || rawLine.includes('@$"');
+    const baseLine = isInterpolatedLine ? stripLineComment(rawLine) : stripLineComment(line);
+    const braceLine = stripStringLiterals(baseLine, { tripleQuotes: true });
+    const segCode = stripStringLiterals(line, { tripleQuotes: true });
+    const lineOpens = [];
+    const queueMembers = (segs, parent, bodyDepth) => {
+      const { members, opens } = inlineCsharpMembers(line, segCode, segs, parent, filePath, lineNum);
+      symbols.push(...members);
+      for (const m of members) settled.add(m);
+      lineOpens.push(...openMembersOf(opens, bodyDepth));
+      for (const o of opens) {
+        if (!o.isType) continue;
+        const enclosing = classStack[classStack.length - 1];
+        if (enclosing !== void 0) enclosing.bodyEntered = true;
+        classStack.push({ name: o.sym.name, startDepth: bodyDepth + o.level, bodyEntered: true });
+      }
+    };
+    const lineSegs = bodySegments(segCode, 0);
+    if (frame !== null && frame !== outerFrame && lineSegs[0] !== void 0) {
+      const brace = bodyBraceAt(segCode, lineSegs[0].start, lineSegs[0].end);
+      if (brace !== -1) queueMembers(bodySegments(segCode, brace + 1), frame.name, braceDepth + 1);
+    }
+    const insideMember = outerFrame === null ? -1 : braceDepth - outerFrame.startDepth - 1;
+    if (outerFrame !== null && insideMember >= 0) {
+      const resume = bodyResumeAt(segCode, insideMember);
+      if (resume >= 0) queueMembers(insideMember === 0 ? lineSegs.slice(1) : bodySegments(segCode, resume), outerFrame.name, outerFrame.startDepth + 1);
+    }
+    if (!inFalseBlock && !stripped.startsWith("#")) {
+      const declSpans = [];
+      if (cm) {
+        const name = stripVerbatim(cm[2] ?? "");
+        declSpans.push({ name, col: line.indexOf(name) });
+      }
+      if (ctorM) {
+        const name = stripVerbatim(ctorM[1] ?? "");
+        declSpans.push({ name, col: line.indexOf(name) });
+      }
+      if (methM) {
+        const name = stripVerbatim(methM[1] ?? "");
+        declSpans.push({ name, col: line.indexOf(name) });
+      }
+      if (delM) {
+        const name = stripVerbatim(delM[1] ?? "");
+        declSpans.push({ name, col: line.indexOf(name) });
+      }
+      if (propM) {
+        const name = stripVerbatim(propM[1] ?? "");
+        declSpans.push({ name, col: line.indexOf(name) });
+      }
+      if (headerM) {
+        const name = stripVerbatim(headerM[1] ?? "");
+        declSpans.push({ name, col: line.indexOf(name) });
+      }
+      if (finM) declSpans.push({ name: stripVerbatim(finM[1] ?? ""), col: line.indexOf("~") + 1 });
+      if (arrowM) {
+        const name = stripVerbatim(arrowM[1] ?? "");
+        declSpans.push({ name, col: line.indexOf(name) });
+      }
+      const isDeclaration = (name, col) => declSpans.some((d) => d.name === name && Math.abs(d.col - col) <= 2);
+      const context = currentMember ?? (frame !== null ? frame.name : "");
+      for (const m of braceLine.matchAll(CS_NEW_CALL_RE)) {
+        const rawName = stripVerbatim(m[1] ?? "");
+        const name = rawName.includes(".") ? rawName.slice(rawName.lastIndexOf(".") + 1) : rawName;
+        if (name.length < 1 || CS_REF_NOISE.has(name)) continue;
+        const nameOffset = m[0].lastIndexOf(name);
+        const col = m.index !== void 0 ? m.index + (nameOffset >= 0 ? nameOffset : 0) : 0;
+        if (isDeclaration(name, col)) continue;
+        const key = `${name}\0${lineNum}`;
+        if (!seenRefs.has(key)) {
+          seenRefs.add(key);
+          refs.push({ filePath, name, line: lineNum, col, context });
+        }
+      }
+      for (const m of braceLine.matchAll(CS_INVOCATION_RE)) {
+        const callee = stripVerbatim(m[2] ?? "");
+        if (callee.length >= 1 && !CS_REF_NOISE.has(callee)) {
+          const dotIdx = m[0].indexOf(".");
+          const searchStart = dotIdx >= 0 ? m[0].lastIndexOf(".") + 1 : 0;
+          const calleeOffset = m[0].indexOf(callee, searchStart);
+          const col = m.index !== void 0 ? m.index + (calleeOffset >= 0 ? calleeOffset : 0) : 0;
+          if (!isDeclaration(callee, col)) {
+            const key = `${callee}\0${lineNum}`;
+            if (!seenRefs.has(key)) {
+              seenRefs.add(key);
+              refs.push({ filePath, name: callee, line: lineNum, col, context });
+            }
+          }
+        }
+        const receiver = m[1] !== void 0 ? stripVerbatim(m[1]) : "";
+        if (receiver.length > 1 && !CS_REF_NOISE.has(receiver)) {
+          const col = m.index !== void 0 ? m.index + m[0].indexOf(receiver) : 0;
+          if (!isDeclaration(receiver, col)) {
+            const key = `${receiver}\0${lineNum}`;
+            if (!seenRefs.has(key)) {
+              seenRefs.add(key);
+              refs.push({ filePath, name: receiver, line: lineNum, col, context });
+            }
+          }
+        }
+      }
+      const nextCode = nextCodeLines(lines, i, 1)[0];
+      if (nextCode?.startsWith("(")) {
+        const mlMatch = CS_MULTILINE_INVOCATION_RE.exec(braceLine);
+        if (mlMatch) {
+          const callee = stripVerbatim(mlMatch[2] ?? "");
+          if (callee.length >= 1 && !CS_REF_NOISE.has(callee)) {
+            const dotIdx = mlMatch[0].indexOf(".");
+            const searchStart = dotIdx >= 0 ? mlMatch[0].lastIndexOf(".") + 1 : 0;
+            const calleeOffset = mlMatch[0].indexOf(callee, searchStart);
+            const col = mlMatch.index !== void 0 ? mlMatch.index + (calleeOffset >= 0 ? calleeOffset : 0) : 0;
+            if (!isDeclaration(callee, col)) {
+              const key = `${callee}\0${lineNum}`;
+              if (!seenRefs.has(key)) {
+                seenRefs.add(key);
+                refs.push({ filePath, name: callee, line: lineNum, col, context });
+              }
+            }
+          }
+          const receiver = mlMatch[1] !== void 0 ? stripVerbatim(mlMatch[1]) : "";
+          if (receiver.length > 1 && !CS_REF_NOISE.has(receiver)) {
+            const col = mlMatch.index !== void 0 ? mlMatch.index + mlMatch[0].indexOf(receiver) : 0;
+            if (!isDeclaration(receiver, col)) {
+              const key = `${receiver}\0${lineNum}`;
+              if (!seenRefs.has(key)) {
+                seenRefs.add(key);
+                refs.push({ filePath, name: receiver, line: lineNum, col, context });
+              }
+            }
           }
         }
       }
     }
-    const braceLine = stripStringLiterals(stripLineComment(line));
     const openBraces = (braceLine.match(/\{/g) ?? []).length;
     const closeBraces = (braceLine.match(/\}/g) ?? []).length;
     braceDepth += openBraces - closeBraces;
+    openMembers = endOpenMembers(symbols, settled, openMembers, braceDepth, lineNum, lines);
+    openMembers.push(...lineOpens);
+    if (currentMember !== void 0) {
+      if (!memberBodyEntered) {
+        if (openBraces > 0 && braceDepth > (frame?.startDepth ?? 0) + 1) {
+          memberBodyEntered = true;
+        } else if (stripped.endsWith(";")) {
+          currentMember = void 0;
+        }
+      } else if (frame === null || braceDepth <= frame.startDepth + 1) {
+        currentMember = void 0;
+        memberBodyEntered = false;
+      }
+    }
     const bracelessTop = classStack.length > 0 ? classStack[classStack.length - 1] : null;
     if (bracelessTop !== null && !bracelessTop.bodyEntered && braceDepth === bracelessTop.startDepth && (openBraces > 0 && openBraces === closeBraces || openBraces === 0 && closeBraces === 0 && stripped.endsWith(";"))) {
       classStack.pop();
@@ -293,7 +1333,7 @@ function extractCsharp(content, filePath) {
       }
     }
   }
-  return { symbols, imports };
+  return { symbols, refs, imports, settled };
 }
 
 // src/languages/php.ts
@@ -321,6 +1361,18 @@ var USE_RE = /^use\s+(?:function\s+|const\s+)?([\w\\]+)(?:\s+as\s+\w+)?\s*;/i;
 var GROUP_USE_RE = /^use\s+(?:function\s+|const\s+)?([\w\\]+)\\\{([^}]*)\}/i;
 var REQUIRE_RE = /^(?:require|include)(?:_once)?\s+['"]([^'"]+)['"]/i;
 var ENUM_CASE_RE = /^case\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:=|;)/i;
+function inlinePhpMember(text, kind, parent, filePath, lineNum) {
+  const enumCaseM = kind === "enum" && parent !== void 0 ? ENUM_CASE_RE.exec(text) : null;
+  if (enumCaseM) return makeLineSymbol(filePath, enumCaseM[1] ?? "", "const", lineNum, text, parent);
+  if (ANON_FN_RE.test(text)) return null;
+  const methM = METHOD_RE2.exec(text);
+  if (methM) return makeLineSymbol(filePath, methM[1] ?? "", parent === void 0 ? "function" : "method", lineNum, text, parent);
+  const propM = parent === void 0 ? null : PROP_RE.exec(text);
+  if (propM) return makeLineSymbol(filePath, propM[1] ?? "", "var", lineNum, text, parent);
+  const constM = CONST_RE.exec(text);
+  if (constM) return makeLineSymbol(filePath, constM[1] ?? "", "const", lineNum, text, parent);
+  return null;
+}
 function maskPhpInlineHtml(content) {
   const opener = /<\?(?:php\b|=)/i;
   if (!opener.test(content)) return content;
@@ -351,12 +1403,34 @@ function extractPhp(content, filePath) {
   const symbols = [];
   const imports = [];
   const lines = maskPhpInlineHtml(content).split(/\r?\n/);
+  const settled = /* @__PURE__ */ new Set();
+  let lineMembers = [];
+  let openMember = null;
+  let pendingBrace = null;
+  const queueMembers = (segs, line, kind, parent, lineNum, bodyDepth) => {
+    let open = null;
+    for (const seg of segs) {
+      const text = line.slice(seg.start, seg.end).trim();
+      const sym = inlinePhpMember(text, kind, parent, filePath, lineNum);
+      if (sym === null) continue;
+      lineMembers.push(sym);
+      settled.add(sym);
+      if (seg.open) open = { sym, depth: bodyDepth + 1 };
+      else if (seg === segs[segs.length - 1] && sym.kind !== "const" && sym.kind !== "var" && !/[;}]$/.test(text) && stripStringLiterals(text).split("(").length === stripStringLiterals(text).split(")").length) pendingBrace = { sym, depth: bodyDepth + 1 };
+    }
+    return open;
+  };
+  const flushMembers = () => {
+    symbols.push(...lineMembers);
+    lineMembers = [];
+  };
   const contextStack = [];
   let braceDepth = 0;
   let parenDepth = 0;
   let inComment = false;
   let mlState = null;
   for (let i = 0; i < lines.length; i++) {
+    flushMembers();
     const rawLine = lines[i] ?? "";
     const lineNum = i + 1;
     let mlLine = rawLine;
@@ -384,6 +1458,23 @@ function extractPhp(content, filePath) {
     if (topFrame !== void 0 && braceDepth > topFrame[1]) {
       topFrame[2] = true;
     }
+    if (pendingBrace !== null) {
+      if (stripped.startsWith("{")) openMember = pendingBrace;
+      pendingBrace = null;
+    }
+    if (openMember !== null && braceDepth < openMember.depth) {
+      endOpenMember(symbols, settled, openMember, lineNum, lines);
+      openMember = null;
+    }
+    const bodyBase = topFrame === void 0 ? 0 : topFrame[1] + 1;
+    const preDepth = braceDepth - openB + closeB;
+    if ((topFrame === void 0 || topFrame[2]) && preDepth >= bodyBase && preLineParenDepth === 0) {
+      const resume = bodyResumeAt(braceLine, preDepth - bodyBase);
+      if (resume >= 0 && (preDepth > bodyBase || topFrame !== void 0)) {
+        const segs = bodySegments(braceLine, resume);
+        openMember = queueMembers(preDepth === bodyBase ? segs.slice(1) : segs, line, topFrame?.[3] ?? "file", topFrame?.[0], lineNum, bodyBase) ?? openMember;
+      }
+    }
     while (contextStack.length > 0) {
       const top = contextStack[contextStack.length - 1];
       if (top !== void 0 && top[2] && braceDepth <= top[1]) {
@@ -430,6 +1521,8 @@ function extractPhp(content, filePath) {
       const parent = topFrame2 !== void 0 && preLineDepth === topFrame2[1] + 1 ? topFrame2[0] : null;
       symbols.push(makeLineSymbol(filePath, name, kind, lineNum, stripped.slice(0, 200), parent ?? void 0, lines, "c"));
       contextStack.push([name, braceDepth - openB + closeB, false, kind]);
+      const bodyOpen = braceLine.indexOf("{");
+      if (bodyOpen !== -1) openMember = queueMembers(bodySegments(braceLine, bodyOpen + 1), line, kind, name, lineNum, preLineDepth + 1) ?? openMember;
       if (openB > 0 && openB === closeB) {
         contextStack.pop();
       }
@@ -481,7 +1574,8 @@ function extractPhp(content, filePath) {
       symbols.push(makeLineSymbol(filePath, defineM[1] ?? "", "const", lineNum, stripped.slice(0, 200), void 0, lines, "c"));
     }
   }
-  return { symbols, imports };
+  flushMembers();
+  return { symbols, imports, settled };
 }
 
 // src/languages/html.ts
@@ -530,20 +1624,66 @@ function isNoise(name) {
 }
 var MAX_SYMBOLS = 1e4;
 var VOID_ELEMENTS = /* @__PURE__ */ new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
-var TAG_RE = /<(\/?)([a-zA-Z][a-zA-Z0-9:-]*)(?:\s(?:"[^"]*"|'[^']*'|[^'">])*)?>/g;
+function makeTagScanner(code) {
+  const head = /<(\/?)([a-zA-Z][a-zA-Z0-9:-]*)/g;
+  const stop = /[>"']/g;
+  let dead = null;
+  return (from) => {
+    head.lastIndex = from;
+    let m;
+    while ((m = head.exec(code)) !== null) {
+      const nameEnd = m.index + m[0].length;
+      let end = -1;
+      if (code[nameEnd] === ">") {
+        end = nameEnd + 1;
+      } else if (nameEnd < code.length && /\s/.test(code[nameEnd])) {
+        let i = nameEnd + 1;
+        const outside = [];
+        for (; ; ) {
+          if (dead !== null && dead[i] === 1) break;
+          stop.lastIndex = i;
+          const h = stop.exec(code);
+          if (h === null) {
+            outside.push(i, code.length + 1);
+            break;
+          }
+          if (h[0] === ">") {
+            end = h.index + 1;
+            break;
+          }
+          outside.push(i, h.index + 1);
+          const closeQuote = code.indexOf(h[0], h.index + 1);
+          if (closeQuote < 0) break;
+          i = closeQuote + 1;
+        }
+        if (end < 0 && outside.length > 0) {
+          dead ??= new Uint8Array(code.length + 2);
+          for (let k = 0; k < outside.length; k += 2) dead.fill(1, outside[k], outside[k + 1]);
+        }
+      }
+      if (end >= 0) {
+        return { start: m.index, end, isClose: m[1] === "/", name: (m[2] ?? "").toLowerCase(), selfClosing: code[end - 2] === "/" };
+      }
+      head.lastIndex = m.index + 1;
+    }
+    return null;
+  };
+}
 var ELEMENT_SPAN_SCAN_CAP = 2e6;
 function buildElementSpans(code) {
   const spans = /* @__PURE__ */ new Map();
   const openTagRanges = [];
   const stack = [];
-  TAG_RE.lastIndex = 0;
+  const nextTag = makeTagScanner(code);
+  const styleClose = /<\/style\s*>/gi;
+  let styleCloseMissing = false;
+  let from = 0;
   let m;
-  while ((m = TAG_RE.exec(code)) !== null) {
-    if (m.index > ELEMENT_SPAN_SCAN_CAP) break;
-    const isClose = m[1] === "/";
-    const name = (m[2] ?? "").toLowerCase();
-    const selfClosing = m[0][m[0].length - 2] === "/";
-    const tagEnd = m.index + m[0].length;
+  while ((m = nextTag(from)) !== null) {
+    if (m.start > ELEMENT_SPAN_SCAN_CAP) break;
+    const { isClose, name, selfClosing } = m;
+    const tagEnd = m.end;
+    from = tagEnd;
     if (isClose) {
       for (let i = stack.length - 1; i >= 0; i--) {
         if (stack[i].name === name) {
@@ -554,14 +1694,17 @@ function buildElementSpans(code) {
       }
       continue;
     }
-    openTagRanges.push({ start: m.index, end: tagEnd });
+    openTagRanges.push({ start: m.start, end: tagEnd });
     if (selfClosing || VOID_ELEMENTS.has(name)) continue;
     if (name === "style") {
-      const closeMatch = /<\/style\s*>/gi.exec(code.slice(tagEnd));
-      if (closeMatch !== null) TAG_RE.lastIndex = tagEnd + closeMatch.index + closeMatch[0].length;
+      if (styleCloseMissing) continue;
+      styleClose.lastIndex = tagEnd;
+      const closeMatch = styleClose.exec(code);
+      if (closeMatch === null) styleCloseMissing = true;
+      else from = closeMatch.index + closeMatch[0].length;
       continue;
     }
-    stack.push({ name, start: m.index });
+    stack.push({ name, start: m.start });
   }
   return { spans, openTagRanges };
 }
@@ -754,12 +1897,47 @@ var TYPEALIAS_RE = new RegExp(
 var TOP_FUN_RE = new RegExp(
   "^(?:(?:public|internal|private|suspend|inline|infix|operator|external|actual|expect|tailrec)\\s+)*fun\\s+(?:" + GENERIC_CLAUSE + "\\s*)?" + RECEIVER_RE + "(" + NAME_RE + ")\\s*[(<]"
 );
+function inlineKotlinMembers(line, code, segs, parent, filePath, lineNum, level = 0) {
+  const members = [];
+  const opens = [];
+  for (const seg of segs) {
+    const text = line.slice(seg.start, seg.end).trim();
+    const noAnn = stripLeadingAnnotations(text);
+    const fm = (parent === void 0 ? TOP_FUN_RE : FUN_RE).exec(noAnn);
+    const constM = fm === null ? CONST_RE2.exec(noAnn) : null;
+    const companionM = fm === null && constM === null && parent !== void 0 ? COMPANION_RE.exec(noAnn) : null;
+    const classM = fm === null && constM === null && companionM === null ? CLASS_HEADER_RE2.exec(noAnn) : null;
+    let sym = null;
+    if (fm) sym = makeLineSymbol(filePath, unquoteName(fm[1] ?? ""), parent === void 0 ? "function" : "method", lineNum, text, parent);
+    else if (constM) sym = makeLineSymbol(filePath, constM[1] ?? "", "const", lineNum, text, parent);
+    else if (companionM !== null || classM !== null) {
+      const brace = bodyBraceAt(code, seg.start, seg.end);
+      if (seg.open && brace === -1) continue;
+      const name = unquoteName((companionM !== null ? companionM[1] : classM?.[2]) ?? "Companion");
+      const keyword = companionM !== null ? "object" : classM?.[1] ?? "class";
+      const typeSym = makeLineSymbol(filePath, name, keyword === "interface" ? "interface" : keyword === "object" ? "object" : "class", lineNum, text, parent);
+      members.push(typeSym);
+      if (brace !== -1) {
+        const inner = inlineKotlinMembers(line, code, bodySegments(code, brace + 1), name, filePath, lineNum, level + 1);
+        members.push(...inner.members);
+        if (seg.open) opens.push({ sym: typeSym, level, isType: true }, ...inner.opens);
+      }
+      continue;
+    }
+    if (sym === null) continue;
+    members.push(sym);
+    if (seg.open) opens.push({ sym, level, isType: false });
+  }
+  return { members, opens };
+}
 function extractKotlin(content, filePath) {
   const symbols = [];
   const imports = [];
   const lines = content.split(/\r?\n/);
   const classStack = [];
   let braceDepth = 0;
+  const settled = /* @__PURE__ */ new Set();
+  let openMembers = [];
   let inComment = false;
   let mlState = null;
   for (let i = 0; i < lines.length; i++) {
@@ -850,6 +2028,23 @@ function extractKotlin(content, filePath) {
       }
     }
     const braceLine = stripStringLiterals(line);
+    const lineOpens = [];
+    const queueMembers = (segs, parent, bodyDepth) => {
+      const { members, opens } = inlineKotlinMembers(line, braceLine, segs, parent, filePath, lineNum);
+      symbols.push(...members);
+      for (const m of members) settled.add(m);
+      lineOpens.push(...openMembersOf(opens, bodyDepth));
+      for (const o of opens) if (o.isType) classStack.push({ name: o.sym.name, braceDepth: bodyDepth + o.level, bodyEntered: true, parenBalance: 0, pendingPop: false });
+    };
+    const lineSegs = bodySegments(braceLine, 0);
+    if (frame !== null && frame !== outerFrame && lineSegs[0] !== void 0) {
+      const brace = bodyBraceAt(braceLine, lineSegs[0].start, lineSegs[0].end);
+      if (brace !== -1) queueMembers(bodySegments(braceLine, brace + 1), frame.name, braceDepth + 1);
+    }
+    if (outerFrame !== null && outerDepthInClass >= 1) {
+      const resume = bodyResumeAt(braceLine, outerDepthInClass - 1);
+      if (resume >= 0) queueMembers(outerDepthInClass === 1 ? lineSegs.slice(1) : bodySegments(braceLine, resume), outerFrame.name, outerFrame.braceDepth + 1);
+    } else if (outerFrame === null && !isIndented) queueMembers(lineSegs.slice(1), void 0, braceDepth);
     for (const ch of braceLine) {
       if (ch === "{") {
         braceDepth++;
@@ -864,6 +2059,8 @@ function extractKotlin(content, filePath) {
         frame.parenBalance--;
       }
     }
+    openMembers = endOpenMembers(symbols, settled, openMembers, braceDepth, lineNum, lines);
+    openMembers.push(...lineOpens);
     if (frame !== null && !frame.bodyEntered && frame.parenBalance <= 0) {
       frame.pendingPop = !(stripped.endsWith(":") || stripped.endsWith(","));
     }
@@ -876,12 +2073,28 @@ function extractKotlin(content, filePath) {
       }
     }
   }
-  return { symbols, imports };
+  return { symbols, imports, settled };
 }
 
 // src/languages/scala.ts
 init_define_import_meta_env();
-var SCALA_STRIP = { symbolLiterals: true };
+var SCALA_STRIP = { symbolLiterals: true, interpolatorPrefix: true };
+var MEMBER_KINDS = /* @__PURE__ */ new Set(["function", "val", "var"]);
+function withSpanEnd(sym, endLine, lines) {
+  if (endLine <= sym.lineStart) return sym;
+  return { ...sym, lineEnd: endLine, body: lines.slice(sym.lineStart - 1, endLine).join("\n") };
+}
+function indentedBodyEnd(lines, startLine, declIndent) {
+  let end = startLine;
+  for (let j = startLine; j < lines.length; j++) {
+    const text = lines[j] ?? "";
+    const trimmed = text.trim();
+    if (trimmed === "" || trimmed.startsWith("//")) continue;
+    if (indentOf(text) <= declIndent) break;
+    end = j + 1;
+  }
+  return end;
+}
 function indentOf(line) {
   return line.length - line.trimStart().length;
 }
@@ -897,11 +2110,151 @@ var OBJECT_RE = new RegExp("^\\s*(?:package\\s+)?" + MODS + "object\\s+(" + NAME
 var TRAIT_RE = new RegExp("^\\s*" + MODS + "trait\\s+(" + NAME + ")(?:\\s|\\[|:|$)");
 var ENUM_RE = new RegExp("^\\s*(?:private|protected)?\\s*enum\\s+(" + NAME + ")(?:\\s|\\[|\\(|:|$)");
 var DEF_NAME = "(?:`[^`\\r\\n]+`|[A-Za-z_][A-Za-z0-9_]*_[+\\-*/%=!<>&|^~:]+|[+\\-*/%=!<>&|^~:]+|[A-Za-z_][A-Za-z0-9_]*)";
-var FUNC_RE = new RegExp("^\\s*" + MODS + "def\\s+(" + DEF_NAME + ")(?:\\s*\\[|\\s*\\(|\\s*:)");
+var FUNC_RE = new RegExp("^\\s*" + MODS + "def\\s+(" + DEF_NAME + ")(?:\\s*\\[|\\s*\\(|\\s*:|\\s*=(?!=))");
 var VAL_RE = new RegExp("^\\s*" + MODS + "val\\s+(" + NAME + ")");
 var VAR_RE = new RegExp("^\\s*" + MODS + "var\\s+(" + NAME + ")");
+var GIVEN_RE = /^\s*(?:(?:(?:private|protected)(?:\[[A-Za-z_][A-Za-z0-9_]*\])?|inline|transparent|override|final|implicit|lazy)\s+)*given\s+(?!=(?!>))(\S.*)$/;
+var SIMPLE_TYPE_HEAD_RE = /^(?:[A-Za-z_][A-Za-z0-9_]*\.)*([A-Za-z_][A-Za-z0-9_]*)\s*/;
+function splitTopLevel(text) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth--;
+    else if (ch === "," && depth === 0) {
+      parts.push(text.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+  parts.push(text.slice(start).trim());
+  return parts;
+}
+function anonymousGivenName(typeText) {
+  let text = typeText.trim();
+  while (text.startsWith("[") || text.startsWith("(")) {
+    let depth = 0;
+    let i = 0;
+    for (; i < text.length; i++) {
+      const ch = text[i];
+      if (ch === "(" || ch === "[") depth++;
+      else if (ch === ")" || ch === "]") depth--;
+      if (depth === 0) break;
+    }
+    const after = text.slice(i + 1).trimStart();
+    if (!after.startsWith("=>")) return "given";
+    text = after.slice(2).trim();
+  }
+  const head = SIMPLE_TYPE_HEAD_RE.exec(text);
+  if (!head) return "given";
+  const parts = [head[1]];
+  const tail = text.slice(head[0].length);
+  if (tail !== "") {
+    if (!tail.startsWith("[") || !tail.endsWith("]")) return "given";
+    for (const arg of splitTopLevel(tail.slice(1, -1))) {
+      const members = arg.startsWith("(") && arg.endsWith(")") ? splitTopLevel(arg.slice(1, -1)) : [arg];
+      for (const member of members) {
+        if (member.replace(/\[.*\]/g, "").includes("=>")) {
+          parts.push("Function");
+          continue;
+        }
+        const m = SIMPLE_TYPE_HEAD_RE.exec(member);
+        if (!m || !/^(?:\[.*\])?$/.test(member.slice(m[0].length))) return "given";
+        parts.push(m[1]);
+      }
+    }
+  }
+  return `given_${parts.join("_")}`;
+}
+function givenHead(stripped) {
+  const m = GIVEN_RE.exec(stripped);
+  if (!m) return null;
+  const rest = m[1];
+  const blanked = stripStringLiterals(rest, SCALA_STRIP);
+  let depth = 0;
+  let sigColon = -1;
+  let end = blanked.length;
+  let body = null;
+  for (let i = 0; i < blanked.length; i++) {
+    const ch = blanked[i];
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth--;
+    else if (depth !== 0) continue;
+    else if (ch === "{") {
+      end = i;
+      body = "brace";
+      break;
+    } else if (ch === "=" && blanked[i + 1] !== ">") {
+      end = i;
+      break;
+    } else if (ch === ":") {
+      if (blanked.slice(i + 1).trim() === "") {
+        end = i;
+        body = "colon";
+        break;
+      }
+      if (sigColon < 0) sigColon = i;
+    } else if (blanked.startsWith("with", i) && !/[A-Za-z0-9_]/.test(blanked[i - 1] ?? "") && !/[A-Za-z0-9_]/.test(blanked[i + 4] ?? "")) {
+      end = i;
+      body = blanked.slice(i + 4).trim().startsWith("{") ? "brace" : "colon";
+      break;
+    }
+  }
+  const sig = sigColon >= 0 ? rest.slice(0, sigColon).trim() : "";
+  const named = new RegExp("^(" + NAME + ")\\s*(?:[[(]|$)").exec(sig);
+  if (named) return { name: unquoteName2(named[1]), anonymous: false, body };
+  return { name: anonymousGivenName(sigColon >= 0 ? rest.slice(sigColon + 1, end) : rest.slice(0, end)), anonymous: true, body };
+}
 function startsDeclaration(stripped) {
-  return CLASS_RE3.test(stripped) || OBJECT_RE.test(stripped) || TRAIT_RE.test(stripped) || ENUM_RE.test(stripped) || FUNC_RE.test(stripped) || VAL_RE.test(stripped) || VAR_RE.test(stripped);
+  return CLASS_RE3.test(stripped) || OBJECT_RE.test(stripped) || TRAIT_RE.test(stripped) || ENUM_RE.test(stripped) || FUNC_RE.test(stripped) || VAL_RE.test(stripped) || VAR_RE.test(stripped) || GIVEN_RE.test(stripped) || extensionClauseTail(stripped) !== null;
+}
+function extensionClauseTail(stripped) {
+  if (!/^extension\s*[[(]/.test(stripped)) return null;
+  const blanked = stripStringLiterals(stripped, SCALA_STRIP);
+  let i = "extension".length;
+  let depth = 0;
+  for (; i < blanked.length; i++) {
+    const ch = blanked[i];
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth--;
+    else if (depth === 0 && ch !== " " && ch !== "	") break;
+  }
+  return depth === 0 ? stripped.slice(i).trim() : null;
+}
+var INLINE_TYPES = [[CLASS_RE3, "class"], [OBJECT_RE, "object"], [TRAIT_RE, "trait"], [ENUM_RE, "enum"]];
+function inlineScalaMembers(line, code, segs, parent, filePath, lineNum, level = 0) {
+  const members = [];
+  const opens = [];
+  for (const seg of segs) {
+    const text = line.slice(seg.start, seg.end).trim();
+    const fm = FUNC_RE.exec(text);
+    const vm = fm === null ? VAL_RE.exec(text) : null;
+    const varm = fm === null && vm === null ? VAR_RE.exec(text) : null;
+    const member = fm !== null ? [fm, "function"] : vm !== null ? [vm, "val"] : varm !== null ? [varm, "var"] : null;
+    if (member !== null) {
+      const sym = makeLineSymbol(filePath, unquoteName2(member[0][1] ?? ""), member[1], lineNum, text, parent);
+      members.push(sym);
+      if (seg.open) opens.push({ sym, level, isType: false });
+      continue;
+    }
+    for (const [re, kind] of INLINE_TYPES) {
+      const tm = re.exec(text);
+      if (tm === null) continue;
+      const brace = bodyBraceAt(code, seg.start, seg.end);
+      if (seg.open && brace === -1) break;
+      const name = unquoteName2(tm[1] ?? "");
+      const typeSym = makeLineSymbol(filePath, name, kind, lineNum, text, parent);
+      members.push(typeSym);
+      if (brace !== -1) {
+        const inner = inlineScalaMembers(line, code, bodySegments(code, brace + 1), name, filePath, lineNum, level + 1);
+        members.push(...inner.members);
+        if (seg.open) opens.push({ sym: typeSym, level, isType: true }, ...inner.opens);
+      }
+      break;
+    }
+  }
+  return { members, opens };
 }
 function extractScala(content, filePath) {
   const symbols = [];
@@ -909,8 +2262,16 @@ function extractScala(content, filePath) {
   const lines = content.split(/\r?\n/);
   const typeStack = [];
   let braceDepth = 0;
+  const settled = /* @__PURE__ */ new Set();
+  let openMembers = [];
   let inComment = false;
   let mlState = null;
+  let lastCodeLine = 0;
+  let extBlock = null;
+  const closeColonFrame = (frame, endLine) => {
+    const open = symbols[frame.symbolIndex];
+    if (open !== void 0) symbols[frame.symbolIndex] = withSpanEnd(open, endLine, lines);
+  };
   for (let i = 0; i < lines.length; i++) {
     const rawLine = lines[i] ?? "";
     const lineNum = i + 1;
@@ -920,7 +2281,7 @@ function extractScala(content, filePath) {
       mlLine = masked.code;
       mlState = masked.state;
     }
-    const { code: blockStripped, inComment: nextInComment } = stripBlockCommentSpan(mlLine, inComment);
+    const { code: blockStripped, inComment: nextInComment } = stripBlockCommentSpan(mlLine, inComment, SCALA_STRIP);
     inComment = nextInComment;
     const line = stripLineComment(blockStripped, ["//"], SCALA_STRIP).trimEnd();
     const stripped = line.trim();
@@ -933,9 +2294,13 @@ function extractScala(content, filePath) {
     const indent = indentOf(line);
     while (typeStack.length > 0) {
       const top = typeStack[typeStack.length - 1];
-      if (top.colonBody && indent <= top.declIndent) typeStack.pop();
-      else break;
+      if (!top.colonBody || indent > top.declIndent) break;
+      typeStack.pop();
+      const closesWithMarker = indent === top.declIndent && stripped === (top.endMarker ?? `end ${top.name}`);
+      closeColonFrame(top, closesWithMarker ? lineNum : lastCodeLine);
+      if (closesWithMarker) lastCodeLine = lineNum;
     }
+    lastCodeLine = lineNum;
     const colonTop = typeStack.length > 0 && typeStack[typeStack.length - 1].colonBody ? typeStack[typeStack.length - 1] : null;
     if (colonTop !== null && colonTop.bodyIndent === null) {
       colonTop.bodyIndent = indent;
@@ -974,7 +2339,7 @@ function extractScala(content, filePath) {
       const cname = unquoteName2(cm[1] ?? "");
       const parent = typeStack.length > 0 ? typeStack[typeStack.length - 1].name : void 0;
       symbols.push(makeLineSymbol(filePath, cname, "class", lineNum, stripped.slice(0, 200), parent, lines, "c"));
-      typeStack.push({ name: cname, startDepth: braceDepth, bodyEntered: false, openParens: 0, declIndent: indent, colonBody: opensColonBody, bodyIndent: null });
+      typeStack.push({ name: cname, startDepth: braceDepth, bodyEntered: false, openParens: 0, declIndent: indent, colonBody: opensColonBody, bodyIndent: null, symbolIndex: symbols.length - 1 });
       matched = true;
     }
     const om = !matched && typeDetectionGateOk && (!isIndented || typeStack.length > 0) ? OBJECT_RE.exec(stripped) : null;
@@ -982,7 +2347,7 @@ function extractScala(content, filePath) {
       const oname = unquoteName2(om[1] ?? "");
       const parent = typeStack.length > 0 ? typeStack[typeStack.length - 1].name : void 0;
       symbols.push(makeLineSymbol(filePath, oname, "object", lineNum, stripped.slice(0, 200), parent, lines, "c"));
-      typeStack.push({ name: oname, startDepth: braceDepth, bodyEntered: false, openParens: 0, declIndent: indent, colonBody: opensColonBody, bodyIndent: null });
+      typeStack.push({ name: oname, startDepth: braceDepth, bodyEntered: false, openParens: 0, declIndent: indent, colonBody: opensColonBody, bodyIndent: null, symbolIndex: symbols.length - 1 });
       matched = true;
     }
     const tm = !matched && typeDetectionGateOk && (!isIndented || typeStack.length > 0) ? TRAIT_RE.exec(stripped) : null;
@@ -990,7 +2355,7 @@ function extractScala(content, filePath) {
       const tname = unquoteName2(tm[1] ?? "");
       const parent = typeStack.length > 0 ? typeStack[typeStack.length - 1].name : void 0;
       symbols.push(makeLineSymbol(filePath, tname, "trait", lineNum, stripped.slice(0, 200), parent, lines, "c"));
-      typeStack.push({ name: tname, startDepth: braceDepth, bodyEntered: false, openParens: 0, declIndent: indent, colonBody: opensColonBody, bodyIndent: null });
+      typeStack.push({ name: tname, startDepth: braceDepth, bodyEntered: false, openParens: 0, declIndent: indent, colonBody: opensColonBody, bodyIndent: null, symbolIndex: symbols.length - 1 });
       matched = true;
     }
     const enm = !matched && typeDetectionGateOk && (!isIndented || typeStack.length > 0) ? ENUM_RE.exec(stripped) : null;
@@ -998,10 +2363,37 @@ function extractScala(content, filePath) {
       const enname = unquoteName2(enm[1] ?? "");
       const parent = typeStack.length > 0 ? typeStack[typeStack.length - 1].name : void 0;
       symbols.push(makeLineSymbol(filePath, enname, "enum", lineNum, stripped.slice(0, 200), parent, lines, "c"));
-      typeStack.push({ name: enname, startDepth: braceDepth, bodyEntered: false, openParens: 0, declIndent: indent, colonBody: opensColonBody, bodyIndent: null });
+      typeStack.push({ name: enname, startDepth: braceDepth, bodyEntered: false, openParens: 0, declIndent: indent, colonBody: opensColonBody, bodyIndent: null, symbolIndex: symbols.length - 1 });
+      matched = true;
+    }
+    const gm = !matched && typeDetectionGateOk && (!isIndented || typeStack.length > 0) ? givenHead(stripped) : null;
+    if (gm) {
+      const parent = typeStack.length > 0 ? typeStack[typeStack.length - 1].name : void 0;
+      symbols.push(makeLineSymbol(filePath, gm.name, gm.body === null ? "val" : "object", lineNum, stripped.slice(0, 200), parent, lines, "c"));
+      if (gm.body !== null) {
+        typeStack.push({ name: gm.name, startDepth: braceDepth, bodyEntered: false, openParens: 0, declIndent: indent, colonBody: gm.body === "colon", bodyIndent: null, symbolIndex: symbols.length - 1, ...gm.anonymous ? { endMarker: "end given" } : {} });
+      }
       matched = true;
     }
     const frame = typeStack.length > 0 ? typeStack[typeStack.length - 1] : null;
+    if (extBlock !== null && braceDepth <= extBlock.depth && indent <= extBlock.indent) extBlock = null;
+    if (!matched && extBlock !== null) {
+      if (extBlock.bodyIndent === null) {
+        extBlock.bodyIndent = indent;
+        extBlock.bodyDepth = braceDepth;
+      }
+      const fm = indent === extBlock.bodyIndent && braceDepth === extBlock.bodyDepth ? FUNC_RE.exec(stripped) : null;
+      if (fm) symbols.push(makeLineSymbol(filePath, unquoteName2(fm[1] ?? ""), "function", lineNum, stripped.slice(0, 200), extBlock.parent, lines, "c"));
+      matched = true;
+    }
+    const memberSlot = frame === null ? !isIndented : braceDepth - frame.startDepth === 1 || inColonBody && frame === colonTop;
+    const extTail = !matched && memberSlot ? extensionClauseTail(stripped) : null;
+    if (extTail !== null) {
+      const fm = FUNC_RE.exec(extTail);
+      if (fm) symbols.push(makeLineSymbol(filePath, unquoteName2(fm[1] ?? ""), "function", lineNum, stripped.slice(0, 200), frame?.name, lines, "c"));
+      else extBlock = { indent, depth: braceDepth, parent: frame?.name, bodyIndent: null, bodyDepth: braceDepth };
+      matched = true;
+    }
     if (!matched && frame !== null) {
       const depthInType = braceDepth - frame.startDepth;
       if (depthInType === 1 || inColonBody && frame === colonTop) {
@@ -1040,7 +2432,34 @@ function extractScala(content, filePath) {
         }
       }
     }
+    const lastSymbol = symbols[symbols.length - 1];
+    if (lastSymbol !== void 0 && lastSymbol.lineStart === lineNum && MEMBER_KINDS.has(lastSymbol.kind) && stripped.endsWith("=") && !stripped.includes("{")) {
+      symbols[symbols.length - 1] = withSpanEnd(lastSymbol, indentedBodyEnd(lines, lineNum, indent), lines);
+    }
     const braceLine = stripStringLiterals(line, SCALA_STRIP);
+    const lineOpens = [];
+    const queueMembers = (segs, parent, bodyDepth) => {
+      const { members, opens } = inlineScalaMembers(line, braceLine, segs, parent, filePath, lineNum);
+      symbols.push(...members);
+      for (const m of members) settled.add(m);
+      lineOpens.push(...openMembersOf(opens, bodyDepth));
+      for (const o of opens) {
+        if (!o.isType) continue;
+        const enclosing = typeStack[typeStack.length - 1];
+        if (enclosing !== void 0) enclosing.bodyEntered = true;
+        typeStack.push({ name: o.sym.name, startDepth: bodyDepth + o.level, bodyEntered: true, openParens: 0, declIndent: indent, colonBody: false, bodyIndent: null, symbolIndex: symbols.indexOf(o.sym) });
+      }
+    };
+    const lineSegs = bodySegments(braceLine, 0);
+    if (frame !== null && frame !== outerFrame && lineSegs[0] !== void 0) {
+      const brace = bodyBraceAt(braceLine, lineSegs[0].start, lineSegs[0].end);
+      if (brace !== -1) queueMembers(bodySegments(braceLine, brace + 1), frame.name, braceDepth + 1);
+    }
+    if (outerFrame !== null && (outerDepthInType === 1 || inColonBody && outerFrame === colonTop)) queueMembers(lineSegs.slice(1), outerFrame.name, braceDepth);
+    else if (outerFrame !== null && !outerFrame.colonBody && outerDepthInType > 1) {
+      const resume = bodyResumeAt(braceLine, outerDepthInType - 1);
+      if (resume >= 0) queueMembers(bodySegments(braceLine, resume), outerFrame.name, outerFrame.startDepth + 1);
+    } else if (outerFrame === null && !isIndented) queueMembers(lineSegs.slice(1), void 0, braceDepth);
     if (frame !== null && !frame.bodyEntered) {
       const parenDelta2 = (braceLine.match(/\(/g) ?? []).length - (braceLine.match(/\)/g) ?? []).length;
       frame.openParens = Math.max(0, frame.openParens + parenDelta2);
@@ -1055,6 +2474,8 @@ function extractScala(content, filePath) {
         braceDepth--;
       }
     }
+    openMembers = endOpenMembers(symbols, settled, openMembers, braceDepth, lineNum, lines);
+    openMembers.push(...lineOpens);
     while (typeStack.length > 0) {
       const top = typeStack[typeStack.length - 1];
       if (!top.colonBody && top.bodyEntered && braceDepth <= top.startDepth) {
@@ -1064,11 +2485,19 @@ function extractScala(content, filePath) {
       }
     }
   }
-  return { symbols, imports };
+  while (typeStack.length > 0) {
+    const top = typeStack.pop();
+    if (top.colonBody) closeColonFrame(top, lastCodeLine);
+  }
+  return { symbols, imports, settled };
 }
 
 // src/languages/lua.ts
 init_define_import_meta_env();
+function receiverName(fname) {
+  const parts = fname.split(/[.:]/);
+  return parts.length > 1 ? parts[parts.length - 2] : void 0;
+}
 function nearestFunctionName(stack) {
   for (let i = stack.length - 1; i >= 0; i--) {
     const frame = stack[i];
@@ -1160,7 +2589,7 @@ function extractLua(content, filePath) {
     if (fm) {
       const fname = fm[1] ?? "";
       const baseName = fname.split(/[.:]/).pop() ?? fname;
-      const parent = nearestFunctionName(funcStack);
+      const parent = receiverName(fname) ?? nearestFunctionName(funcStack);
       if (parent !== void 0) {
         symbols.push(makeLineSymbol(filePath, baseName, "function", lineNum, stripped.slice(0, 200), parent));
       } else {
@@ -1189,7 +2618,7 @@ function extractLua(content, filePath) {
     if (afm) {
       const fname = afm[1] ?? "";
       const baseName = fname.split(/[.:]/).pop() ?? fname;
-      const parent = nearestFunctionName(funcStack);
+      const parent = receiverName(fname) ?? nearestFunctionName(funcStack);
       if (parent !== void 0) {
         symbols.push(makeLineSymbol(filePath, baseName, "function", lineNum, stripped.slice(0, 200), parent));
       } else {
@@ -1249,7 +2678,7 @@ var DECLARE_RE = new RegExp(String.raw`^Declare\s+(?:(?:Ansi|Unicode|Auto|PtrSaf
 var VB6_PROPERTY_RE = new RegExp(String.raw`^Property\s+(?:Get|Let|Set)\s+(${ID})`, "i");
 var PROPERTY_RE2 = new RegExp(String.raw`^Property\s+(${ID})`, "i");
 var PROCEDURE_RE = new RegExp(String.raw`^(Sub|Function)\s+(${ID})`, "i");
-var OPERATOR_RE = /^Operator\s+([^\s(]+)\s*\(/i;
+var OPERATOR_RE2 = /^Operator\s+([^\s(]+)\s*\(/i;
 var EVENT_RE2 = new RegExp(String.raw`^Event\s+(${ID})`, "i");
 var CONST_RE3 = /^Const\s+(\S.*)$/i;
 var DIM_RE = /^Dim\s+(\S.*)$/i;
@@ -1578,7 +3007,7 @@ function extractVb(content, filePath) {
       else open(keyword, name, procedureKind(), stmt);
       continue;
     }
-    if ((m = OPERATOR_RE.exec(rest)) !== null) {
+    if ((m = OPERATOR_RE2.exec(rest)) !== null) {
       open("operator", m[1], "method", stmt);
       continue;
     }
@@ -1803,6 +3232,16 @@ function extractVhdl(content, filePath) {
 
 // src/languages/elixir.ts
 init_define_import_meta_env();
+function bracketDelta(line) {
+  const code = line.replace(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g, "");
+  return (code.match(/[([{]/g)?.length ?? 0) - (code.match(/[)\]}]/g)?.length ?? 0);
+}
+var DANGLING_RE = /(?:,|\bwhen|\band|\bor|\bin|&&|\|\||[+\-*/<>=!|&])\s*$/;
+var DO_KEYWORD_RE = /(?:^|[\s,)])do:/;
+var DO_KEYWORD_AT_EOL_RE = /(?:^|[\s,)])do:$/;
+function indentOf2(line) {
+  return line.length - line.trimStart().length;
+}
 function nearestDefName(stack) {
   for (let i = stack.length - 1; i >= 0; i--) {
     const frame = stack[i];
@@ -1822,6 +3261,30 @@ function extractElixir(content, filePath) {
   const lines = content.split(/\r?\n/);
   const moduleStack = [];
   let mlState = null;
+  let pending;
+  let keywordBody;
+  const extendDefSpan = (symbolIndex, lineEnd) => {
+    const open = symbols[symbolIndex];
+    if (open !== void 0 && lineEnd > open.lineStart) {
+      symbols[symbolIndex] = { ...open, lineEnd, body: lines.slice(open.lineStart - 1, lineEnd).join("\n") };
+    }
+  };
+  const trackKeywordBody = (symbolIndex, stripped) => {
+    const open = symbols[symbolIndex];
+    if (open !== void 0 && DO_KEYWORD_AT_EOL_RE.test(stripped)) {
+      keywordBody = { symbolIndex, headIndent: indentOf2(lines[open.lineStart - 1] ?? "") };
+    }
+  };
+  const settleDefHead = (name, stripped) => {
+    const symbolIndex = symbols.length - 1;
+    if (/\bdo\s*$/.test(stripped)) {
+      moduleStack.push({ name, endKeywordNeeded: true, isBlock: false, symbolIndex });
+    } else if (!DO_KEYWORD_RE.test(stripped)) {
+      pending = { name, symbolIndex, depth: bracketDelta(stripped), dangling: DANGLING_RE.test(stripped) };
+    } else {
+      trackKeywordBody(symbolIndex, stripped);
+    }
+  };
   for (let i = 0; i < lines.length; i++) {
     const rawLine = lines[i] ?? "";
     const lineNum = i + 1;
@@ -1829,9 +3292,37 @@ function extractElixir(content, filePath) {
     mlState = nextMlState;
     const line = stripLineComment(masked, ["#"]).trimEnd();
     const stripped = line.trim();
+    if (keywordBody !== void 0) {
+      if (rawLine.trim() === "") {
+        keywordBody = void 0;
+      } else if (stripped && indentOf2(masked) <= keywordBody.headIndent) {
+        keywordBody = void 0;
+      } else {
+        if (stripped) extendDefSpan(keywordBody.symbolIndex, lineNum);
+        continue;
+      }
+    }
     if (!stripped) {
       continue;
     }
+    if (pending !== void 0) {
+      const startsContinuation = /^(?:when\b|do\b|,|\|)/.test(stripped);
+      if (pending.depth <= 0 && !pending.dangling && !startsContinuation) {
+        pending = void 0;
+      } else {
+        pending.depth += bracketDelta(stripped);
+        pending.dangling = DANGLING_RE.test(stripped);
+        if (pending.depth <= 0 && /\bdo\s*$/.test(stripped)) {
+          moduleStack.push({ name: pending.name, endKeywordNeeded: true, isBlock: false, symbolIndex: pending.symbolIndex });
+          pending = void 0;
+        } else if (pending.depth <= 0 && DO_KEYWORD_RE.test(stripped)) {
+          extendDefSpan(pending.symbolIndex, lineNum);
+          trackKeywordBody(pending.symbolIndex, stripped);
+          pending = void 0;
+        }
+        continue;
+      }
+    }
     const opensDoBlock = /\bdo\s*$/.test(stripped);
     const opensFnBlock = /\bfn\b/.test(stripped) && !/\bend\b/.test(stripped) && /(?:fn|->)\s*$/.test(stripped);
     const modM = MODULE_RE.exec(stripped);
@@ -1868,9 +3359,7 @@ function extractElixir(content, filePath) {
       } else {
         symbols.push(makeLineSymbol(filePath, fname, "function", lineNum, stripped.slice(0, 200), void 0, lines, "hash"));
       }
-      if (opensDoBlock) {
-        moduleStack.push({ name: fname, endKeywordNeeded: true, isBlock: false, symbolIndex: symbols.length - 1 });
-      }
+      settleDefHead(fname, stripped);
       continue;
     }
     const pfm = PRIVATE_FUNC_RE.exec(stripped);
@@ -1882,9 +3371,7 @@ function extractElixir(content, filePath) {
       } else {
         symbols.push(makeLineSymbol(filePath, fname, "function", lineNum, stripped.slice(0, 200), void 0, lines, "hash"));
       }
-      if (opensDoBlock) {
-        moduleStack.push({ name: fname, endKeywordNeeded: true, isBlock: false, symbolIndex: symbols.length - 1 });
-      }
+      settleDefHead(fname, stripped);
       continue;
     }
     if (STRUCT_RE.test(stripped)) {
@@ -1915,12 +3402,14 @@ function extractElixir(content, filePath) {
 
 // src/languages/dart.ts
 init_define_import_meta_env();
+var DART_STRIP = { tripleQuotes: true, singleQuoteHoles: true };
 var CLASS_RE4 = /^(?:(?:abstract|base|interface|final|sealed|mixin)\s+)*class\s+([A-Za-z_][A-Za-z0-9_]*)/;
 var ENUM_RE2 = /^enum\s+([A-Za-z_][A-Za-z0-9_]*)/;
 var MIXIN_RE = /^(?:base\s+)?mixin\s+([A-Za-z_][A-Za-z0-9_]*)/;
 var EXTENSION_RE = new RegExp("^extension\\s+(?:([A-Za-z_][A-Za-z0-9_]*)\\s*(?:" + GENERIC_CLAUSE + ")?\\s+)?on\\s+");
 var EXTENSION_TYPE_RE = /^extension\s+type\s+([A-Za-z_][A-Za-z0-9_]*)/;
 var FUNC_RE5 = new RegExp("(?:^|\\s)(?:static\\s+)?(?:(?:void|Future|Stream|async|external)\\s+|[A-Za-z_][A-Za-z0-9_<>?]*(?:\\s*\\?)?\\s+)([A-Za-z_][A-Za-z0-9_]*)\\s*(?:" + GENERIC_CLAUSE + ")?\\s*\\(");
+var OPERATOR_RE3 = /(?:^|\s)(?:(?:external|abstract)\s+)*(?:[A-Za-z_][A-Za-z0-9_<>?,]*(?:\s*\?)?\s+)?operator\s*(\[\]=|\[\]|>>>|<<|>>|<=|>=|==|~\/|[-+*/%<>&|^~])\s*\(/;
 var GETTER_RE = /^(?:(?:static|external|abstract|covariant)\s+)*(?:[A-Za-z_][A-Za-z0-9_<>,?\s]*(?:\s*\?)?\s+)?get\s+([A-Za-z_][A-Za-z0-9_]*)/;
 var NAMED_CTOR_RE = /^(?:(?:const|factory|external)\s+)*([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)\s*\(/;
 var UNNAMED_CTOR_RE = /^(?:(?:const|factory|external)\s+)*([A-Za-z_][A-Za-z0-9_]*)\s*\(/;
@@ -1950,11 +3439,11 @@ function extractDart(content, filePath) {
     const line = stripLineComment(blockStripped).trimEnd();
     const stripped = line.trim();
     if (!stripped) {
-      const braceLine2 = stripStringLiterals(line, { tripleQuotes: true });
+      const braceLine2 = stripStringLiterals(line, DART_STRIP);
       braceDepth += (braceLine2.match(/\{/g) ?? []).length - (braceLine2.match(/\}/g) ?? []).length;
       continue;
     }
-    const structural = stripStringLiterals(stripped, { tripleQuotes: true });
+    const structural = stripStringLiterals(stripped, DART_STRIP);
     const isIndented = line[0] === " " || line[0] === "	";
     const outerFrame = typeStack.length > 0 ? typeStack[typeStack.length - 1] : null;
     const outerDepthInType = outerFrame !== null ? braceDepth - outerFrame.startDepth : 0;
@@ -2029,6 +3518,11 @@ function extractDart(content, filePath) {
         if (!member && FIELD_START_RE.test(stripped)) {
           member = true;
         }
+        const om = !member ? OPERATOR_RE3.exec(structural) : null;
+        if (om) {
+          symbols.push(makeLineSymbol(filePath, om[1] ?? "", "function", lineNum, stripped.slice(0, 200), frame.name, lines, "c"));
+          member = true;
+        }
         const gm = !member ? GETTER_RE.exec(stripped) : null;
         if (gm) {
           symbols.push(makeLineSymbol(filePath, gm[1] ?? "", "function", lineNum, stripped.slice(0, 200), frame.name, lines, "c"));
@@ -2053,7 +3547,7 @@ function extractDart(content, filePath) {
         symbols.push(makeLineSymbol(filePath, fname, "function", lineNum, stripped.slice(0, 200), void 0, lines, "c"));
       }
     }
-    const braceLine = stripStringLiterals(line, { tripleQuotes: true });
+    const braceLine = stripStringLiterals(line, DART_STRIP);
     for (const ch of braceLine) {
       if (ch === "{") {
         braceDepth++;
@@ -2470,7 +3964,7 @@ var DOMAIN_RE = makeCreateRe("DOMAIN");
 var AGGREGATE_RE = makeCreateRe("AGGREGATE", OR_REPLACE);
 var POLICY_RE = makeCreateRe("POLICY");
 var RULE_RE = makeCreateRe("RULE", OR_REPLACE);
-var OPERATOR_RE2 = makeCreateRe("OPERATOR(?!\\s+(?:CLASS|FAMILY)\\b)", OR_REPLACE);
+var OPERATOR_RE4 = makeCreateRe("OPERATOR(?!\\s+(?:CLASS|FAMILY)\\b)", OR_REPLACE);
 var SYNONYM_RE = makeCreateRe("SYNONYM", `${OR_REPLACE}(?:PUBLIC\\s+)?`);
 var DATABASE_LINK_RE = makeCreateRe("DATABASE\\s+LINK", "(?:PUBLIC\\s+)?");
 var CLUSTER_RE = makeCreateRe("CLUSTER");
@@ -2496,7 +3990,7 @@ var PATTERNS = [
   [AGGREGATE_RE, "sql_aggregate"],
   [POLICY_RE, "sql_policy"],
   [RULE_RE, "sql_rule"],
-  [OPERATOR_RE2, "sql_operator"],
+  [OPERATOR_RE4, "sql_operator"],
   [SYNONYM_RE, "sql_synonym"],
   [DATABASE_LINK_RE, "sql_database_link"],
   [CLUSTER_RE, "sql_cluster"],
@@ -2788,6 +4282,26 @@ function plsqlStructure(noStrings, lineIndex, units, createStarts, filePath, roo
   }
   return { ends, children };
 }
+var BODY_KINDS = /* @__PURE__ */ new Set([
+  "sql_function",
+  "sql_procedure",
+  "sql_trigger",
+  "sql_type",
+  "sql_type_body",
+  "sql_package",
+  "sql_package_body",
+  "sql_rule"
+]);
+var BODY_OPENER_RE = /\b(?:BEGIN|DECLARE)\b|\$\w*\$|\bRETURN\s+[\w$#.%]+(?:\s+[\w$#.%=]+|\s*\([^()]*\)){0,16}?\s+(?:IS|AS)\b(?!\s+(?:NOT|NULL|TRUE|FALSE|DISTINCT|UNKNOWN)\b)/i;
+var QUOTED_IDENTIFIER_RE = /"[^"]*"|`[^`]*`|\[[^\]]*\]/g;
+function isBodylessFunction(kind, header) {
+  return kind === "sql_function" && !BODY_OPENER_RE.test(header.replace(QUOTED_IDENTIFIER_RE, " "));
+}
+function trimBlankTail(lines, start, end) {
+  let e = end;
+  while (e > start && (lines[e - 1] ?? "").trim() === "") e--;
+  return e;
+}
 function extractSql(content, filePath) {
   const symbols = [];
   const sections = [];
@@ -2809,8 +4323,8 @@ function extractSql(content, filePath) {
           const line = offsetToLine(lineIndex, m.index ?? 0);
           createStarts.push(m.index ?? 0);
           const semiIdx = findStatementTerminator(noStrings, m.index ?? 0);
-          if (semiIdx !== -1 && offsetToLine(lineIndex, semiIdx) === line) {
-            singleLineEndLines.set(`${name}\0${kind}\0${line}`, line);
+          if (semiIdx !== -1 && (offsetToLine(lineIndex, semiIdx) === line || !BODY_KINDS.has(kind) || isBodylessFunction(kind, noStrings.slice(m.index ?? 0, semiIdx)))) {
+            singleLineEndLines.set(`${name}\0${kind}\0${line}`, offsetToLine(lineIndex, semiIdx));
           } else if (PLSQL_UNIT_KINDS.has(kind)) {
             units.push({ name, kind, index: m.index ?? 0, matchEnd: (m.index ?? 0) + m[0].length, line });
           }
@@ -2824,10 +4338,13 @@ function extractSql(content, filePath) {
   sections.sort((a, b) => a.line - b.line);
   symbols.sort((a, b) => a.lineStart - b.lineStart);
   assignFlatEndLines(sections, totalLines);
+  const noLines = noStrings.split("\n");
   const pinned = propagateEndLinesToSymbols(symbols, sections).map((sym) => {
     const key = `${sym.name}\0${sym.kind}\0${sym.lineStart}`;
-    const pinnedEndLine = singleLineEndLines.get(key) ?? plsql.ends.get(key);
-    return pinnedEndLine !== void 0 && pinnedEndLine !== sym.lineEnd ? { ...sym, lineEnd: pinnedEndLine } : sym;
+    const semiEnd = singleLineEndLines.get(key);
+    const pinnedEndLine = semiEnd !== void 0 ? Math.min(semiEnd, sym.lineEnd) : plsql.ends.get(key);
+    const end = pinnedEndLine ?? trimBlankTail(noLines, sym.lineStart, sym.lineEnd);
+    return end !== sym.lineEnd ? { ...sym, lineEnd: end } : sym;
   });
   if (plsql.children.length === 0) return pinned;
   return [...pinned, ...plsql.children].sort((a, b) => a.lineStart - b.lineStart);
@@ -3055,6 +4572,103 @@ var FUNC_NAME = "[A-Za-z_][A-Za-z0-9_.+:-]*";
 var FUNC_KEYWORD_RE = new RegExp(`^function\\s+(${FUNC_NAME})\\s*(?:\\(\\s*\\))?`);
 var FUNC_POSIX_RE = new RegExp(`^(${FUNC_NAME})\\s*\\(\\s*\\)`);
 var VAR_RE3 = /^(?:(?:export|declare|readonly)\s+(?:-\w+\s+)*)?([A-Za-z_]\w*)=/;
+var COMPOUND_OPENERS = /* @__PURE__ */ new Set(["if", "for", "while", "until", "select", "case"]);
+var COMPOUND_CLOSERS = /* @__PURE__ */ new Set(["fi", "done", "esac"]);
+var COMPOUND_PREFIX_WORDS = /* @__PURE__ */ new Set(["then", "do", "else", "!", "time"]);
+var COMPOUND_BODY_START_RE = /^(?:if|for|while|until|select|case)\b/;
+var COMPOUND_SEGMENT_SPLIT_RE = /;|&&|\|\||\||&|\(|\{|\)|\}/;
+function cleanForScan(line) {
+  return stripStringLiterals(stripBashComment(line)).trim();
+}
+function compoundDelta(text) {
+  let delta = 0;
+  for (const segment of text.split(COMPOUND_SEGMENT_SPLIT_RE)) {
+    const words = segment.trim().split(/\s+/);
+    let w = 0;
+    while (w < words.length && COMPOUND_PREFIX_WORDS.has(words[w] ?? "")) w++;
+    const first = words[w] ?? "";
+    if (COMPOUND_OPENERS.has(first)) delta++;
+    else if (COMPOUND_CLOSERS.has(first)) delta--;
+  }
+  return delta;
+}
+var SUBSHELL_TOKEN_RE = /;;&|;;|;&|\|\||&&|[()]|[;&|]|[^\s()&;|]+/g;
+var CASE_ARM_ENDS = /* @__PURE__ */ new Set([";;", ";&", ";;&"]);
+var COMMAND_POSITION_WORDS = /* @__PURE__ */ new Set(["then", "do", "else", "elif", "!", "time", "{"]);
+var SubshellParenScanner = class {
+  depth = 0;
+  // One entry per open `case`: 'subject' until `in`, 'pattern' while reading an arm's pattern, 'body' inside an arm.
+  cases = [];
+  commandPosition = true;
+  // Feeds one cleaned line; true once the body's opening `(` has been closed.
+  closes(text) {
+    for (const tok of text.match(SUBSHELL_TOKEN_RE) ?? []) {
+      const top = this.cases.length - 1;
+      const state = this.cases[top];
+      if (state === "subject") {
+        if (tok === "in") this.cases[top] = "pattern";
+        continue;
+      }
+      if (state === "pattern") {
+        if (tok === "esac") {
+          this.cases.pop();
+          this.commandPosition = false;
+        } else if (tok === ")") {
+          this.cases[top] = "body";
+          this.commandPosition = true;
+        }
+        continue;
+      }
+      if (state === "body" && CASE_ARM_ENDS.has(tok)) {
+        this.cases[top] = "pattern";
+        continue;
+      }
+      if (tok === "(") {
+        this.depth++;
+        this.commandPosition = true;
+        continue;
+      }
+      if (tok === ")") {
+        this.depth--;
+        if (this.depth <= 0) return true;
+        this.commandPosition = false;
+        continue;
+      }
+      if (this.commandPosition && tok === "case") this.cases.push("subject");
+      else if (this.commandPosition && tok === "esac" && state === "body") this.cases.pop();
+      this.commandPosition = /^[;&|]/.test(tok) || COMMAND_POSITION_WORDS.has(tok);
+    }
+    this.commandPosition = true;
+    return false;
+  }
+};
+function findCompoundBodyEnd(lines, headerIdx, rest) {
+  let startIdx = headerIdx;
+  let text = rest;
+  if (text === "") {
+    let j = headerIdx + 1;
+    while (j < lines.length && cleanForScan(lines[j] ?? "") === "") j++;
+    if (j >= lines.length) return null;
+    startIdx = j;
+    text = cleanForScan(lines[j] ?? "");
+  }
+  const kind = text.startsWith("(") ? "paren" : text.startsWith("[[") ? "test" : COMPOUND_BODY_START_RE.test(text) ? "keyword" : null;
+  if (kind === null) return null;
+  let depth = 0;
+  const parens = kind === "paren" ? new SubshellParenScanner() : null;
+  for (let k = startIdx; k < lines.length; k++) {
+    const cur = k === startIdx ? text : cleanForScan(lines[k] ?? "");
+    if (parens !== null) {
+      if (parens.closes(cur)) return k + 1;
+    } else if (kind === "test") {
+      if (cur.includes("]]")) return k + 1;
+    } else {
+      depth += compoundDelta(cur);
+      if (depth <= 0) return k + 1;
+    }
+  }
+  return null;
+}
 function stripBashComment(line) {
   for (let i = 0; i < line.length; i++) {
     if (line[i] !== "#") continue;
@@ -3113,6 +4727,7 @@ function extractBash(content, filePath) {
   let awaitingFunctionBrace = false;
   let openFunctionIndex = null;
   let openHeadingIndex = null;
+  let skipUntil = 0;
   for (let i = 0; i < lines.length; i++) {
     const rawLine = lines[i] ?? "";
     const lineNum = i + 1;
@@ -3120,7 +4735,7 @@ function extractBash(content, filePath) {
       if (rawLine.trim() === heredocs[0]) heredocs.shift();
       continue;
     }
-    if (!inFunction && braceDepth === 0) {
+    if (!inFunction && braceDepth === 0 && lineNum > skipUntil) {
       const banner = extractShellBannerHeading(rawLine);
       if (banner !== null) {
         if (openHeadingIndex !== null) {
@@ -3155,6 +4770,7 @@ function extractBash(content, filePath) {
     const opened = findHeredocOpeners(noComment, arithmeticDepth);
     arithmeticDepth = opened.depth;
     heredocs.push(...opened.terminators);
+    if (lineNum <= skipUntil) continue;
     if (!stripped) continue;
     if (!inFunction && !awaitingFunctionBrace && braceDepth === 0) {
       const kwMatch = FUNC_KEYWORD_RE.exec(stripped);
@@ -3178,7 +4794,18 @@ function extractBash(content, filePath) {
           pushedIndex = symbols.length;
           symbols.push(makeLineSymbol(filePath, fname, "function", lineNum, stripped.slice(0, 200), void 0, lines, "hash"));
         }
-        if (fname) {
+        const rest = stripped.slice(funcMatch[0].length).trim();
+        const compoundEnd = fname && !rest.startsWith("{") ? findCompoundBodyEnd(lines, i, rest) : null;
+        if (compoundEnd !== null) {
+          if (pushedIndex !== null) {
+            const open = symbols[pushedIndex];
+            if (open !== void 0 && compoundEnd > lineNum) {
+              symbols[pushedIndex] = { ...open, lineEnd: compoundEnd, body: lines.slice(lineNum - 1, compoundEnd).join("\n") };
+            }
+          }
+          skipUntil = compoundEnd;
+          continue;
+        } else if (fname) {
           if (stripped.includes("{")) {
             const braceLine2 = stripStringLiterals(stripped);
             const openCount = (braceLine2.match(/\{/g) ?? []).length;
@@ -3292,7 +4919,7 @@ function maskContinuationAndDefines(text) {
   }
   return { noContinuation: contLines.join("\n"), forTargets: targetLines.join("\n") };
 }
-var TARGET_RE = /^((?:[^\t\n#:=]|:(?=[\\/])|\\#)(?:[^:\n#=]|:(?=[\\/])|\\#)*):{1,2}(?![:=])\s*(?:[^=\n]|$)/gm;
+var TARGET_RE = /^((?:[^\t\n#:=]|:(?=[\\/])|\\#)(?:[^:\n#=]|:(?=[\\/])|\\#)*):{1,2}(?![:=])(?![ \t]*(?:(?:override|export|private)[ \t]+)*[^\s:=#]+[ \t]*(?:[?+!]|:{0,3})=)\s*(?:[^=\n]|$)/gm;
 var DEFINE_RE2 = /^ *(?:(?:override|export|private)\s+)*define\s+([\w./%$()-]+)/gm;
 var SPECIAL_TARGETS = /* @__PURE__ */ new Set([
   ".PHONY",
@@ -4028,12 +5655,12 @@ function extractApex(content, filePath) {
   }
   const typeNamesLower = /* @__PURE__ */ new Set();
   for (const match of code.matchAll(TYPE_DECL_RE)) {
-    const typeKind = match[1] ?? "";
+    const typeKind2 = match[1] ?? "";
     const name = match[2] ?? "";
     const startOffset = match.index ?? 0;
     const line = offsetToLine(lineIndex, startOffset);
     const bodyStartLine = annotationStartLine(codeLines, line);
-    const typeKindLower = typeKind.toLowerCase();
+    const typeKindLower = typeKind2.toLowerCase();
     const kind = typeKindLower === "class" ? "apex_class" : `apex_${typeKindLower}`;
     typeNamesLower.add(name.toLowerCase());
     emit2(name, kind, spanForMatch(content, code, lineIndex, startOffset, bodyStartLine, match[0]));
@@ -4090,36 +5717,52 @@ var FLOW_TAG_KIND = {
   variables: "sf_flow_variable"
 };
 function xmlText(content, tag) {
-  const re = new RegExp(
-    `<(?:[A-Za-z_][\\w.-]*:)?${tag}(?:\\s[^>]*)?>([\\s\\S]*?)</(?:[A-Za-z_][\\w.-]*:)?${tag}\\s*>`,
-    "i"
-  );
-  const match = re.exec(content);
-  if (match?.[1] === void 0) return null;
-  return decodeXml(match[1].trim());
+  const first = findElements(content, tagOpenRe(tag, "gi"), tagCloseRe(tag, "gi"), 1)[0];
+  if (first === void 0) return null;
+  return decodeXml(first.body.trim());
+}
+function tagOpenRe(tag, flags) {
+  return new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?${tag}(?=[\\s>])`, flags);
+}
+function tagCloseRe(tag, flags) {
+  return new RegExp(`</(?:[A-Za-z_][\\w.-]*:)?${tag}\\s*>`, flags);
 }
 function directChildText(content, tag) {
-  const candidateRe = new RegExp(
-    `<(?:[A-Za-z_][\\w.-]*:)?${tag}(?:\\s[^>]*)?>([\\s\\S]*?)</(?:[A-Za-z_][\\w.-]*:)?${tag}\\s*>`,
-    "gi"
-  );
-  const tagRe = /<(\/?)([A-Za-z_:][\w.:-]*)\b[^>]*?(\/?)>/g;
-  for (const cand of content.matchAll(candidateRe)) {
-    const idx = cand.index ?? 0;
-    let depth = 0;
-    tagRe.lastIndex = 0;
-    let t;
-    while ((t = tagRe.exec(content)) !== null) {
-      if (t.index >= idx) break;
-      const closing = t[1] === "/";
-      const selfClosing = t[3] === "/";
-      if (selfClosing) continue;
-      depth += closing ? -1 : 1;
-    }
-    if (depth === 0) return decodeXml((cand[1] ?? "").trim());
+  const nextCandidate = elementCursor(content, tagOpenRe(tag, "gi"), tagCloseRe(tag, "gi"));
+  let depthBefore = null;
+  let cand;
+  while ((cand = nextCandidate()) !== null) {
+    depthBefore ??= depthCursor(content);
+    if (depthBefore(cand.start) === 0) return decodeXml(cand.body.trim());
   }
   return null;
 }
+function depthCursor(content) {
+  const re = /<(\/?)([A-Za-z_:][\w.:-]*)\b/g;
+  let depth = 0;
+  let heldStart = -1;
+  let heldDelta = 0;
+  let done = false;
+  return (pos) => {
+    for (; ; ) {
+      if (heldStart < 0) {
+        const m = done ? null : re.exec(content);
+        const gt = m === null ? -1 : content.indexOf(">", m.index + m[0].length);
+        if (m === null || gt < 0) {
+          done = true;
+          return depth;
+        }
+        const nameEnd = m.index + m[0].length;
+        heldStart = m.index;
+        heldDelta = content[gt - 1] === "/" && gt - 1 >= nameEnd ? 0 : m[1] === "/" ? -1 : 1;
+        re.lastIndex = gt + 1;
+      }
+      if (heldStart >= pos) return depth;
+      depth += heldDelta;
+      heldStart = -1;
+    }
+  };
+}
 function decodeXml(value) {
   return value.replace(/&apos;/g, "'").replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
 }
@@ -4139,8 +5782,7 @@ function wholeFileSpan(content) {
   return {
     startLine: 1,
     endLine: lines.length > 1 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length,
-    // File-level metadata symbols can be several megabytes (profiles are a common case).
-    // Keep only the source span in the index; `read` reconstructs empty bodies from disk.
+    // File-level metadata symbols can be several megabytes (profiles are a common case). Keep only the source span in the index; `read` reconstructs empty bodies from disk.
     body: ""
   };
 }
@@ -4154,11 +5796,13 @@ function spanFromOffsets(content, lineIndex, startOffset, endOffset) {
   };
 }
 function rootElement(content) {
-  const match = /<(?!\?|!)(?:[A-Za-z_][\w.-]*:)?([A-Za-z_][\w.-]*)\b[^>]*>/.exec(content);
+  const match = /<(?!\?|!)(?:[A-Za-z_][\w.-]*:)?([A-Za-z_][\w.-]*)\b/.exec(content);
   if (match === null) return null;
   const root = match[1];
   if (root === void 0) return null;
-  if (match[0].endsWith("/>")) return root;
+  const gt = content.indexOf(">", match.index + match[0].length);
+  if (gt < 0) return null;
+  if (content[gt - 1] === "/") return root;
   const close = new RegExp(`</(?:[A-Za-z_][\\w.-]*:)?${escapeRegExp(root)}\\s*>`, "i");
   return close.test(content) ? root : null;
 }
@@ -4176,14 +5820,10 @@ function metadataArtifactName(filePath) {
   return match?.[1] ?? basenameWithout(filePath, "-meta.xml");
 }
 function elementBlocks(content, tag) {
-  const re = new RegExp(
-    `<(?:[A-Za-z_][\\w.-]*:)?${tag}(?:\\s[^>]*)?>([\\s\\S]*?)</(?:[A-Za-z_][\\w.-]*:)?${tag}\\s*>`,
-    "gi"
-  );
-  return [...content.matchAll(re)].map((match) => ({
-    inner: match[1] ?? "",
-    offset: match.index ?? 0,
-    text: match[0]
+  return findElements(content, tagOpenRe(tag, "gi"), tagCloseRe(tag, "gi")).map((el) => ({
+    inner: el.body,
+    offset: el.start,
+    text: content.slice(el.start, el.end)
   }));
 }
 function attributeValue(attributes, name) {
@@ -4191,11 +5831,33 @@ function attributeValue(attributes, name) {
   return match?.[2] === void 0 ? null : decodeXml(match[2]);
 }
 function propertyElements(content) {
-  const re = /<(?:[A-Za-z_][\w.-]*:)?property\b([^>]*?)(?:\/>|>([\s\S]*?)<\/(?:[A-Za-z_][\w.-]*:)?property\s*>)/gi;
+  const open = /<(?:[A-Za-z_][\w.-]*:)?property\b/gi;
+  const close = /<\/(?:[A-Za-z_][\w.-]*:)?property\s*>/gi;
+  const nextGt = gtFinder(content);
   const out = [];
-  for (const match of content.matchAll(re)) {
-    const name = attributeValue(match[1] ?? "", "name");
-    if (name !== null && name !== "") out.push({ name, offset: match.index ?? 0, text: match[0] });
+  let deadFrom = Infinity;
+  let m;
+  while ((m = open.exec(content)) !== null) {
+    const nameEnd = m.index + m[0].length;
+    const gt = nextGt(nameEnd);
+    if (gt < 0) break;
+    let end = gt + 1;
+    let attrs = content.slice(nameEnd, gt);
+    if (content[gt - 1] === "/" && gt - 1 >= nameEnd) {
+      attrs = content.slice(nameEnd, gt - 1);
+    } else {
+      if (gt >= deadFrom) continue;
+      close.lastIndex = gt + 1;
+      const c = close.exec(content);
+      if (c === null) {
+        deadFrom = gt;
+        continue;
+      }
+      end = c.index + c[0].length;
+    }
+    const name = attributeValue(attrs, "name");
+    if (name !== null && name !== "") out.push({ name, offset: m.index, text: content.slice(m.index, end) });
+    open.lastIndex = end;
   }
   return out;
 }
@@ -4227,15 +5889,35 @@ function metadataName(filePath, content, suffix) {
 function addFlowElements(symbols, seen, content, filePath, flowName) {
   const lineIndex = buildLineIndex(content);
   const tagAlternation = Object.keys(FLOW_TAG_KIND).join("|");
-  const re = new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?(${tagAlternation})(?:\\s[^>]*)?>\\s*([\\s\\S]*?)\\s*</(?:[A-Za-z_][\\w.-]*:)?\\1\\s*>`, "g");
-  for (const match of content.matchAll(re)) {
+  const open = new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?(${tagAlternation})(?=[\\s>])`, "g");
+  const closeByTag = /* @__PURE__ */ new Map();
+  const deadFromByTag = /* @__PURE__ */ new Map();
+  const nextGt = gtFinder(content);
+  let m;
+  while ((m = open.exec(content)) !== null) {
     if (symbols.length >= MAX_SYMBOLS11) return;
-    const tag = match[1] ?? "";
-    const inner = match[2] ?? "";
+    const tag = m[1] ?? "";
+    const nameEnd = m.index + m[0].length;
+    const gt = nextGt(nameEnd);
+    if (gt < 0) break;
+    if (gt >= (deadFromByTag.get(tag) ?? Infinity)) continue;
+    let close = closeByTag.get(tag);
+    if (close === void 0) {
+      close = tagCloseRe(tag, "g");
+      closeByTag.set(tag, close);
+    }
+    close.lastIndex = gt + 1;
+    const c = close.exec(content);
+    if (c === null) {
+      deadFromByTag.set(tag, gt);
+      continue;
+    }
+    const startOffset = m.index;
+    const endOffset = c.index + c[0].length;
+    open.lastIndex = endOffset;
+    const inner = content.slice(gt + 1, c.index).trim();
     const name = directChildText(inner, "name");
     if (name === null || name === "") continue;
-    const startOffset = match.index ?? 0;
-    const endOffset = startOffset + match[0].length;
     const span = spanFromOffsets(content, lineIndex, startOffset, endOffset);
     const kind = FLOW_TAG_KIND[tag] ?? "sf_flow_element";
     emit(symbols, seen, makeSpanSymbol(filePath, name, kind, span, flowName));
@@ -4446,11 +6128,33 @@ function blankJsStringLiterals(content) {
 }
 var FUNC_DECL_RE = /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s+([A-Za-z_$][\w$]*)/;
 var CONST_DECL_RE = /^(?:export\s+)?const\s+([A-Za-z_$][\w$]*)\s*[:=]/;
-var CLASS_DECL_RE = /^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/;
+var CLASS_DECL_RE = /^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(?!extends\b)([A-Za-z_$][\w$]*)/;
+var ANONYMOUS_DEFAULT_RE = /^export\s+default\s+(?:async\s+)?(?:function\b|(class)\b|(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>)/;
+var DEFAULT_VALUE_RE = /^export\s+default\s+(?:\{|[A-Za-z_$][\w$.]*\s*\()/;
+function declarationEndIdx(blanked, startIdx) {
+  let depth = 0;
+  for (let j = startIdx; j < blanked.length; j++) {
+    const line = blanked[j] ?? "";
+    for (const ch of line) {
+      if (ch === "(" || ch === "[" || ch === "{") depth++;
+      else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    }
+    if (depth > 0) continue;
+    let k = j + 1;
+    while (k < blanked.length && (blanked[k] ?? "").trim() === "") k++;
+    if (j === startIdx && (blanked[k] ?? "").trimStart().startsWith("{")) {
+      j = k - 1;
+      continue;
+    }
+    return j;
+  }
+  return startIdx;
+}
 function extractTopLevelDeclarations(scriptContent, filePath, startLine) {
   const symbols = [];
   const commentFree = stripJsComments(scriptContent);
   const lines = blankJsStringLiterals(commentFree).split("\n");
+  const rawLines = scriptContent.split("\n");
   let depth = 0;
   for (let i = 0; i < lines.length; i++) {
     const rawLine = lines[i] ?? "";
@@ -4458,16 +6162,16 @@ function extractTopLevelDeclarations(scriptContent, filePath, startLine) {
     if (depth === 0 && trimmed) {
       const line = startLine + i;
       const fm = FUNC_DECL_RE.exec(trimmed);
-      if (fm?.[1]) {
-        symbols.push(makeLineSymbol(filePath, fm[1], "sfc_script_function", line));
-      } else {
-        const cm = CONST_DECL_RE.exec(trimmed);
-        if (cm?.[1]) {
-          symbols.push(makeLineSymbol(filePath, cm[1], "sfc_script_const", line));
-        } else {
-          const clm = CLASS_DECL_RE.exec(trimmed);
-          if (clm?.[1]) symbols.push(makeLineSymbol(filePath, clm[1], "sfc_script_class", line));
-        }
+      const cm = fm ? null : CONST_DECL_RE.exec(trimmed);
+      const clm = fm || cm ? null : CLASS_DECL_RE.exec(trimmed);
+      const am = fm || cm || clm ? null : ANONYMOUS_DEFAULT_RE.exec(trimmed);
+      const dm = fm || cm || clm || am ? null : DEFAULT_VALUE_RE.exec(trimmed);
+      const name = fm?.[1] ?? cm?.[1] ?? clm?.[1] ?? (am || dm ? "default" : void 0);
+      if (name) {
+        const kind = fm || am && am[1] === void 0 ? "sfc_script_function" : cm || dm ? "sfc_script_const" : "sfc_script_class";
+        const sym = makeLineSymbol(filePath, name, kind, line);
+        const endIdx = declarationEndIdx(lines, i);
+        symbols.push(endIdx > i ? { ...sym, lineEnd: startLine + endIdx, body: rawLines.slice(i, endIdx + 1).join("\n") } : sym);
       }
     }
     depth += (rawLine.match(/\{/g) ?? []).length - (rawLine.match(/\}/g) ?? []).length;
@@ -4495,19 +6199,14 @@ function extractComponentRefs(markup, filePath, startLine, allowKebab) {
 }
 function extractTagBlocks(content, lineIndex, tag) {
   const masked = blankJsStringLiterals(content);
-  const re = new RegExp(`<${tag}\\b([^>]*)>([\\s\\S]*?)<\\/${tag}\\s*>`, "gi");
   const blocks = [];
-  for (const m of masked.matchAll(re)) {
-    const matchStart = m.index ?? 0;
-    const attrs = m[1] ?? "";
-    const innerLen = (m[2] ?? "").length;
-    const openTagLen = 1 + tag.length + attrs.length + 1;
-    const innerStart = matchStart + openTagLen;
+  for (const el of findElements(masked, new RegExp(`<${tag}\\b`, "gi"), new RegExp(`<\\/${tag}\\s*>`, "gi"))) {
+    const innerStart = el.bodyEnd - el.body.length;
     blocks.push({
-      content: content.slice(innerStart, innerStart + innerLen),
+      content: content.slice(innerStart, el.bodyEnd),
       contentStartLine: offsetToLine(lineIndex, innerStart),
-      matchStart,
-      matchEnd: matchStart + m[0].length
+      matchStart: el.start,
+      matchEnd: el.end
     });
   }
   return blocks;
@@ -5401,6 +7100,16 @@ function readToken4(masked, i) {
   if (p === start) return void 0;
   return { word: masked.slice(start, p), start, end: p };
 }
+function readNameToken(masked, i) {
+  let p = i;
+  for (; ; ) {
+    while (isSpace4(masked[p])) p++;
+    if (masked[p] === "#" && masked[p + 1] === "^") p++;
+    if (masked[p] !== "^") break;
+    p = datumEnd2(masked, p + 1);
+  }
+  return readToken4(masked, p);
+}
 function extractClojure(content, filePath) {
   if (content.includes("\0")) return { symbols: [], imports: [] };
   const rawLines = content.split(/\r?\n/);
@@ -5421,7 +7130,7 @@ function extractClojure(content, filePath) {
       if (tok !== void 0) {
         const kind = DEFINERS4.get(tok.word.toLowerCase());
         if (kind !== void 0) {
-          const nameTok = readToken4(masked, tok.end);
+          const nameTok = readNameToken(masked, tok.end);
           const name = nameTok?.word.replace(/^:+/, "") ?? "";
           const idx = spans.open(name, kind, lineOf(i), owner());
           stack.push({ index: idx, depth });
@@ -5728,7 +7437,7 @@ function afterContext(rest) {
   const arrow = rest.indexOf("=>");
   return (arrow >= 0 ? rest.slice(arrow + 2) : rest).trimStart();
 }
-function classify(line) {
+function classify(line, continued = false) {
   let m;
   if (m = /^module\s+([A-Za-z_][A-Za-z0-9_.']*)/.exec(line)) return [{ kind: "module", name: m[1] }];
   if (m = /^(?:data|newtype)\s+(?:instance\s+)?([A-Z][A-Za-z0-9_']*)/.exec(line)) return [{ kind: "type", name: m[1] }];
@@ -5748,11 +7457,11 @@ function classify(line) {
   if (m = /^\(([^()]+)\)\s*::/.exec(line)) return [{ kind: "function", name: m[1].trim() }];
   if (m = /^([a-z_][A-Za-z0-9_']*)\b/.exec(line)) {
     const name = m[1];
-    if (!RESERVED_TOP.has(name) && hasTopLevelEquals(line)) return [{ kind: "function", name }];
+    if (!RESERVED_TOP.has(name) && (continued || hasTopLevelEquals(line))) return [{ kind: "function", name }];
     return void 0;
   }
   if (m = /^\(([^()]+)\)/.exec(line)) {
-    if (hasTopLevelEquals(line)) return [{ kind: "function", name: m[1].trim() }];
+    if (continued || hasTopLevelEquals(line)) return [{ kind: "function", name: m[1].trim() }];
   }
   return void 0;
 }
@@ -5761,7 +7470,15 @@ function extractHaskell(content, filePath) {
   const rawLines = content.split(/\r?\n/);
   const masked = maskHaskell(content);
   const maskedLines = masked.split(/\r?\n/);
-  const n = rawLines.length;
+  const n = rawLines.length > 1 && rawLines[rawLines.length - 1] === "" ? rawLines.length - 1 : rawLines.length;
+  const headContinues = (idx) => {
+    for (let j = idx + 1; j < n; j++) {
+      if ((maskedLines[j] ?? "").trim() === "") continue;
+      if (!/^\s/.test(rawLines[j] ?? "")) return false;
+      return /^(?:\|(?!\|)|=(?![=>])|::)/.test((maskedLines[j] ?? "").trim());
+    }
+    return false;
+  };
   const boundaries = [];
   for (let idx = 0; idx < n; idx++) {
     const raw = rawLines[idx] ?? "";
@@ -5769,7 +7486,7 @@ function extractHaskell(content, filePath) {
     const maskedLine = maskedLines[idx] ?? "";
     const trimmed = maskedLine.trim();
     if (trimmed === "") continue;
-    const defs = classify(trimmed);
+    const defs = classify(trimmed) ?? classify(trimmed, headContinues(idx));
     if (defs === void 0) {
       boundaries.push({ num: idx + 1, consumed: false });
       continue;
@@ -5786,6 +7503,17 @@ function extractHaskell(content, filePath) {
         boundaries[endIdx + 1].consumed = true;
         endIdx++;
       }
+      if (boundaries.some((o, k) => k !== i && o.num === b.num && o.def?.kind === "function")) {
+        let k = endIdx + 1;
+        while (k < boundaries.length && boundaries[k].def?.kind === "function" && boundaries[k].def?.name !== b.def.name) k++;
+        if (k < boundaries.length && boundaries[k].def?.kind === "function" && !boundaries[k].consumed) {
+          while (k < boundaries.length && boundaries[k].def?.kind === "function" && boundaries[k].def?.name === b.def.name) {
+            boundaries[k].consumed = true;
+            endIdx = k;
+            k++;
+          }
+        }
+      }
     }
     const next = boundaries[endIdx + 1];
     const lineEnd = Math.max(b.num, next !== void 0 ? next.num - 1 : n);
@@ -5935,7 +7663,7 @@ function extractOcaml(content, filePath) {
   const rawLines = content.split(/\r?\n/);
   const masked = maskOcaml(content);
   const maskedLines = masked.split(/\r?\n/);
-  const n = rawLines.length;
+  const n = rawLines.length > 1 && rawLines[rawLines.length - 1] === "" ? rawLines.length - 1 : rawLines.length;
   const boundaries = [];
   for (let idx = 0; idx < n; idx++) {
     const raw = rawLines[idx] ?? "";
@@ -5943,6 +7671,7 @@ function extractOcaml(content, filePath) {
     const maskedLine = maskedLines[idx] ?? "";
     const trimmed = maskedLine.trim();
     if (trimmed === "") continue;
+    if (/^end\b/.test(trimmed)) continue;
     const def = classify2(trimmed);
     boundaries.push(def === void 0 ? { num: idx + 1 } : { num: idx + 1, def });
   }
@@ -6296,12 +8025,17 @@ function sectionsToHeadingSymbols(sections, filePath) {
     parent: ""
   }));
 }
+var CSHARP_SPAN_OPTS = { lineComment: "//", stringEscapes: "csharp", rawStringQuotes: true, expressionBodies: true, interpolation: "csharp" };
 var ADAPTER_EXTRACTORS = {
-  csharp: (content, filePath) => assignBraceBlockSpans(extractCsharp(content, filePath).symbols, content, { lineComment: "//", stringEscapes: "csharp", rawStringQuotes: true }),
+  csharp: (content, filePath) => {
+    const { symbols, settled } = extractCsharp(content, filePath);
+    return spanUnsettled(symbols, settled, (rest) => assignBraceBlockSpans(rest, content, CSHARP_SPAN_OPTS));
+  },
   // Both halves walk the SAME masked text: the brace pass used to span raw file content, so it nested on braces in the inline HTML the extractor is no longer reading.
   php: (content, filePath) => {
     const code = maskPhpInlineHtml(content);
-    return assignBraceBlockSpans(extractPhp(code, filePath).symbols, code, { lineComment: ["//", "#"], lineCommentExceptions: ["#["], multilineLang: "php" });
+    const { symbols, settled } = extractPhp(code, filePath);
+    return spanUnsettled(symbols, settled, (rest) => assignBraceBlockSpans(rest, code, { lineComment: ["//", "#"], lineCommentExceptions: ["#["], multilineLang: "php" }));
   },
   html: (content, filePath) => {
     const r = extractHtml(content, filePath);
@@ -6311,9 +8045,7 @@ var ADAPTER_EXTRACTORS = {
     const r = extractLiquid(content, filePath);
     return [...r.symbols, ...sectionsToHeadingSymbols(r.sections, filePath)];
   },
-  // The six template dialects mask their own delimiters out and hand off to extractHtml, so they
-  // compose the same way html/liquid do above -- see templates_idx.ts's module doc for why this
-  // is the one place in Batch G/F where sharing IS correct.
+  // The six template dialects mask their own delimiters out and hand off to extractHtml, so they compose the same way html/liquid do above -- see templates_idx.ts's module doc for why this is the one place in Batch G/F where sharing IS correct.
   jinja2: (content, filePath) => {
     const r = extractJinja2(content, filePath);
     return [...r.symbols, ...sectionsToHeadingSymbols(r.sections, filePath)];
@@ -6338,13 +8070,22 @@ var ADAPTER_EXTRACTORS = {
     const r = extractTwig(content, filePath);
     return [...r.symbols, ...sectionsToHeadingSymbols(r.sections, filePath)];
   },
-  kotlin: (content, filePath) => assignBraceBlockSpans(extractKotlin(content, filePath).symbols, content, { lineComment: "//", nestedBlockComments: true, tripleQuote: true, tripleQuoteRunClose: "last" }),
-  swift: (content, filePath) => assignBraceBlockSpans(extractSwift(content, filePath).symbols, content, { lineComment: "//", nestedBlockComments: true, tripleQuote: true, tripleQuoteRunClose: "last", multilineLang: "swift" }),
-  scala: (content, filePath) => assignBraceBlockSpans(extractScala(content, filePath).symbols, content, { lineComment: "//", nestedBlockComments: true, tripleQuote: true, tripleQuoteRunClose: "last" }),
+  kotlin: (content, filePath) => {
+    const { symbols, settled } = extractKotlin(content, filePath);
+    return spanUnsettled(symbols, settled, (rest) => assignBraceBlockSpans(rest, content, { lineComment: "//", nestedBlockComments: true, tripleQuote: true, tripleQuoteRunClose: "last", expressionBodies: "kotlin", interpolation: "kotlin" }));
+  },
+  swift: (content, filePath) => {
+    const { symbols, settled } = extractSwift(content, filePath);
+    return spanUnsettled(symbols, settled, (rest) => assignBraceBlockSpans(rest, content, { lineComment: "//", nestedBlockComments: true, tripleQuote: true, tripleQuoteRunClose: "last", multilineLang: "swift", interpolation: "swift" }));
+  },
+  scala: (content, filePath) => {
+    const { symbols, settled } = extractScala(content, filePath);
+    return spanUnsettled(symbols, settled, (rest) => assignBraceBlockSpans(rest, content, { lineComment: "//", nestedBlockComments: true, tripleQuote: true, tripleQuoteRunClose: "last", expressionBodies: "kotlin", interpolation: "scala", symbolLiterals: true }));
+  },
   lua: (content, filePath) => extractLua(content, filePath).symbols,
   vb: (content, filePath) => extractVb(content, filePath).symbols,
   elixir: (content, filePath) => extractElixir(content, filePath).symbols,
-  dart: (content, filePath) => assignBraceBlockSpans(extractDart(content, filePath).symbols, content, { lineComment: "//", nestedBlockComments: true, tripleQuote: true, tripleSingleQuote: true, tripleQuoteRunClose: "first" }),
+  dart: (content, filePath) => assignBraceBlockSpans(extractDart(content, filePath).symbols, content, { lineComment: "//", nestedBlockComments: true, tripleQuote: true, tripleSingleQuote: true, tripleQuoteRunClose: "first", interpolation: "dart" }),
   zig: (content, filePath) => assignBraceBlockSpans(extractZig(content, filePath).symbols, content, { lineComment: "//", blockComment: null, lineStringPrefix: "\\\\" }),
   r: (content, filePath) => extractR(content, filePath).symbols,
   graphql: (content, filePath) => extractGraphql(content, filePath).symbols,
@@ -6396,10 +8137,14 @@ var ADAPTER_EXTRACTORS = {
 };
 export {
   ADAPTER_EXTRACTORS,
+  CSHARP_SPAN_OPTS,
+  assignBraceBlockSpans,
   extractAstro,
   extractCobol,
+  extractCsharp,
   extractNatural,
   extractSalesforceMetadata,
   extractSvelte,
-  extractVue
+  extractVue,
+  spanUnsettled
 };