@lzehrung/codegraph 2.3.28 → 2.3.30

package/dist/bin/query-index-worker.js

@@ -75,7 +75,829 @@ function getLanguageById(id) {
   return registry.get(id);
 }
 
+// dist/languages/definitions/shared.js
+function isNameFieldOnParent(node, parentTypes, field = "name") {
+  const parent = node.parent;
+  if (!parent || !parentTypes.includes(parent.type))
+    return false;
+  return parent.childForFieldName(field)?.id === node.id;
+}
+function isNameOrPropertyFieldOnParent(node, parentTypes) {
+  const parent = node.parent;
+  if (!parent || !parentTypes.includes(parent.type))
+    return false;
+  const name = parent.childForFieldName("name") ?? parent.childForFieldName("property");
+  return name?.id === node.id;
+}
+function hasParentType(node, parentTypes) {
+  return parentTypes.includes(node.parent?.type ?? "");
+}
+function matchesParentTypePairs(node, pairs) {
+  const parentType = node.parent?.type;
+  if (!parentType)
+    return false;
+  return pairs.some(([parent, child]) => parent === parentType && child === node.type);
+}
+function classifyByParentType(mapping, fallback = "variable") {
+  return (node) => {
+    const parent = node.parent;
+    if (!parent)
+      return fallback;
+    const entry = mapping[parent.type];
+    if (entry === void 0)
+      return fallback;
+    if (typeof entry === "string")
+      return entry;
+    if (entry.nameField !== void 0 && parent.childForFieldName(entry.nameField)?.id !== node.id) {
+      return fallback;
+    }
+    return entry.kind;
+  };
+}
+function nodeTypeIn(types) {
+  const nodeTypes = new Set(types);
+  return (node) => nodeTypes.has(node.type);
+}
+
+// dist/util/trivia-tables.js
+var SLASH_STAR_COMMENT = { open: "/*", close: "*/" };
+var NESTED_SLASH_STAR_COMMENT = { open: "/*", close: "*/", nested: true };
+var JS_LIKE_ROW = {
+  lineComments: ["//"],
+  blockComments: [SLASH_STAR_COMMENT],
+  strings: [
+    { open: "'", close: "'", escape: "\\" },
+    { open: '"', close: '"', escape: "\\" },
+    { open: "`", close: "`", escape: "\\", interpolation: { start: "${", end: "}", excludeFromMask: true } }
+  ]
+};
+var PYTHON_F_PREFIX = "(?:[fF]|[rR][fF]|[fF][rR])";
+var PYTHON_PLAIN_PREFIX = "(?:[bBuU]|[bB][rR]|[rR][bB])?";
+var PYTHON_INTERPOLATION = { start: "{", end: "}", doubled: true };
+var PYTHON_ROW = {
+  lineComments: ["#"],
+  blockComments: [],
+  strings: [
+    { prefix: PYTHON_F_PREFIX, open: '"""', close: '"""', escape: "\\", interpolation: PYTHON_INTERPOLATION },
+    { prefix: PYTHON_F_PREFIX, open: "'''", close: "'''", escape: "\\", interpolation: PYTHON_INTERPOLATION },
+    { prefix: PYTHON_F_PREFIX, open: '"', close: '"', escape: "\\", interpolation: PYTHON_INTERPOLATION },
+    { prefix: PYTHON_F_PREFIX, open: "'", close: "'", escape: "\\", interpolation: PYTHON_INTERPOLATION },
+    { prefix: PYTHON_PLAIN_PREFIX, open: '"""', close: '"""', escape: "\\" },
+    { prefix: PYTHON_PLAIN_PREFIX, open: "'''", close: "'''", escape: "\\" },
+    { prefix: PYTHON_PLAIN_PREFIX, open: '"', close: '"', escape: "\\" },
+    { prefix: PYTHON_PLAIN_PREFIX, open: "'", close: "'", escape: "\\" }
+  ]
+};
+var CSHARP_ROW = {
+  lineComments: ["//"],
+  blockComments: [SLASH_STAR_COMMENT],
+  strings: [
+    // A verbatim (or interpolated verbatim) string doubles its closing quote; the backslash is data.
+    { prefix: "(?:[$][@]|[@][$]|[@])", open: '"', close: '"', doubled: true },
+    { open: '"""', close: '"""', quoteRun: true },
+    { open: '"', close: '"', escape: "\\" },
+    { open: "'", close: "'", escape: "\\" }
+  ]
+};
+var GO_ROW = {
+  lineComments: ["//"],
+  blockComments: [SLASH_STAR_COMMENT],
+  strings: [
+    { open: "`", close: "`" },
+    { open: '"', close: '"', escape: "\\" },
+    { open: "'", close: "'", escape: "\\" }
+  ]
+};
+var RUST_ROW = {
+  lineComments: ["//"],
+  blockComments: [NESTED_SLASH_STAR_COMMENT],
+  strings: [
+    { prefix: "[bc]?r", open: '"', close: '"', hashes: true },
+    { prefix: "b?", open: '"', close: '"', escape: "\\" },
+    { prefix: "b?", open: "'", close: "'", escape: "\\", charLike: true }
+  ]
+};
+var PHP_HEREDOC_OPENER = `<<<[ \\t]*(?:"([^"\\r\\n]*)"|'([^'\\r\\n]*)'|([A-Za-z_]\\w*))`;
+var PHP_ROW = {
+  lineComments: ["//", "#"],
+  blockComments: [SLASH_STAR_COMMENT],
+  strings: [
+    { open: "'", close: "'", escape: "\\" },
+    { open: '"', close: '"', escape: "\\" }
+  ],
+  heredocs: [{ opener: PHP_HEREDOC_OPENER, indentedTerminator: true }]
+};
+var RUBY_HEREDOC_ID = `(?:"([^"\\r\\n]*)"|'([^'\\r\\n]*)'|([A-Za-z_]\\w*))`;
+var RUBY_ROW = {
+  lineComments: ["#"],
+  blockComments: [{ open: "=begin", close: "=end", lineStartOnly: true }],
+  strings: [
+    { open: '"', close: '"', escape: "\\" },
+    { open: "'", close: "'", escape: "\\" }
+  ],
+  heredocs: [
+    { opener: `<<[~-]${RUBY_HEREDOC_ID}`, indentedTerminator: true },
+    { opener: `<<${RUBY_HEREDOC_ID}`, indentedTerminator: false }
+  ],
+  percentLiterals: true
+};
+var SWIFT_INTERPOLATION = { start: "\\(", end: ")" };
+var SWIFT_ROW = {
+  lineComments: ["//"],
+  blockComments: [NESTED_SLASH_STAR_COMMENT],
+  strings: [
+    { open: '"""', close: '"""', escape: "\\", closeAloneOnLine: true, interpolation: SWIFT_INTERPOLATION },
+    { open: '"', close: '"', escape: "\\", interpolation: SWIFT_INTERPOLATION },
+    { hashes: true, open: '"""', close: '"""', closeAloneOnLine: true },
+    { hashes: true, open: '"', close: '"' }
+  ]
+};
+var KOTLIN_ROW = {
+  lineComments: ["//"],
+  blockComments: [NESTED_SLASH_STAR_COMMENT],
+  strings: [
+    { open: '"""', close: '"""', interpolation: { start: "${", end: "}" } },
+    { open: '"', close: '"', escape: "\\", interpolation: { start: "${", end: "}" } },
+    { open: "'", close: "'", escape: "\\" }
+  ]
+};
+var ZIG_ROW = {
+  lineComments: ["//"],
+  blockComments: [],
+  strings: [
+    { open: '"', close: '"', escape: "\\" },
+    { open: "'", close: "'", escape: "\\" }
+  ],
+  zigMultiline: true
+};
+var CSS_FAMILY_ROW = {
+  lineComments: [],
+  blockComments: [SLASH_STAR_COMMENT],
+  strings: [
+    { open: "'", close: "'", escape: "\\" },
+    { open: '"', close: '"', escape: "\\" }
+  ]
+};
+var C_FAMILY_ROW = {
+  lineComments: ["//"],
+  blockComments: [SLASH_STAR_COMMENT],
+  strings: [
+    { open: '"', close: '"', escape: "\\" },
+    { open: "'", close: "'", escape: "\\" }
+  ]
+};
+var JAVA_ROW = {
+  lineComments: ["//"],
+  blockComments: [SLASH_STAR_COMMENT],
+  strings: [
+    { open: '"""', close: '"""', escape: "\\" },
+    { open: '"', close: '"', escape: "\\" },
+    { open: "'", close: "'", escape: "\\" }
+  ]
+};
+var SQL_ROW = {
+  lineComments: ["--"],
+  blockComments: [SLASH_STAR_COMMENT],
+  strings: [
+    { open: "'", close: "'", doubled: true },
+    { open: '"', close: '"', doubled: true }
+  ]
+};
+var TRIVIA_ROWS = {
+  js: JS_LIKE_ROW,
+  ts: JS_LIKE_ROW,
+  tsx: JS_LIKE_ROW,
+  javascript: JS_LIKE_ROW,
+  typescript: JS_LIKE_ROW,
+  jsx: JS_LIKE_ROW,
+  python: PYTHON_ROW,
+  csharp: CSHARP_ROW,
+  go: GO_ROW,
+  rust: RUST_ROW,
+  php: PHP_ROW,
+  ruby: RUBY_ROW,
+  swift: SWIFT_ROW,
+  kotlin: KOTLIN_ROW,
+  zig: ZIG_ROW,
+  css: CSS_FAMILY_ROW,
+  less: CSS_FAMILY_ROW,
+  scss: CSS_FAMILY_ROW,
+  c: C_FAMILY_ROW,
+  cpp: C_FAMILY_ROW,
+  java: JAVA_ROW,
+  sql: SQL_ROW
+};
+function triviaRowFor(languageId) {
+  return TRIVIA_ROWS[languageId] ?? JS_LIKE_ROW;
+}
+
+// dist/util/trivia.js
+function maskTrivia(source, languageId, options) {
+  const mask = buildMarkedMask(source, languageId, {
+    maskStrings: options?.maskStrings ?? true,
+    mode: "render"
+  });
+  const chars = source.split("");
+  for (let i = 0; i < chars.length; i += 1) {
+    const ch = chars[i];
+    if (mask[i] && ch !== "\n" && ch !== "\r")
+      chars[i] = " ";
+  }
+  return chars.join("");
+}
+function buildMarkedMask(source, languageId, options) {
+  const row = triviaRowFor(languageId);
+  const mask = new Uint8Array(source.length);
+  const starters = rowStarters(row);
+  let index = 0;
+  while (index < source.length) {
+    if (!starters.has(source[index] ?? "")) {
+      index += 1;
+      continue;
+    }
+    const commentEnd = commentSpanEnd(source, row, index);
+    if (commentEnd !== null) {
+      for (let i = index; i < commentEnd; i += 1)
+        mask[i] = 1;
+      index = commentEnd;
+      continue;
+    }
+    if (!options.maskStrings) {
+      const stringEnd = stringSpanEnd(source, row, index);
+      if (stringEnd !== null) {
+        index = stringEnd;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    const construct = nextTriviaConstruct(source, row, index);
+    if (!construct) {
+      index += 1;
+      continue;
+    }
+    for (const [start, end] of constructSpans(construct, options.mode)) {
+      for (let i = start; i < end; i += 1)
+        mask[i] = 1;
+    }
+    index = construct.end;
+  }
+  return mask;
+}
+function constructSpans(construct, mode) {
+  if (construct.delimitersAreTrivia || mode === "full")
+    return [[construct.start, construct.end]];
+  if (mode === "render")
+    return construct.renderSpans;
+  return construct.maskSpans;
+}
+var starterCache = /* @__PURE__ */ new WeakMap();
+var prefixRegexCache = /* @__PURE__ */ new WeakMap();
+var openerRegexCache = /* @__PURE__ */ new WeakMap();
+function rowStarters(row) {
+  const cached = starterCache.get(row);
+  if (cached)
+    return cached;
+  const starters = /* @__PURE__ */ new Set();
+  for (const prefix of row.lineComments)
+    starters.add(prefix[0] ?? "");
+  for (const comment of row.blockComments)
+    starters.add(comment.open[0] ?? "");
+  for (const form of row.strings) {
+    if (form.prefix) {
+      for (const ch of literalCharsInRegexSource(form.prefix))
+        starters.add(ch);
+    }
+    if (form.hashes)
+      starters.add("#");
+    starters.add(form.open[0] ?? "");
+  }
+  if (row.heredocs) {
+    for (const heredoc of row.heredocs)
+      starters.add(heredoc.opener[0] ?? "");
+  }
+  if (row.percentLiterals)
+    starters.add("%");
+  if (row.zigMultiline)
+    starters.add("\\");
+  starterCache.set(row, starters);
+  return starters;
+}
+function literalCharsInRegexSource(prefixSource) {
+  const bare = prefixSource.replace(/[()|[\]?]/g, "");
+  return Array.from(bare.match(/[A-Za-z0-9@$'"`#\\%<>&*=~,^!;:-]/g) ?? []);
+}
+function prefixRegexFor(form) {
+  let regex = prefixRegexCache.get(form);
+  if (!regex) {
+    regex = new RegExp(form.prefix ?? "", "y");
+    prefixRegexCache.set(form, regex);
+  }
+  return regex;
+}
+function openerRegexFor(heredoc) {
+  let regex = openerRegexCache.get(heredoc);
+  if (!regex) {
+    regex = new RegExp(heredoc.opener, "y");
+    openerRegexCache.set(heredoc, regex);
+  }
+  return regex;
+}
+function fullRangeConstruct(start, end, delimitersAreTrivia) {
+  return {
+    start,
+    end,
+    renderSpans: [[start, end]],
+    maskSpans: [[start, end]],
+    delimitersAreTrivia
+  };
+}
+function nextTriviaConstruct(source, row, index) {
+  const commentEnd = commentSpanEnd(source, row, index);
+  if (commentEnd !== null)
+    return fullRangeConstruct(index, commentEnd, true);
+  const heredocConstruct = heredocConstructAt(source, row, index);
+  if (heredocConstruct !== null)
+    return heredocConstruct;
+  const stringConstruct = stringConstructAt(source, row, index);
+  if (stringConstruct !== null)
+    return stringConstruct;
+  if (row.percentLiterals) {
+    const percentConstruct = percentLiteralConstructAt(source, index);
+    if (percentConstruct !== null)
+      return percentConstruct;
+  }
+  if (row.zigMultiline && source.startsWith("\\\\", index)) {
+    return zigMultilineConstruct(source, index);
+  }
+  return null;
+}
+function commentSpanEnd(source, row, index) {
+  for (const prefix of row.lineComments) {
+    if (source.startsWith(prefix, index))
+      return lineCommentEnd(source, index + prefix.length);
+  }
+  for (const comment of row.blockComments) {
+    if (comment.lineStartOnly) {
+      const atLineStart = index === 0 || source[index - 1] === "\n";
+      if (!atLineStart || !source.startsWith(comment.open, index))
+        continue;
+      return lineStartOnlyBlockCommentEnd(source, index + comment.open.length, comment.close);
+    }
+    if (!source.startsWith(comment.open, index))
+      continue;
+    return blockCommentEnd(source, index + comment.open.length, comment, 1);
+  }
+  return null;
+}
+function lineCommentEnd(source, index) {
+  let end = index;
+  while (end < source.length && source[end] !== "\n" && source[end] !== "\r")
+    end += 1;
+  return end;
+}
+function blockCommentEnd(source, index, comment, depth) {
+  let cursor = index;
+  let remaining = depth;
+  while (cursor < source.length && remaining > 0) {
+    if (comment.nested && source.startsWith(comment.open, cursor)) {
+      remaining += 1;
+      cursor += comment.open.length;
+      continue;
+    }
+    if (source.startsWith(comment.close, cursor)) {
+      remaining -= 1;
+      cursor += comment.close.length;
+      continue;
+    }
+    cursor += 1;
+  }
+  return remaining > 0 ? source.length : cursor;
+}
+function lineStartOnlyBlockCommentEnd(source, index, close) {
+  let lineStart = index;
+  while (lineStart < source.length) {
+    if (source.startsWith(close, lineStart))
+      return lineStart + close.length;
+    const newline = source.indexOf("\n", lineStart);
+    if (newline < 0)
+      return source.length;
+    lineStart = newline + 1;
+  }
+  return source.length;
+}
+function precededByIdentifier(source, index) {
+  if (index <= 0)
+    return false;
+  return /[\p{ID_Continue}$_]/u.test(source[index - 1] ?? "");
+}
+function stringSpanEnd(source, row, index) {
+  return stringConstructAt(source, row, index)?.end ?? null;
+}
+function stringConstructAt(source, row, index) {
+  for (const form of row.strings) {
+    const construct = quotedStringConstruct(source, row, form, index);
+    if (construct !== null)
+      return construct;
+  }
+  return null;
+}
+function quotedStringConstruct(source, row, form, index) {
+  let cursor = index;
+  if (form.prefix) {
+    const prefixRe = prefixRegexFor(form);
+    prefixRe.lastIndex = cursor;
+    if (!prefixRe.exec(source))
+      return null;
+    cursor = prefixRe.lastIndex;
+    if (precededByIdentifier(source, index))
+      return null;
+  }
+  let hashCount = 0;
+  if (form.hashes) {
+    while (source[cursor] === "#") {
+      hashCount += 1;
+      cursor += 1;
+    }
+    if (precededByIdentifier(source, index))
+      return null;
+    if (!source.startsWith(form.open, cursor))
+      return null;
+  } else if (form.charLike) {
+    const charEnd = charLiteralEnd(source, cursor, form);
+    if (charEnd === null)
+      return null;
+    const body2 = [cursor + 1, charEnd - 1];
+    return {
+      start: index,
+      end: charEnd,
+      renderSpans: body2[0] < body2[1] ? [body2] : [],
+      maskSpans: [[index, charEnd]],
+      delimitersAreTrivia: false
+    };
+  } else if (form.quoteRun) {
+    let run = 0;
+    while (source[cursor + run] === form.open[0])
+      run += 1;
+    if (run < form.open.length)
+      return null;
+    const scanned = quoteRunStringEnd(source, cursor + run, form.open[0] ?? '"', run);
+    const bodyStart2 = cursor + run;
+    const body2 = [bodyStart2, scanned.closeStart];
+    return {
+      start: index,
+      end: scanned.end,
+      renderSpans: body2[0] < body2[1] ? [body2] : [],
+      maskSpans: [[index, scanned.end]],
+      delimitersAreTrivia: false
+    };
+  } else {
+    if (!source.startsWith(form.open, cursor))
+      return null;
+  }
+  const bodyStart = cursor + form.open.length;
+  const body = collectQuotedBody(source, row, form, bodyStart, form.close, hashCount);
+  return {
+    start: index,
+    end: body.end,
+    renderSpans: bodyStart < body.closeStart ? [[bodyStart, body.closeStart]] : [],
+    maskSpans: [[index, bodyStart], ...body.segments, [body.closeStart, body.end]],
+    delimitersAreTrivia: false
+  };
+}
+function collectQuotedBody(source, row, form, start, close, hashCount) {
+  const segments = [];
+  let cursor = start;
+  let segmentStart = start;
+  const pushSegment = (upTo) => {
+    if (segmentStart < upTo)
+      segments.push([segmentStart, upTo]);
+  };
+  while (cursor < source.length) {
+    const ch = source[cursor];
+    if (form.interpolation) {
+      const interpolation = form.interpolation;
+      const doubled = interpolation.doubled && source.startsWith(interpolation.start, cursor) && source.startsWith(interpolation.start, cursor + interpolation.start.length);
+      if (doubled) {
+        cursor += interpolation.start.length * 2;
+        continue;
+      }
+      if (source.startsWith(interpolation.start, cursor)) {
+        if (interpolation.excludeFromMask) {
+          pushSegment(cursor);
+          const inner = collectInterpolationSpans(source, row, cursor, interpolation);
+          cursor = inner.end;
+          segmentStart = cursor;
+          continue;
+        }
+        cursor = interpolationEnd(source, row, cursor, interpolation);
+        continue;
+      }
+    }
+    if (form.escape && ch === form.escape) {
+      cursor += 2;
+      continue;
+    }
+    if (form.doubled && source.startsWith(close, cursor) && source.startsWith(close, cursor + close.length)) {
+      cursor += close.length * 2;
+      continue;
+    }
+    if (source.startsWith(close, cursor)) {
+      let closeEnd = cursor + close.length;
+      if (hashCount > 0) {
+        let hashes = 0;
+        while (source[closeEnd + hashes] === "#")
+          hashes += 1;
+        if (hashes < hashCount) {
+          cursor += 1;
+          continue;
+        }
+        closeEnd += hashCount;
+      }
+      if (form.closeAloneOnLine && !closeAloneOnItsLine(source, cursor)) {
+        cursor += 1;
+        continue;
+      }
+      pushSegment(cursor);
+      return { end: closeEnd, closeStart: cursor, segments };
+    }
+    cursor += 1;
+  }
+  pushSegment(source.length);
+  return { end: source.length, closeStart: source.length, segments };
+}
+function charLiteralEnd(source, quoteIndex, form) {
+  let cursor = quoteIndex + 1;
+  if (cursor >= source.length)
+    return null;
+  if (source[cursor] === form.escape) {
+    while (cursor < source.length && source[cursor] !== "'") {
+      cursor += source[cursor] === "\\" ? 2 : 1;
+    }
+    return cursor < source.length ? cursor + 1 : cursor;
+  }
+  if (source[cursor + 1] === "'")
+    return cursor + 2;
+  return null;
+}
+function quoteRunStringEnd(source, index, quote, runLength) {
+  let cursor = index;
+  while (cursor < source.length) {
+    if (source[cursor] !== quote) {
+      cursor += 1;
+      continue;
+    }
+    let run = 0;
+    while (source[cursor + run] === quote)
+      run += 1;
+    if (run >= runLength)
+      return { end: cursor + run, closeStart: cursor };
+    cursor += run;
+  }
+  return { end: source.length, closeStart: source.length };
+}
+function closeAloneOnItsLine(source, closeIndex) {
+  const lineStart = source.lastIndexOf("\n", closeIndex - 1) + 1;
+  for (let i = lineStart; i < closeIndex; i += 1) {
+    const ch = source[i];
+    if (ch !== " " && ch !== "	" && ch !== "\r")
+      return false;
+  }
+  return true;
+}
+function interpolationEnd(source, row, start, interpolation) {
+  return collectInterpolationSpans(source, row, start, interpolation).end;
+}
+function collectInterpolationSpans(source, row, start, interpolation) {
+  const nestOpen = interpolation.start[interpolation.start.length - 1] ?? "";
+  const spans = [];
+  let depth = 1;
+  let cursor = start + interpolation.start.length;
+  while (cursor < source.length) {
+    const ch = source[cursor];
+    if (source.startsWith(interpolation.end, cursor)) {
+      depth -= 1;
+      if (!depth)
+        return { end: cursor + interpolation.end.length, spans };
+      cursor += interpolation.end.length;
+      continue;
+    }
+    if (ch === nestOpen) {
+      depth += 1;
+      cursor += 1;
+      continue;
+    }
+    const commentEnd = commentSpanEnd(source, row, cursor);
+    if (commentEnd !== null) {
+      spans.push([cursor, commentEnd]);
+      cursor = commentEnd;
+      continue;
+    }
+    const nested = stringConstructAt(source, row, cursor);
+    if (nested !== null) {
+      spans.push(...nested.maskSpans);
+      cursor = nested.end;
+      continue;
+    }
+    cursor += 1;
+  }
+  return { end: source.length, spans };
+}
+function heredocConstructAt(source, row, index) {
+  if (!row.heredocs)
+    return null;
+  for (const heredoc of row.heredocs) {
+    const openerRe = openerRegexFor(heredoc);
+    openerRe.lastIndex = index;
+    const match = openerRe.exec(source);
+    if (!match)
+      continue;
+    if (precededByIdentifier(source, index))
+      continue;
+    const terminatorId = match.slice(1).find((id) => id !== void 0) ?? "";
+    if (!terminatorId)
+      continue;
+    const indentedTerminator = heredoc.indentedTerminator ?? false;
+    const scanned = heredocBodyEnd(source, match.index + match[0].length, terminatorId, indentedTerminator);
+    const bodyStart = match.index + match[0].length;
+    return {
+      start: index,
+      end: scanned.end,
+      renderSpans: bodyStart < scanned.terminatorStart ? [[bodyStart, scanned.terminatorStart]] : [],
+      maskSpans: [[index, scanned.end]],
+      delimitersAreTrivia: false
+    };
+  }
+  return null;
+}
+function heredocBodyEnd(source, afterOpener, terminatorId, indentedTerminator) {
+  let lineStart = source.indexOf("\n", afterOpener);
+  if (lineStart < 0)
+    return { end: source.length, terminatorStart: source.length };
+  lineStart += 1;
+  while (lineStart < source.length) {
+    let cursor = lineStart;
+    if (indentedTerminator) {
+      while (source[cursor] === " " || source[cursor] === "	" || source[cursor] === "\r")
+        cursor += 1;
+    }
+    if (source.startsWith(terminatorId, cursor)) {
+      const afterId = cursor + terminatorId.length;
+      const next = source[afterId];
+      if (next === void 0 || !/[\p{ID_Continue}$_]/u.test(next)) {
+        return { end: afterId, terminatorStart: cursor };
+      }
+    }
+    const newline = source.indexOf("\n", lineStart);
+    if (newline < 0)
+      return { end: source.length, terminatorStart: source.length };
+    lineStart = newline + 1;
+  }
+  return { end: source.length, terminatorStart: source.length };
+}
+var PERCENT_LITERAL_TYPES = "qQwWrsxiI";
+var PERCENT_BRACKET_PAIRS = { "(": ")", "[": "]", "{": "}", "<": ">" };
+function percentLiteralConstructAt(source, index) {
+  if (source[index] !== "%")
+    return null;
+  const typeChar = source[index + 1];
+  if (!typeChar || !PERCENT_LITERAL_TYPES.includes(typeChar))
+    return null;
+  const openChar = source[index + 2];
+  if (!openChar)
+    return null;
+  if (/[A-Za-z0-9 \t]/.test(openChar))
+    return null;
+  if (precededByIdentifier(source, index))
+    return null;
+  const closeChar = PERCENT_BRACKET_PAIRS[openChar];
+  const bodyStart = index + 3;
+  let cursor = bodyStart;
+  let depth = 1;
+  while (cursor < source.length) {
+    const ch = source[cursor];
+    if (ch === "\\") {
+      cursor += 2;
+      continue;
+    }
+    if (closeChar !== void 0) {
+      if (ch === openChar) {
+        depth += 1;
+      } else if (ch === closeChar) {
+        depth -= 1;
+        if (!depth) {
+          return {
+            start: index,
+            end: cursor + 1,
+            renderSpans: bodyStart < cursor ? [[bodyStart, cursor]] : [],
+            maskSpans: [[index, cursor + 1]],
+            delimitersAreTrivia: false
+          };
+        }
+      }
+    } else if (ch === openChar) {
+      return {
+        start: index,
+        end: cursor + 1,
+        renderSpans: bodyStart < cursor ? [[bodyStart, cursor]] : [],
+        maskSpans: [[index, cursor + 1]],
+        delimitersAreTrivia: false
+      };
+    }
+    cursor += 1;
+  }
+  return {
+    start: index,
+    end: source.length,
+    renderSpans: bodyStart < source.length ? [[bodyStart, source.length]] : [],
+    maskSpans: [[index, source.length]],
+    delimitersAreTrivia: false
+  };
+}
+function zigMultilineConstruct(source, start) {
+  const renderSpans = [];
+  let cursor = start;
+  let end = source.length;
+  while (cursor < source.length) {
+    let lineEnd = cursor;
+    while (lineEnd < source.length && source[lineEnd] !== "\n")
+      lineEnd += 1;
+    if (cursor + 2 < lineEnd)
+      renderSpans.push([cursor + 2, lineEnd]);
+    if (lineEnd >= source.length) {
+      end = source.length;
+      break;
+    }
+    let probe = lineEnd + 1;
+    while (probe < source.length && (source[probe] === " " || source[probe] === "	" || source[probe] === "\r")) {
+      probe += 1;
+    }
+    if (source[probe] === "\\" && source[probe + 1] === "\\") {
+      cursor = probe;
+      continue;
+    }
+    end = lineEnd;
+    break;
+  }
+  return {
+    start,
+    end,
+    renderSpans,
+    maskSpans: [[start, end]],
+    delimitersAreTrivia: false
+  };
+}
+
+// dist/util/comments.js
+function stripJsLikeComments(src) {
+  return maskTrivia(src, "js", { maskStrings: false });
+}
+function maskJsLikeCommentsAndStrings(src) {
+  return maskTrivia(src, "js");
+}
+
 // dist/languages/definitions/js-family.js
+function isStatementLevelTypeKeywordClause(clause) {
+  const trimmed = clause.trim();
+  if (!/^type(?:\s+|(?=\{))/.test(trimmed))
+    return false;
+  return !trimmed.slice(4).trimStart().startsWith(",");
+}
+function isEcmaScriptTypeOnlyStatement(stmtText) {
+  const text = stripJsLikeComments(stmtText).trim();
+  const fromMatch = /^(?:import|export)\b\s*([\s\S]*?)\bfrom\s*["']/.exec(text);
+  if (fromMatch)
+    return isStatementLevelTypeKeywordClause(fromMatch[1] ?? "");
+  return /^(?:import|export)\b\s+type(?:\s+|(?=\{|$))/.test(text);
+}
+var ECMASCRIPT_DECLARATION_NAME_PARENTS = [
+  "function_declaration",
+  "generator_function_declaration",
+  "class_declaration",
+  "import_specifier",
+  "namespace_import",
+  "import_clause",
+  // Method names in classes: needed so that editing a method name is
+  // classified as a definition change, not an unrecognised node.
+  "method_definition",
+  // A named function expression binds its own name; `$scope.x = function x() {}` and
+  // `const f = function inner() {}` are the common shapes.
+  "function_expression"
+];
+var ECMASCRIPT_BLOCK_SCOPE_TYPES = ["program", "block", "class_body", "class_static_block"];
+var ECMASCRIPT_FUNCTION_SCOPE_TYPES = [
+  "function_declaration",
+  "generator_function_declaration",
+  "function_expression",
+  "arrow_function",
+  "method_definition"
+];
+function isEcmaScriptVariableDeclaratorName(node) {
+  return isNameFieldOnParent(node, ["variable_declarator"]);
+}
+function isEcmaScriptFieldDefinitionName(node, parentType) {
+  return isNameOrPropertyFieldOnParent(node, [parentType]);
+}
 var ECMASCRIPT_CONTROL_SPLIT_POINTS = [
   "if_statement",
   "else_clause",
@@ -205,17 +1027,17 @@ var BASE_STRUCTURE = {
 };
 var BASE_GRAPH = {
   imports: `
-    (import_statement (string) @mod) @stmt
+    (import_statement (string) @from) @stmt
     ;; import x = require("...") is represented via import_require_clause
-    (import_statement (import_require_clause (string) @mod)) @stmt
-    (export_statement (string) @mod) @stmt
-    (call_expression function: (import) arguments: (arguments (string) @mod)) @stmt
+    (import_statement (import_require_clause (string) @from)) @stmt
+    (export_statement (string) @from) @stmt
+    (call_expression function: (import) arguments: (arguments (string) @from)) @stmt
     ;; declare module "foo" {} \u2014 ambient module augmentations create a type-only
     ;; dependency on the named module and must appear in the file graph so that
     ;; changes to "foo" propagate to augmenting files (and vice-versa).
     ;; The inner node type is "module" (not "module_declaration"); its string
     ;; child uses field-name "name".
-    (ambient_declaration (module name: (string) @mod)) @stmt
+    (ambient_declaration (module name: (string) @from)) @stmt
   `,
   exports: `
     (export_statement) @stmt
@@ -239,6 +1061,7 @@ var BASE_GRAPH = {
     (export_statement (export_clause (export_specifier "type"? @type_kw name: (identifier) @src !alias)) (string) @from) @stmt
     (export_statement (export_clause (export_specifier "type"? @type_kw name: (identifier) @src alias: (identifier) @alias))) @stmt
     (export_statement (export_clause (export_specifier "type"? @type_kw name: (identifier) @src !alias))) @stmt
+    (export_statement "*" @wild (string) @from) @stmt
     (export_statement (string) @from) @stmt
     (export_assignment (identifier) @ts_export_assign)
   `,
@@ -278,49 +1101,37 @@ var BASE_HELPERS = {
     shorthandPropertyIdentifier: ["shorthand_property_identifier", "shorthand_property_identifier_pattern"],
     memberExpression: "member_expression"
   },
-  classifyDefinition: (n) => {
-    const t = n.parent?.type;
-    if (t === "function_declaration")
-      return "function";
-    if (t === "generator_function_declaration")
-      return "function";
-    if (t === "method_definition")
-      return "function";
-    if (t === "method_signature")
-      return "function";
-    if (t === "abstract_method_signature")
-      return "function";
-    if (t === "function_signature")
-      return "function";
-    if (t === "class_declaration")
-      return "class";
-    if (t === "abstract_class_declaration")
-      return "class";
-    if (t === "interface_declaration")
-      return "interface";
-    if (t === "type_alias_declaration")
-      return "type";
-    if (t === "enum_declaration" || t === "internal_module" || t === "module")
-      return "type";
-    return "variable";
-  },
+  // A named function expression's own name is a function-kind binding, matching the
+  // declaration forms; the grammar spells the expression forms without the `_declaration`
+  // suffix (`function_expression`, `generator_function`).
+  classifyDefinition: classifyByParentType({
+    function_declaration: "function",
+    generator_function_declaration: "function",
+    function_expression: "function",
+    generator_function: "function",
+    method_definition: "function",
+    method_signature: "function",
+    abstract_method_signature: "function",
+    function_signature: "function",
+    class_declaration: "class",
+    abstract_class_declaration: "class",
+    interface_declaration: "interface",
+    type_alias_declaration: "type",
+    enum_declaration: "type",
+    internal_module: "type",
+    module: "type"
+  }),
   isDeclarationName: (node) => {
     const parent = node.parent;
-    const p = parent?.type;
-    if (parent?.type === "variable_declarator") {
-      return parent.childForFieldName("name")?.id === node.id;
-    }
-    if (parent?.type === "public_field_definition" || parent?.type === "enum_assignment") {
-      const name = parent.childForFieldName("name") ?? parent.childForFieldName("property");
-      return name?.id === node.id;
-    }
+    if (isEcmaScriptVariableDeclaratorName(node))
+      return true;
+    if (isNameOrPropertyFieldOnParent(node, ["public_field_definition", "enum_assignment"]))
+      return true;
     if (parent?.type === "enum_body") {
       return node.type === "property_identifier";
     }
-    return !!p && [
-      "generator_function_declaration",
-      "function_declaration",
-      "class_declaration",
+    return hasParentType(node, [
+      ...ECMASCRIPT_DECLARATION_NAME_PARENTS,
       "abstract_class_declaration",
       "interface_declaration",
       "type_alias_declaration",
@@ -328,27 +1139,29 @@ var BASE_HELPERS = {
       "function_signature",
       "internal_module",
       "module",
-      "import_specifier",
-      "namespace_import",
-      "import_clause",
       "import_equals_declaration",
       // Method names in classes and abstract method signatures: needed so
       // that editing a method name is classified as a definition change.
-      "method_definition",
       "method_signature",
-      "abstract_method_signature"
-    ].includes(p);
+      "abstract_method_signature",
+      // A named function expression binds its own name inside its body:
+      // `const f = function inner() {}` and `$scope.refresh = function refresh() {}`.
+      "generator_function"
+    ]);
   },
   // Scope construction has structural handling for the ordinary declaration forms. Ambient
-  // overload signatures and `namespace X {}` are not in it, so opt their name nodes in here;
-  // `isDeclarationName` already accepts both parents.
+  // overload signatures, `namespace X {}`, and a named function expression's own name are not
+  // in it, so opt their name nodes in here; `isDeclarationName` already accepts every parent.
+  // The function-expression name is registered after the function scope is pushed, so it lands
+  // in that scope: visible to the body (and recursive calls) but never to the module.
   scopeDeclarationNames: (node) => {
     const parent = node.parent?.type;
-    return parent === "function_signature" || parent === "internal_module" || parent === "module";
+    return parent === "function_signature" || parent === "internal_module" || parent === "module" || parent === "function_expression" || parent === "generator_function";
   },
-  createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body" || n.type === "class_static_block" || n.type === "enum_body",
-  createsFunctionScope: (n) => n.type === "generator_function_declaration" || n.type === "function_declaration" || n.type === "function" || n.type === "function_expression" || n.type === "arrow_function" || n.type === "method_definition",
-  membersAreImplicitlyInScope: false,
+  createsBlockScope: nodeTypeIn([...ECMASCRIPT_BLOCK_SCOPE_TYPES, "enum_body"]),
+  // A generator function expression has its own body scope: without this, its own name
+  // (registered above) and its parameters would land in the enclosing scope.
+  createsFunctionScope: nodeTypeIn([...ECMASCRIPT_FUNCTION_SCOPE_TYPES, "generator_function"]),
   supportsCrossModuleSymbols: true
 };
 var TYPESCRIPT_DEF = {
@@ -358,7 +1171,7 @@ var TYPESCRIPT_DEF = {
   graph: BASE_GRAPH,
   supportsExportFromReferences: true,
   ...BASE_HELPERS,
-  isTypeOnly: (stmtText) => /\b(import|export)\s+type\b/.test(stmtText),
+  isTypeOnly: isEcmaScriptTypeOnlyStatement,
   native: {
     normalizeQuery: normalizeTypeScriptNativeQuery,
     authoritativeKinds: ["exports"],
@@ -380,7 +1193,7 @@ var TSX_DEF = {
   graph: BASE_GRAPH,
   supportsExportFromReferences: true,
   ...BASE_HELPERS,
-  isTypeOnly: (stmtText) => /\b(import|export)\s+type\b/.test(stmtText),
+  isTypeOnly: isEcmaScriptTypeOnlyStatement,
   native: {
     normalizeQuery: normalizeTypeScriptNativeQuery,
     authoritativeKinds: ["exports"],
@@ -415,10 +1228,10 @@ var JAVASCRIPT_DEF = {
   },
   graph: {
     imports: `
-      (import_statement (string) @mod) @stmt
-      (export_statement (string) @mod) @stmt
-      (call_expression function: (import) arguments: (arguments (string) @mod)) @stmt
-      ((call_expression function: (identifier) @fn arguments: (arguments (string) @mod)) @stmt
+      (import_statement (string) @from) @stmt
+      (export_statement (string) @from) @stmt
+      (call_expression function: (import) arguments: (arguments (string) @from)) @stmt
+      ((call_expression function: (identifier) @fn arguments: (arguments (string) @from)) @stmt
         (#eq? @fn "require"))
     `,
     exports: `
@@ -434,8 +1247,10 @@ var JAVASCRIPT_DEF = {
       (export_statement (export_clause (export_specifier name: (identifier) @src !alias)) (string) @from)
       (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias)))
       (export_statement (export_clause (export_specifier name: (identifier) @src !alias)))
+      (export_statement "*" @wild (string) @from)
       (export_statement (string) @from)
       ;; CJS whole-module export: module.exports = function () {} / = () => {}
+      ;; @mod is the identifier module in module.exports, not a specifier; keep it out of GraphImportCapture.
       ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @mod property: (property_identifier) @cjs_export_name)
         right: [ (function) (arrow_function) ] @cjs_fn))
@@ -520,55 +1335,28 @@ var JAVASCRIPT_DEF = {
     shorthandPropertyIdentifier: ["shorthand_property_identifier", "shorthand_property_identifier_pattern"],
     memberExpression: "member_expression"
   },
-  classifyDefinition: (n) => {
-    const t = n.parent?.type;
-    if (t === "function_declaration")
-      return "function";
-    if (t === "generator_function_declaration")
-      return "function";
-    if (t === "method_definition")
-      return "function";
-    if (t === "function" || t === "function_expression")
-      return "function";
-    if (t === "class_declaration")
-      return "class";
-    return "variable";
-  },
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    const p = parent?.type;
-    if (parent?.type === "variable_declarator") {
-      return parent.childForFieldName("name")?.id === node.id;
-    }
-    if (parent?.type === "field_definition") {
-      const name = parent.childForFieldName("name") ?? parent.childForFieldName("property");
-      return name?.id === node.id;
-    }
-    return !!p && [
-      "function_declaration",
-      "generator_function_declaration",
-      "class_declaration",
-      "import_specifier",
-      "namespace_import",
-      "import_clause",
-      // Method names in classes: needed so that editing a method name is
-      // classified as a definition change, not an unrecognised node.
-      "method_definition",
-      // A named function expression binds its own name; `$scope.x = function x() {}` and
-      // `const f = function inner() {}` are the common shapes.
-      "function",
-      "function_expression"
-    ].includes(p);
-  },
+  classifyDefinition: classifyByParentType({
+    function_declaration: "function",
+    generator_function_declaration: "function",
+    method_definition: "function",
+    function: "function",
+    function_expression: "function",
+    class_declaration: "class"
+  }),
+  isDeclarationName: (node) => isEcmaScriptVariableDeclaratorName(node) || isEcmaScriptFieldDefinitionName(node, "field_definition") || // `function` is the JS grammar's function-expression node; the TS grammar spells it
+  // `function_expression` instead.
+  hasParentType(node, [...ECMASCRIPT_DECLARATION_NAME_PARENTS, "function"]),
   // Scope construction has no structural handling for a function expression's own name.
   scopeDeclarationNames: (node) => {
     const parent = node.parent?.type;
     return parent === "function" || parent === "function_expression";
   },
-  createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body" || n.type === "class_static_block",
-  createsFunctionScope: (n) => n.type === "function_declaration" || n.type === "generator_function_declaration" || n.type === "function" || n.type === "function_expression" || n.type === "arrow_function" || n.type === "method_definition",
-  membersAreImplicitlyInScope: false,
+  createsBlockScope: nodeTypeIn([...ECMASCRIPT_BLOCK_SCOPE_TYPES]),
+  createsFunctionScope: nodeTypeIn([...ECMASCRIPT_FUNCTION_SCOPE_TYPES, "function"]),
   supportsCrossModuleSymbols: true,
+  // JSDoc-typed `.js` files use `import type` / `export type`; the JS grammar has no type-only
+  // syntax, so classification matches statement text. A binding named `type` stays runtime.
+  isTypeOnly: isEcmaScriptTypeOnlyStatement,
   native: {
     normalizeQuery: (_kind, query) => query.replace(/\(function\)/g, "(function_expression)").replace(JS_OBJECT_METHOD_EXPORT_PATTERN, JS_OBJECT_METHOD_EXPORT_NATIVE_PATTERN),
     authoritativeKinds: ["exports"],
@@ -603,16 +1391,48 @@ function isTypeAliasLeftName(node) {
   if (!parent)
     return false;
   if (parent.type === "type") {
-    const stmt = parent.parent;
-    return stmt?.type === "type_alias_statement" && stmt.childForFieldName("left")?.id === parent.id;
+    const stmt4 = parent.parent;
+    return stmt4?.type === "type_alias_statement" && stmt4.childForFieldName("left")?.id === parent.id;
   }
   if (parent.type === "generic_type") {
     const typeNode = parent.parent;
-    const stmt = typeNode?.parent;
-    return typeNode?.type === "type" && stmt?.type === "type_alias_statement" && stmt.childForFieldName("left")?.id === typeNode.id;
+    const stmt4 = typeNode?.parent;
+    return typeNode?.type === "type" && stmt4?.type === "type_alias_statement" && stmt4.childForFieldName("left")?.id === typeNode.id;
   }
   return false;
 }
+function isPythonImplicitReceiverName(name) {
+  return name === "self" || name === "cls";
+}
+function isPythonReceiverAttributeAssignmentName(node) {
+  const attr = node.parent;
+  if (attr?.type !== "attribute")
+    return false;
+  if (attr.childForFieldName("attribute")?.id !== node.id)
+    return false;
+  const object = attr.childForFieldName("object");
+  if (!object || !isPythonImplicitReceiverName(object.text))
+    return false;
+  const assignment = attr.parent;
+  if (assignment?.type !== "assignment")
+    return false;
+  return assignment.childForFieldName("left")?.id === attr.id;
+}
+var PYTHON_GRAPH_IMPORT_QUERY = `
+      (import_statement name: (dotted_name) @from) @stmt
+      (import_statement name: (aliased_import name: (dotted_name) @from alias: (identifier) @alias)) @stmt
+      (import_from_statement module_name: (dotted_name) @from (wildcard_import)* @wild) @stmt
+      (import_from_statement (relative_import) @from (wildcard_import)* @wild) @stmt
+      ;; tree-sitter-python's future_import_statement has no named node for the
+      ;; \`__future__\` module; only the imported names are named children.
+      (future_import_statement) @stmt
+    `;
+var PYTHON_BINDING_QUERY = `
+      (import_statement . (_) @from) @stmt
+      (import_from_statement module_name: (dotted_name) @from) @stmt
+      (import_from_statement (relative_import) @from) @stmt
+      (future_import_statement) @stmt
+    `;
 var PYTHON_DEF = {
   id: "python",
   extensions: [".py", ".pyi", ".pyw"],
@@ -662,11 +1482,7 @@ var PYTHON_DEF = {
     comments: ["comment"]
   },
   graph: {
-    imports: `
-      (import_statement) @stmt
-      (import_from_statement) @stmt
-      (future_import_statement) @stmt
-    `,
+    imports: PYTHON_GRAPH_IMPORT_QUERY,
     // NOTE: These __all__ queries only capture module-level assignments.
     // Dynamic __all__ definitions inside functions, conditionals, or loops
     // (e.g., `if PY3: __all__ = [...]`) are not detected by these patterns.
@@ -709,6 +1525,13 @@ var PYTHON_DEF = {
       (class_definition name: (identifier) @name)
       (assignment left: (identifier) @name)
       (assignment left: [(pattern_list (identifier) @name) (tuple_pattern (identifier) @name)])
+      ;; Instance / class attributes declared as \`self.x = ...\` or \`cls.x = ...\`.
+      ((assignment
+        left: (attribute object: (identifier) @receiver attribute: (identifier) @name))
+        (#eq? @receiver "self"))
+      ((assignment
+        left: (attribute object: (identifier) @receiver attribute: (identifier) @name))
+        (#eq? @receiver "cls"))
       (named_expression name: (identifier) @name)
       (type_alias_statement left: (type [(identifier) @name (generic_type (identifier) @name)]))
       ;; \`case Point(x=px, y=py):\` is case_pattern -> class_pattern ->
@@ -730,11 +1553,7 @@ var PYTHON_DEF = {
       ;; \`case [head, *tail]:\` binds the capture after the splat.
       (splat_pattern (identifier) @name)
     `,
-    importBindings: `
-      (import_statement) @stmt
-      (import_from_statement) @stmt
-      (future_import_statement) @stmt
-    `
+    importBindings: PYTHON_BINDING_QUERY
   },
   nodeTypes: {
     identifier: ["identifier"],
@@ -767,9 +1586,11 @@ var PYTHON_DEF = {
     if (t === "splat_pattern")
       return true;
     if (t === "named_expression")
-      return parent?.childForFieldName("name")?.id === node.id;
+      return isNameFieldOnParent(node, ["named_expression"]);
     if (t === "pattern_list" || t === "tuple_pattern")
       return true;
+    if (isPythonReceiverAttributeAssignmentName(node))
+      return true;
     if (t === "assignment")
       return parent?.childForFieldName("left")?.id === node.id;
     if (t === "aliased_import")
@@ -778,9 +1599,8 @@ var PYTHON_DEF = {
       return true;
     return !!t && ["function_definition", "class_definition"].includes(t);
   },
-  createsBlockScope: (n) => n.type === "module" || n.type === "block",
-  createsFunctionScope: (n) => n.type === "function_definition" || n.type === "lambda",
-  membersAreImplicitlyInScope: false,
+  createsBlockScope: nodeTypeIn(["module", "block"]),
+  createsFunctionScope: nodeTypeIn(["function_definition", "lambda"]),
   supportsCrossModuleSymbols: true,
   // A function body and a class body are both `block`, so only the function form blocks exports.
   exportScopeBlockers: ["function_definition>block"],
@@ -789,6 +1609,17 @@ var PYTHON_DEF = {
 registerLanguage(PYTHON_DEF);
 
 // dist/languages/definitions/php.js
+var PHP_IMPORT_QUERY = `
+      (require_expression (_) @from) @stmt
+      (include_expression (_) @from) @stmt
+      (require_once_expression (_) @from) @stmt
+      (include_once_expression (_) @from) @stmt
+      (namespace_use_declaration (namespace_use_clause (qualified_name) @from alias: (name) @alias)) @stmt
+      (namespace_use_declaration (namespace_use_clause (qualified_name) @from !alias)) @stmt
+      (namespace_use_declaration (namespace_use_clause (name) @from alias: (name) @alias)) @stmt
+      (namespace_use_declaration (namespace_use_clause (name) @from !alias)) @stmt
+      (namespace_use_declaration (namespace_name) @from (namespace_use_group)) @stmt
+    `;
 var PHP_DEF = {
   id: "php",
   extensions: [".php", ".phtml", ".php4", ".php8"],
@@ -849,13 +1680,11 @@ var PHP_DEF = {
     comments: ["comment"]
   },
   graph: {
-    imports: `
-      (require_expression) @stmt
-      (include_expression) @stmt
-      (require_once_expression) @stmt
-      (include_once_expression) @stmt
-      (namespace_use_declaration) @stmt
-    `,
+    // Path-bearing nodes: include/require argument, `use Foo\Bar` qualified_name.
+    // Grouped `use Foo\{A}` has no single node for `Foo\A` (prefix + clause); the
+    // prefix is `@from`. Concatenated includes (`__DIR__ . "/x"`) capture the
+    // expression. PHP has no star-import token, so there is no `@wild`.
+    imports: PHP_IMPORT_QUERY,
     exports: `
       (namespace_definition name: (namespace_name) @name)
       (class_declaration name: (name) @name)
@@ -877,73 +1706,77 @@ var PHP_DEF = {
       (const_declaration (const_element . (name) @name))
       (property_element name: (variable_name) @name)
     `,
-    importBindings: `
-      (require_expression) @stmt
-      (include_expression) @stmt
-      (require_once_expression) @stmt
-      (include_once_expression) @stmt
-      (namespace_use_declaration) @stmt
-  `
+    importBindings: PHP_IMPORT_QUERY
   },
   nodeTypes: {
     identifier: ["name", "variable_name", "namespace_name", "qualified_name", "relative_name"],
     propertyIdentifier: ["name"],
     memberExpression: "member_access_expression"
   },
-  classifyDefinition: (node) => {
-    const parentType = node.parent?.type;
-    if (parentType === "class_declaration")
-      return "class";
-    if (parentType === "interface_declaration")
-      return "interface";
-    if (parentType === "trait_declaration")
-      return "trait";
-    if (parentType === "enum_declaration")
-      return "type";
-    if (parentType === "enum_case")
-      return "constant";
-    if (parentType === "function_definition")
-      return "function";
-    if (parentType === "method_declaration")
-      return "method";
-    if (parentType === "namespace_definition")
-      return "namespace";
-    if (parentType === "const_element" || parentType === "const_declaration") {
-      return "constant";
-    }
-    return "variable";
-  },
+  classifyDefinition: classifyByParentType({
+    class_declaration: "class",
+    interface_declaration: "interface",
+    trait_declaration: "trait",
+    enum_declaration: "type",
+    enum_case: "constant",
+    function_definition: "function",
+    method_declaration: "method",
+    namespace_definition: "namespace",
+    const_element: "constant",
+    const_declaration: "constant"
+  }),
   normalizeIdentifier: (name) => name.replace(/^\$/, ""),
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return false;
-    const nameFieldOwnerTypes = /* @__PURE__ */ new Set([
-      "namespace_definition",
-      "class_declaration",
-      "interface_declaration",
-      "trait_declaration",
-      "enum_declaration",
-      "enum_case",
-      "function_definition",
-      "method_declaration"
-    ]);
-    if (nameFieldOwnerTypes.has(parent.type)) {
-      return parent.childForFieldName("name")?.id === node.id;
-    }
-    if (parent.type === "property_element") {
-      return parent.childForFieldName("name")?.id === node.id;
-    }
-    return parent.type === "const_element" && parent.namedChildren[0]?.id === node.id && node.type === "name";
-  },
+  isDeclarationName: (node) => isNameFieldOnParent(node, [
+    "namespace_definition",
+    "class_declaration",
+    "interface_declaration",
+    "trait_declaration",
+    "enum_declaration",
+    "enum_case",
+    "function_definition",
+    "method_declaration",
+    // `property_element` exposes the declared name via the `name` field and any
+    // initializer via `default_value`; field identity keeps a default value that
+    // happens to be a bare variable reference from being misread as a declaration.
+    "property_element"
+  ]) || // `const_element` has no named fields (grammar: `seq($.name, '=', $.expression)`),
+  // so the declared name is identified positionally as the first namedChild; a
+  // value that is itself a bare `name` reference (e.g. `const X = SOME_CONST;`)
+  // is the second namedChild and must not qualify.
+  node.parent?.type === "const_element" && node.parent.namedChildren[0]?.id === node.id && node.type === "name",
   scopeDeclarationNames: (node) => node.type === "variable_name" && node.parent?.type === "property_element",
   createsFunctionScope: (node) => node.type === "function_definition" || node.type === "method_declaration",
-  membersAreImplicitlyInScope: false,
+  // PHP `if`/`while`/function bodies are all `compound_statement`; without a block scope a
+  // nested declaration leaks into the enclosing scope.
+  createsBlockScope: (node) => node.type === "compound_statement",
+  // The exports query anchors unanchored, so a `function_definition` nested inside another
+  // function's `compound_statement` would otherwise publish as a module export.
+  exportScopeBlockers: ["compound_statement"],
   supportsCrossModuleSymbols: true
 };
 registerLanguage(PHP_DEF);
 
+// dist/languages/graph-captures.js
+var GRAPH_IMPORT_REQUIRED_CAPTURES = ["stmt", "from"];
+var GRAPH_IMPORT_OPTIONAL_CAPTURES = ["alias", "wild", "iname", "def", "ns", "type_kw"];
+var GRAPH_IMPORT_CAPTURES = [...GRAPH_IMPORT_REQUIRED_CAPTURES, ...GRAPH_IMPORT_OPTIONAL_CAPTURES];
+function graphCapture(name) {
+  return `@${name}`;
+}
+
 // dist/languages/definitions/html.js
+function htmlAssetImportQuery(valueCapture) {
+  const value = graphCapture(valueCapture);
+  const stmt4 = graphCapture("stmt");
+  return `
+      (script_element (start_tag (attribute (attribute_name) @attr (#match? @attr "^(?i)src$") (quoted_attribute_value (attribute_value) ${value})))) ${stmt4}
+      ((element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)href$") (quoted_attribute_value (attribute_value) ${value})))) ${stmt4} (#match? @tag "^(?i)(link|a)$"))
+      ((element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)href$") (quoted_attribute_value (attribute_value) ${value})))) ${stmt4} (#match? @tag "^(?i)(link|a)$"))
+      ((element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)src$") (quoted_attribute_value (attribute_value) ${value})))) ${stmt4} (#match? @tag "^(?i)img$"))
+      ((element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)src$") (quoted_attribute_value (attribute_value) ${value})))) ${stmt4} (#match? @tag "^(?i)img$"))
+    `;
+}
+var htmlAssetImports = htmlAssetImportQuery("from");
 var HTML_DEF = {
   id: "html",
   extensions: [".html", ".htm", ".xhtml"],
@@ -961,24 +1794,12 @@ var HTML_DEF = {
     comments: ["comment"]
   },
   graph: {
-    imports: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#match? @attr "^(?i)src$") (quoted_attribute_value (attribute_value) @mod)))) @stmt
-      ((element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)href$") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#match? @tag "^(?i)(link|a)$"))
-      ((element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)href$") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#match? @tag "^(?i)(link|a)$"))
-      ((element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)src$") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#match? @tag "^(?i)img$"))
-      ((element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)src$") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#match? @tag "^(?i)img$"))
-    `,
+    imports: htmlAssetImports,
     exports: "",
     locals: `
       (attribute (attribute_name) @attr (#match? @attr "^(?i)id$") (quoted_attribute_value (attribute_value) @name))
     `,
-    importBindings: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#match? @attr "^(?i)src$") (quoted_attribute_value (attribute_value) @from)))) @stmt
-      ((element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)href$") (quoted_attribute_value (attribute_value) @from)))) @stmt (#match? @tag "^(?i)(link|a)$"))
-      ((element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)href$") (quoted_attribute_value (attribute_value) @from)))) @stmt (#match? @tag "^(?i)(link|a)$"))
-      ((element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)src$") (quoted_attribute_value (attribute_value) @from)))) @stmt (#match? @tag "^(?i)img$"))
-      ((element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#match? @attr "^(?i)src$") (quoted_attribute_value (attribute_value) @from)))) @stmt (#match? @tag "^(?i)img$"))
-    `
+    importBindings: htmlAssetImports
   },
   nodeTypes: {
     identifier: ["attribute_value", "tag_name"]
@@ -1033,6 +1854,15 @@ var ADOC_DEF = htmlStubLanguage("adoc", [".adoc", ".asciidoc"]);
 registerLanguage(ADOC_DEF);
 
 // dist/languages/definitions/css-like.js
+var from = graphCapture("from");
+var stmt = graphCapture("stmt");
+var cssLikeImportQuery = `
+      (import_statement (string_value) ${from}) ${stmt}
+    `;
+var cssLikeLocalsQuery = `
+      (class_selector (class_name) @name)
+      (id_selector (id_name) @name)
+    `;
 function cssLikeStructure() {
   return {
     blocks: [
@@ -1046,17 +1876,10 @@ function cssLikeStructure() {
 }
 function cssLikeGraph() {
   return {
-    imports: `
-      (import_statement (string_value) @mod) @stmt
-    `,
+    imports: cssLikeImportQuery,
     exports: "",
-    locals: `
-      (class_selector (class_name) @name)
-      (id_selector (id_name) @name)
-    `,
-    importBindings: `
-      (import_statement (string_value) @from) @stmt
-    `
+    locals: cssLikeLocalsQuery,
+    importBindings: cssLikeImportQuery
   };
 }
 function cssLikeNodeTypes() {
@@ -1076,6 +1899,22 @@ var CSS_DEF = {
 registerLanguage(CSS_DEF);
 
 // dist/languages/definitions/scss.js
+var from2 = graphCapture("from");
+var stmt2 = graphCapture("stmt");
+var cssGraph = cssLikeGraph();
+var sassImportQueries = `
+      (import_statement (_ (string_value) ${from2})) ${stmt2}
+      (use_statement (string_value) ${from2}) ${stmt2}
+      (use_statement (_ (string_value) ${from2})) ${stmt2}
+      (forward_statement (string_value) ${from2}) ${stmt2}
+      (forward_statement (_ (string_value) ${from2})) ${stmt2}
+    `;
+var sassLocalQueries = `
+      (mixin_statement name: (identifier) @name)
+      (function_statement name: (identifier) @name)
+      ((declaration (property_name) @name) (#match? @name "^[$]"))
+      (selectors (placeholder (identifier) @name))
+    `;
 var SCSS_DEF = {
   id: "scss",
   extensions: [".scss"],
@@ -1092,46 +1931,30 @@ var SCSS_DEF = {
     comments: ["comment", "js_comment"]
   },
   graph: {
-    imports: `
-      (import_statement (string_value) @mod) @stmt
-      (import_statement (_ (string_value) @mod)) @stmt
-      (use_statement (string_value) @mod) @stmt
-      (use_statement (_ (string_value) @mod)) @stmt
-      (forward_statement (string_value) @mod) @stmt
-      (forward_statement (_ (string_value) @mod)) @stmt
-    `,
+    imports: `${cssGraph.imports}${sassImportQueries}`,
     exports: `
       (stylesheet (mixin_statement name: (identifier) @name))
       (stylesheet (function_statement name: (identifier) @name))
       ((stylesheet (declaration (property_name) @name)) (#match? @name "^[$]"))
       (stylesheet (rule_set (selectors (placeholder (identifier) @name))))
     `,
-    locals: `
-      (mixin_statement name: (identifier) @name)
-      (function_statement name: (identifier) @name)
-      ((declaration (property_name) @name) (#match? @name "^[$]"))
-      (placeholder (identifier) @name)
-      (class_selector (class_name) @name)
-      (id_selector (id_name) @name)
-    `,
-    importBindings: `
-      (import_statement (string_value) @from) @stmt
-      (import_statement (_ (string_value) @from)) @stmt
-      (use_statement (string_value) @from) @stmt
-      (use_statement (_ (string_value) @from)) @stmt
-      (forward_statement (string_value) @from) @stmt
-      (forward_statement (_ (string_value) @from)) @stmt
-    `
+    locals: `${sassLocalQueries}${cssGraph.locals}`,
+    importBindings: `${cssGraph.importBindings}${sassImportQueries}`
   },
   nodeTypes: {
     identifier: ["identifier", "variable", "class_name", "id_name", "property_name"]
   },
-  classifyDefinition: (node) => {
-    const parent = node.parent?.type;
-    if (parent === "mixin_statement" || parent === "function_statement")
-      return "function";
-    return "variable";
-  }
+  classifyDefinition: classifyByParentType({
+    mixin_statement: "function",
+    function_statement: "function"
+  }),
+  isDeclarationName: (node) => isNameFieldOnParent(node, ["mixin_statement", "function_statement"]) || node.parent?.type === "declaration" && node.type === "property_name" && node.text.startsWith("$") || // A placeholder in a selector list is a declaration. `@extend %name` is a use;
+  // the pinned grammar currently wraps that form in ERROR rather than extend_statement.
+  node.parent?.type === "placeholder" && node.parent.parent?.type === "selectors" || matchesParentTypePairs(node, [
+    ["class_selector", "class_name"],
+    ["id_selector", "id_name"]
+  ]),
+  scopeDeclarationNames: "all"
 };
 registerLanguage(SCSS_DEF);
 
@@ -1145,6 +1968,21 @@ var LESS_DEF = {
 };
 registerLanguage(LESS_DEF);
 
+// dist/languages/definitions/sfc-graph.js
+var from3 = graphCapture("from");
+var stmt3 = graphCapture("stmt");
+var sfcExternalScriptQuery = `
+      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) ${from3})))) ${stmt3}
+    `;
+function sfcExternalScriptGraph() {
+  return {
+    imports: sfcExternalScriptQuery,
+    exports: "",
+    locals: "",
+    importBindings: sfcExternalScriptQuery
+  };
+}
+
 // dist/languages/definitions/vue.js
 var VUE_DEF = {
   id: "vue",
@@ -1155,19 +1993,10 @@ var VUE_DEF = {
       { type: "script_element", captureId: "script" },
       { type: "style_element", captureId: "style" }
     ],
-    splitPoints: ["template_element", "script_element", "style_element"],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt
-    `,
-    exports: "",
-    locals: "",
-    importBindings: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt
-    `
+    splitPoints: ["template_element", "script_element", "style_element"],
+    comments: ["comment"]
   },
+  graph: sfcExternalScriptGraph(),
   nodeTypes: {
     identifier: ["attribute_value"]
   }
@@ -1187,16 +2016,7 @@ var SVELTE_DEF = {
     splitPoints: ["script_element", "style_element"],
     comments: ["comment"]
   },
-  graph: {
-    imports: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt
-    `,
-    exports: "",
-    locals: "",
-    importBindings: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt
-    `
-  },
+  graph: sfcExternalScriptGraph(),
   nodeTypes: {
     identifier: ["attribute_value"]
   }
@@ -1206,6 +2026,7 @@ registerLanguage(SVELTE_DEF);
 // dist/languages/definitions/ruby.js
 var RUBY_DEF = {
   id: "ruby",
+  usesQueryDrivenLocals: true,
   extensions: [".rb", ".rbw", ".rake", ".gemspec"],
   structure: {
     blocks: [
@@ -1235,7 +2056,7 @@ var RUBY_DEF = {
   },
   graph: {
     imports: `
-      (call method: (identifier) @method arguments: (argument_list (string (string_content) @mod)) (#match? @method "^(require|require_relative|load|autoload)$")) @stmt
+      (call method: (identifier) @method arguments: (argument_list (string (string_content) @from)) (#match? @method "^(require|require_relative|load|autoload)$")) @stmt
     `,
     exports: `
       (class name: [(constant) (scope_resolution)] @name)
@@ -1261,7 +2082,16 @@ var RUBY_DEF = {
     memberExpression: "call"
   },
   supportsCrossModuleSymbols: true,
+  membersAreImplicitlyInScope: true,
+  // Query-driven locals capture the declared name inside a `class`, `module`, `method`, or
+  // `singleton_method`, so classification must read the parent type the same way the scope
+  // walker's structural handling does.
   classifyDefinition: (node) => {
+    const parentType = node.parent?.type;
+    if (parentType === "class" || parentType === "module")
+      return "class";
+    if (parentType === "method" || parentType === "singleton_method")
+      return "method";
     const assignment = node.parent;
     const value = assignment?.childForFieldName("right");
     if (assignment?.type === "assignment" && assignment.childForFieldName("left")?.id === node.id && value?.type === "call" && value.childForFieldName("receiver")?.text === "Struct" && value.childForFieldName("method")?.text === "new") {
@@ -1272,22 +2102,7 @@ var RUBY_DEF = {
   scopeDeclarationNames: (node) => node.type === "constant" && node.parent?.type === "assignment",
   createsFunctionScope: (node) => node.type === "method" || node.type === "singleton_method",
   createsBlockScope: (node) => node.type === "do_block" || node.type === "block",
-  isDeclarationName: (node) => {
-    const p = node.parent;
-    if (!p)
-      return false;
-    if (p.type === "class" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "module" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "method" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "singleton_method" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "assignment" && p.childForFieldName("left")?.id === node.id)
-      return true;
-    return false;
-  }
+  isDeclarationName: (node) => isNameFieldOnParent(node, ["class", "module", "method", "singleton_method"]) || isNameFieldOnParent(node, ["assignment"], "left")
 };
 registerLanguage(RUBY_DEF);
 
@@ -1325,7 +2140,7 @@ var GO_DEF = {
   },
   graph: {
     imports: `
-      (import_spec path: (interpreted_string_literal) @mod) @stmt
+      (import_spec path: (interpreted_string_literal) @from) @stmt
     `,
     exports: `
       (function_declaration name: (identifier) @name)
@@ -1348,7 +2163,9 @@ var GO_DEF = {
       (range_clause left: (expression_list (identifier) @name) (#not-eq? @name "_"))
     `,
     importBindings: `
+      (import_spec name: (dot) @wild path: (interpreted_string_literal) @from) @stmt
       (import_spec name: (package_identifier) @alias path: (interpreted_string_literal) @from) @stmt
+      (import_spec name: (blank_identifier) @alias path: (interpreted_string_literal) @from) @stmt
       (import_spec path: (interpreted_string_literal) @from) @stmt
     `
   },
@@ -1357,52 +2174,33 @@ var GO_DEF = {
     memberExpression: "selector_expression"
   },
   supportsCrossModuleSymbols: true,
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "function_declaration" || parent.type === "method_declaration")
-      return "function";
-    if (parent.type === "type_spec" && parent.childForFieldName("name")?.id === node.id)
-      return "type";
-    if (parent.type === "type_parameter_declaration")
-      return "type";
-    return "variable";
-  },
-  createsFunctionScope: (node) => node.type === "function_declaration" || node.type === "method_declaration" || node.type === "func_literal",
-  createsBlockScope: (node) => node.type === "block" || node.type === "for_statement",
-  membersAreImplicitlyInScope: false,
-  isDeclarationName: (node) => {
-    const p = node.parent;
-    if (!p)
-      return false;
-    if (p.type === "function_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "method_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "type_spec" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if ((p.type === "var_spec" || p.type === "const_spec") && node.type === "identifier")
-      return true;
-    if (p.type === "type_parameter_declaration" && node.type === "identifier")
-      return true;
-    if (p.type === "expression_list" && p.parent?.type === "short_var_declaration")
-      return node.type === "identifier";
-    if (p.type === "expression_list" && p.parent?.type === "range_clause")
-      return node.type === "identifier" && node.text !== "_";
-    if (p.type === "parameter_declaration" || p.type === "variadic_parameter_declaration") {
-      return node.type === "identifier";
-    }
-    if (p.type === "field_declaration" && node.type === "field_identifier")
-      return true;
-    return false;
-  },
+  classifyDefinition: classifyByParentType({
+    function_declaration: "function",
+    method_declaration: "function",
+    type_spec: { kind: "type", nameField: "name" },
+    type_parameter_declaration: "type"
+  }),
+  createsFunctionScope: nodeTypeIn(["function_declaration", "method_declaration", "func_literal"]),
+  createsBlockScope: nodeTypeIn(["block", "for_statement"]),
+  isDeclarationName: (node) => isNameFieldOnParent(node, ["function_declaration", "method_declaration", "type_spec"]) || matchesParentTypePairs(node, [
+    ["var_spec", "identifier"],
+    ["const_spec", "identifier"],
+    ["type_parameter_declaration", "identifier"],
+    // Only parameter *names* — never type-position identifiers (e.g. builtin `int` or type param `T`).
+    ["parameter_declaration", "identifier"],
+    ["variadic_parameter_declaration", "identifier"],
+    ["field_declaration", "field_identifier"]
+  ]) || node.parent?.type === "expression_list" && node.parent.parent?.type === "short_var_declaration" && node.type === "identifier" || node.parent?.type === "expression_list" && node.parent.parent?.type === "range_clause" && node.type === "identifier" && node.text !== "_",
   scopeDeclarationNames: (node) => node.type === "field_identifier" && node.parent?.type === "field_declaration" || node.type === "identifier" && node.parent?.type === "expression_list" && node.parent.parent?.type === "range_clause"
 };
 registerLanguage(GO_DEF);
 
 // dist/languages/definitions/java.js
 var JAVA_IDENTIFIER_IGNORABLE_PATTERN = new RegExp(`[${JAVA_IDENTIFIER_IGNORABLE_SOURCE}]`, "gu");
+var JAVA_IMPORT_QUERY = `
+      (import_declaration (scoped_identifier) @from (asterisk)? @wild) @stmt
+      (import_declaration (identifier) @from (asterisk)? @wild) @stmt
+    `;
 var JAVA_DEF = {
   id: "java",
   extensions: [".java"],
@@ -1449,9 +2247,7 @@ var JAVA_DEF = {
     comments: ["line_comment", "block_comment"]
   },
   graph: {
-    imports: `
-      (import_declaration . (_) @mod) @stmt
-    `,
+    imports: JAVA_IMPORT_QUERY,
     exports: `
       (class_declaration name: (identifier) @name)
       (record_declaration name: (identifier) @name)
@@ -1475,58 +2271,40 @@ var JAVA_DEF = {
       (spread_parameter (variable_declarator name: (identifier) @name))
       (receiver_parameter (identifier) @name)
     `,
-    importBindings: `
-      (import_declaration . (_) @from) @stmt
-    `
+    importBindings: JAVA_IMPORT_QUERY
   },
   nodeTypes: {
     identifier: ["identifier", "type_identifier"],
     memberExpression: "field_access"
   },
   supportsCrossModuleSymbols: true,
+  membersAreImplicitlyInScope: true,
   exportScopeBlockers: ["block", "constructor_body"],
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "method_declaration" || parent.type === "constructor_declaration")
-      return "method";
-    if (parent.type === "class_declaration" || parent.type === "record_declaration")
-      return "class";
-    if (parent.type === "interface_declaration" || parent.type === "annotation_type_declaration")
-      return "interface";
-    if (parent.type === "enum_declaration")
-      return "type";
-    return "variable";
-  },
-  createsFunctionScope: (node) => node.type === "method_declaration" || node.type === "constructor_declaration",
-  createsBlockScope: (node) => node.type === "block" || node.type === "class_body",
-  isDeclarationName: (node) => {
-    const p = node.parent;
-    if (!p)
-      return false;
-    if (p.type === "class_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "record_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "interface_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "annotation_type_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_constant" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "method_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "variable_declarator" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "formal_parameter" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "receiver_parameter" && node.type === "identifier")
-      return true;
-    return false;
-  },
+  classifyDefinition: classifyByParentType({
+    method_declaration: "method",
+    constructor_declaration: "method",
+    class_declaration: "class",
+    record_declaration: "class",
+    interface_declaration: "interface",
+    annotation_type_declaration: "interface",
+    enum_declaration: "type"
+  }),
+  createsFunctionScope: nodeTypeIn(["method_declaration", "constructor_declaration"]),
+  createsBlockScope: nodeTypeIn(["block", "class_body"]),
+  isDeclarationName: (node) => isNameFieldOnParent(node, [
+    "class_declaration",
+    "record_declaration",
+    "interface_declaration",
+    "annotation_type_declaration",
+    "enum_declaration",
+    "enum_constant",
+    "method_declaration",
+    "constructor_declaration",
+    "variable_declarator",
+    "formal_parameter"
+  ]) || // `spread_parameter` (`int... rest`) has no `name` field; its declared name is the
+  // `variable_declarator` child, so that node is the declaration name.
+  node.type === "variable_declarator" && node.parent?.type === "spread_parameter" || node.parent?.type === "receiver_parameter" && node.type === "identifier",
   normalizeIdentifier: (name) => hasNonAsciiCodePoint(name, true) ? name.replace(JAVA_IDENTIFIER_IGNORABLE_PATTERN, "") : name
 };
 registerLanguage(JAVA_DEF);
@@ -1591,10 +2369,11 @@ var CSHARP_DEF = {
     comments: ["comment"]
   },
   graph: {
+    // Path node is `identifier` | `qualified_name` | `alias_qualified_name` (`global::System`).
+    // An identifier/qualified_name alternation misses `alias_qualified_name`, so keep `(_)`.
     imports: `
-      (using_directive !name (_) @mod) @stmt
-      (using_directive name: (identifier) (_) @mod) @stmt
-      (extern_alias_directive name: (identifier) @mod) @stmt
+      (using_directive !name (_) @from) @stmt
+      (using_directive name: (identifier) (_) @from) @stmt
     `,
     exports: `
       (class_declaration name: (identifier) @name)
@@ -1612,6 +2391,9 @@ var CSHARP_DEF = {
     locals: `
       (class_declaration name: (identifier) @name)
       (record_declaration name: (identifier) @name)
+      (record_declaration (parameter_list (parameter name: (identifier) @name)))
+      (method_declaration (parameter_list (parameter name: (identifier) @name)))
+      (constructor_declaration (parameter_list (parameter name: (identifier) @name)))
       (struct_declaration name: (identifier) @name)
       (interface_declaration name: (identifier) @name)
       (enum_declaration name: (identifier) @name)
@@ -1623,6 +2405,8 @@ var CSHARP_DEF = {
       (variable_declarator name: (identifier) @name)
       (declaration_pattern name: (identifier) @name)
     `,
+    // extern alias has no path node in the grammar, so there is no @from.
+    // using path node: identifier | qualified_name | alias_qualified_name — keep `(_)`.
     importBindings: `
       (using_directive name: (identifier) @alias (_) @from) @stmt
       (using_directive !name (_) @from) @stmt
@@ -1634,36 +2418,43 @@ var CSHARP_DEF = {
     memberExpression: "member_access_expression"
   },
   supportsCrossModuleSymbols: true,
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "method_declaration" || parent.type === "constructor_declaration" || parent.type === "destructor_declaration" || parent.type === "local_function_statement")
-      return "method";
-    if (parent.type === "class_declaration" || parent.type === "record_declaration" || parent.type === "struct_declaration")
-      return "class";
-    if (parent.type === "interface_declaration")
-      return "interface";
-    if (parent.type === "enum_declaration" || parent.type === "delegate_declaration")
-      return "type";
-    return "variable";
-  },
-  createsFunctionScope: (node) => node.type === "method_declaration" || node.type === "constructor_declaration" || node.type === "destructor_declaration" || node.type === "local_function_statement",
-  createsBlockScope: (node) => node.type === "block" || node.type === "declaration_list",
-  isDeclarationName: (node) => {
-    const p = node.parent;
-    if (!p)
-      return false;
-    if ((p.type === "class_declaration" || p.type === "record_declaration" || p.type === "struct_declaration" || p.type === "interface_declaration" || p.type === "enum_declaration" || p.type === "delegate_declaration" || p.type === "enum_member_declaration" || p.type === "method_declaration" || p.type === "constructor_declaration" || p.type === "destructor_declaration" || p.type === "local_function_statement" || p.type === "property_declaration") && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "variable_declarator" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "parameter" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "declaration_pattern" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    return false;
-  },
+  membersAreImplicitlyInScope: true,
+  classifyDefinition: classifyByParentType({
+    method_declaration: "method",
+    constructor_declaration: "method",
+    destructor_declaration: "method",
+    local_function_statement: "method",
+    class_declaration: "class",
+    record_declaration: "class",
+    struct_declaration: "class",
+    interface_declaration: "interface",
+    enum_declaration: "type",
+    delegate_declaration: "type"
+  }),
+  createsFunctionScope: nodeTypeIn([
+    "method_declaration",
+    "constructor_declaration",
+    "destructor_declaration",
+    "local_function_statement"
+  ]),
+  createsBlockScope: nodeTypeIn(["block", "declaration_list"]),
+  isDeclarationName: (node) => isNameFieldOnParent(node, [
+    "class_declaration",
+    "record_declaration",
+    "struct_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "delegate_declaration",
+    "enum_member_declaration",
+    "method_declaration",
+    "constructor_declaration",
+    "destructor_declaration",
+    "local_function_statement",
+    "property_declaration",
+    "variable_declarator",
+    "parameter",
+    "declaration_pattern"
+  ]),
   normalizeIdentifier: (name) => {
     const withoutVerbatimPrefix = name.startsWith("@") ? name.slice(1) : name;
     return hasNonAsciiCodePoint(withoutVerbatimPrefix) ? withoutVerbatimPrefix.replace(CSHARP_IDENTIFIER_FORMAT_PATTERN, "") : withoutVerbatimPrefix;
@@ -1714,9 +2505,9 @@ var RUST_DEF = {
   },
   graph: {
     imports: `
-      (mod_item name: (identifier) @mod) @stmt
-      (extern_crate_declaration name: (identifier) @mod) @stmt
-      (use_declaration argument: (_) @mod) @stmt
+      (mod_item name: (identifier) @from) @stmt
+      (extern_crate_declaration name: (identifier) @from) @stmt
+      (use_declaration argument: (_) @from) @stmt
     `,
     exports: `
       (function_item name: (identifier) @name) @stmt
@@ -1766,6 +2557,7 @@ var RUST_DEF = {
       (use_declaration argument: (use_as_clause path: (identifier) @from alias: (identifier) @alias)) @stmt
       (use_declaration argument: (use_as_clause path: (scoped_identifier path: (_) @from name: (identifier) @iname) alias: (identifier) @alias)) @stmt
       (use_declaration argument: (scoped_identifier path: (_) @from name: (identifier) @iname)) @stmt
+      (use_declaration argument: (use_wildcard) @from @wild) @stmt
       (use_declaration argument: (identifier) @from) @stmt
       (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (identifier) @iname))) @stmt
       ;; Aliased members inside a group (\`use foo::{Bar as Baz}\`): import
@@ -1780,53 +2572,31 @@ var RUST_DEF = {
   supportsCrossModuleSymbols: true,
   exportScopeBlockers: ["block"],
   scopeDeclarationNames: (node) => node.parent?.type === "macro_definition",
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "function_item" || parent.type === "function_signature_item" || parent.type === "macro_definition")
-      return "function";
-    if (parent.type === "enum_item" || parent.type === "type_item" || parent.type === "associated_type")
-      return "type";
-    if (parent.type === "struct_item" || parent.type === "trait_item")
-      return "class";
-    return "variable";
-  },
-  createsFunctionScope: (node) => node.type === "function_item",
-  createsBlockScope: (node) => node.type === "block",
-  membersAreImplicitlyInScope: false,
-  isDeclarationName: (node) => {
-    const p = node.parent;
-    if (!p)
-      return false;
-    if (p.type === "function_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "function_signature_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "struct_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "trait_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "type_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "associated_type" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_variant" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "const_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "static_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "macro_definition" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "let_declaration" && p.childForFieldName("pattern")?.id === node.id)
-      return true;
-    if (p.type === "parameter" && p.childForFieldName("pattern")?.id === node.id)
-      return true;
-    return false;
-  },
+  classifyDefinition: classifyByParentType({
+    function_item: "function",
+    function_signature_item: "function",
+    macro_definition: "function",
+    enum_item: "type",
+    type_item: "type",
+    associated_type: "type",
+    struct_item: "class",
+    trait_item: "class"
+  }),
+  createsFunctionScope: nodeTypeIn(["function_item"]),
+  createsBlockScope: nodeTypeIn(["block"]),
+  isDeclarationName: (node) => isNameFieldOnParent(node, [
+    "function_item",
+    "function_signature_item",
+    "struct_item",
+    "trait_item",
+    "type_item",
+    "associated_type",
+    "enum_item",
+    "enum_variant",
+    "const_item",
+    "static_item",
+    "macro_definition"
+  ]) || isNameFieldOnParent(node, ["let_declaration", "parameter"], "pattern"),
   normalizeIdentifier: (name) => hasNonAsciiCodePoint(name) ? name.normalize("NFC") : name
 };
 registerLanguage(RUST_DEF);
@@ -1848,12 +2618,7 @@ var cFamilyControlSplitPoints = [
   "switch_statement",
   "case_statement"
 ];
-var cFamilyIncludeImportsQuery = `
-      (preproc_include path: (string_literal) @mod) @stmt
-      (preproc_include path: (system_lib_string) @mod) @stmt
-      (preproc_include path: (identifier) @mod) @stmt
-    `;
-var cFamilyIncludeBindingsQuery = `
+var cFamilyIncludeQuery = `
       (preproc_include path: (string_literal) @from) @stmt
       (preproc_include path: (system_lib_string) @from) @stmt
       (preproc_include path: (identifier) @from) @stmt
@@ -1940,16 +2705,16 @@ function createCFamilyLanguageDefinition(options) {
       comments: ["comment"]
     },
     graph: {
-      imports: cFamilyIncludeImportsQuery,
+      imports: cFamilyIncludeQuery,
       exports: joinQueryPatterns([
         ...cFamilyCoreExportQueries(graphFunctionNameQuery),
-        ...options.extraExportQueries ?? []
+        ...options.extraSymbolQueries ?? []
       ]),
       locals: joinQueryPatterns([
         ...cFamilyCoreLocalQueries(graphFunctionNameQuery),
-        ...options.extraLocalQueries ?? []
+        ...options.extraSymbolQueries ?? []
       ]),
-      importBindings: cFamilyIncludeBindingsQuery
+      importBindings: cFamilyIncludeQuery
     },
     nodeTypes: options.nodeTypes,
     classifyDefinition: options.classifyDefinition,
@@ -1958,10 +2723,13 @@ function createCFamilyLanguageDefinition(options) {
     createsFunctionScope: options.createsFunctionScope,
     createsBlockScope: (node) => node.type === "compound_statement",
     supportsCrossModuleSymbols: true,
-    // A name declared inside a function body is not a module export. The exports query cannot
-    // anchor on `translation_unit` because include guards nest every header declaration.
-    exportScopeBlockers: ["compound_statement"],
-    usesQueryDrivenLocals: options.usesQueryDrivenLocals || false
+    // A name declared inside a function body or a class/struct/union body is not a module
+    // export. C and C++ spell that type body `field_declaration_list`, not `class_body`.
+    // The exports query cannot anchor on `translation_unit` because include guards nest
+    // every header declaration.
+    exportScopeBlockers: ["compound_statement", "field_declaration_list"],
+    usesQueryDrivenLocals: options.usesQueryDrivenLocals || false,
+    ...options.membersAreImplicitlyInScope !== void 0 ? { membersAreImplicitlyInScope: options.membersAreImplicitlyInScope } : {}
   };
 }
 function isWithin(node, ancestor) {
@@ -1988,6 +2756,29 @@ function findAncestor(node, types) {
 function isInParameterList(node) {
   return !!findAncestor(node, cFamilyParameterListTypes);
 }
+function isSpecifierNameField(node, specifierTypes) {
+  const parent = node.parent;
+  return !!parent && specifierTypes.includes(parent.type) && isInField(node, parent, "name");
+}
+function cFamilyIsDeclarationName(node) {
+  if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["parameter_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["field_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["init_declarator"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["type_definition"])))
+    return true;
+  if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["function_definition"])) && !isInParameterList(node))
+    return true;
+  if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["declaration"])) && !isInParameterList(node))
+    return true;
+  return isSpecifierNameField(node, ["enumerator", "preproc_def", "preproc_function_def"]);
+}
+function cFamilyContainerClassifyDefinition(node) {
+  const container = findAncestor(node, cFamilyContainerTypes);
+  if (container?.type === "function_definition")
+    return "function";
+  if (container?.type === "declaration" && isFunctionDeclarator(node))
+    return "function";
+  if (container?.type === "type_definition")
+    return "type";
+  return "variable";
+}
 function resolveDeclaratorRoot(ancestor) {
   let declaratorNode = ancestor.childForFieldName("declarator");
   if (!declaratorNode)
@@ -2040,13 +2831,7 @@ var C_DEF = createCFamilyLanguageDefinition({
     cFamilyBlock("preproc_def", "name: (identifier) @chunk.name", "macro"),
     cFamilyBlock("preproc_function_def", "name: (identifier) @chunk.name", "macro")
   ],
-  extraExportQueries: [
-    `(union_specifier name: (type_identifier) @name)`,
-    `(enumerator name: (identifier) @name)`,
-    `(preproc_def name: (identifier) @name)`,
-    `(preproc_function_def name: (identifier) @name)`
-  ],
-  extraLocalQueries: [
+  extraSymbolQueries: [
     `(union_specifier name: (type_identifier) @name)`,
     `(enumerator name: (identifier) @name)`,
     `(preproc_def name: (identifier) @name)`,
@@ -2067,45 +2852,22 @@ var C_DEF = createCFamilyLanguageDefinition({
       return "class";
     if (parent.type === "type_definition" && isInField(node, parent, "declarator"))
       return "type";
-    const container = findAncestor(node, cFamilyContainerTypes);
-    if (container?.type === "function_definition")
-      return "function";
-    if (container?.type === "declaration" && isFunctionDeclarator(node))
-      return "function";
-    if (container?.type === "type_definition")
-      return "type";
-    return "variable";
-  },
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return false;
-    if ((parent.type === "struct_specifier" || parent.type === "union_specifier" || parent.type === "enum_specifier") && isInField(node, parent, "name"))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["parameter_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["field_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["init_declarator"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["type_definition"])))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["function_definition"])) && !isInParameterList(node))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["declaration"])) && !isInParameterList(node))
-      return true;
-    if (parent.type === "enumerator" && isInField(node, parent, "name"))
-      return true;
-    if (parent.type === "preproc_def" && isInField(node, parent, "name"))
-      return true;
-    if (parent.type === "preproc_function_def" && isInField(node, parent, "name"))
-      return true;
-    return false;
+    return cFamilyContainerClassifyDefinition(node);
   },
-  createsFunctionScope: (node) => node.type === "function_definition"
+  isDeclarationName: (node) => isSpecifierNameField(node, ["struct_specifier", "union_specifier", "enum_specifier"]) || cFamilyIsDeclarationName(node),
+  createsFunctionScope: nodeTypeIn(["function_definition"])
 });
 registerLanguage(C_DEF);
 
 // dist/languages/definitions/cpp.js
 var CPP_DEF = createCFamilyLanguageDefinition({
   id: "cpp",
-  extensions: [".cc", ".cpp", ".cxx", ".c++", ".hpp", ".hh", ".hxx", ".ipp", ".tpp", ".inl"],
+  // Module-interface units use `.cppm`/`.ixx`/`.mxx` by convention; without them a declared
+  // `export module foo;` is never discovered, so a first-party `import foo;` stays external.
+  extensions: [".cc", ".cpp", ".cxx", ".c++", ".hpp", ".hh", ".hxx", ".ipp", ".tpp", ".inl", ".cppm", ".ixx", ".mxx"],
   includeFieldIdentifier: true,
   usesQueryDrivenLocals: true,
+  membersAreImplicitlyInScope: true,
   blocks: (functionNameQuery) => [
     cFamilyFunctionBlock(functionNameQuery),
     cFamilyTypeIdentifierBlock("class_specifier", "class"),
@@ -2116,25 +2878,9 @@ var CPP_DEF = createCFamilyLanguageDefinition({
     cFamilyBlock("type_definition", "declarator: (type_identifier) @chunk.name", "type")
   ],
   splitPoints: [...cFamilyControlSplitPoints, "try_statement", "catch_clause"],
-  extraExportQueries: [
-    `(class_specifier name: (type_identifier) @name)`,
-    `(class_specifier name: (template_type name: (type_identifier) @name))`,
-    `(union_specifier name: (type_identifier) @name)`,
-    `(enumerator name: (identifier) @name)`,
-    `(namespace_definition name: (namespace_identifier) @name)`,
-    `(namespace_definition name: (nested_namespace_specifier (namespace_identifier) @name))`,
-    `(alias_declaration name: (type_identifier) @name)`,
-    `(concept_definition name: (identifier) @name)`,
-    `(preproc_def name: (identifier) @name)`,
-    `(preproc_function_def name: (identifier) @name)`,
-    `(class_specifier body: (field_declaration_list (field_declaration declarator: (function_declarator declarator: (field_identifier) @name))))`,
-    `(class_specifier body: (field_declaration_list (field_declaration declarator: (reference_declarator (function_declarator declarator: (operator_name) @name)))))`,
-    `(class_specifier body: (field_declaration_list (declaration declarator: (function_declarator declarator: (destructor_name) @name))))`
-  ],
-  extraLocalQueries: [
+  extraSymbolQueries: [
     `(class_specifier name: (type_identifier) @name)`,
     `(class_specifier name: (template_type name: (type_identifier) @name))`,
-    `(enum_specifier name: (type_identifier) @name)`,
     `(union_specifier name: (type_identifier) @name)`,
     `(enumerator name: (identifier) @name)`,
     `(namespace_definition name: (namespace_identifier) @name)`,
@@ -2145,7 +2891,8 @@ var CPP_DEF = createCFamilyLanguageDefinition({
     `(preproc_function_def name: (identifier) @name)`,
     `(class_specifier body: (field_declaration_list (field_declaration declarator: (function_declarator declarator: (field_identifier) @name))))`,
     `(class_specifier body: (field_declaration_list (field_declaration declarator: (reference_declarator (function_declarator declarator: (operator_name) @name)))))`,
-    `(class_specifier body: (field_declaration_list (declaration declarator: (function_declarator declarator: (destructor_name) @name))))`
+    `(class_specifier body: (field_declaration_list (declaration declarator: (function_declarator declarator: (destructor_name) @name))))`,
+    `(module_declaration name: (module_name) @name)`
   ],
   nodeTypes: {
     identifier: ["identifier", "field_identifier", "type_identifier", "namespace_identifier"],
@@ -2158,27 +2905,32 @@ var CPP_DEF = createCFamilyLanguageDefinition({
       return "variable";
     if (parent.type === "enum_specifier")
       return "type";
-    if (parent.type === "class_specifier" || parent.type === "struct_specifier" || parent.type === "union_specifier" || parent.type === "namespace_definition" || parent.type === "nested_namespace_specifier")
+    if (parent.type === "class_specifier" || parent.type === "struct_specifier" || parent.type === "union_specifier" || parent.type === "namespace_definition" || parent.type === "nested_namespace_specifier" || parent.type === "module_declaration")
       return "class";
+    if (parent.type === "module_name") {
+      const moduleDeclaration = findAncestor(node, /* @__PURE__ */ new Set(["module_declaration"]));
+      if (moduleDeclaration)
+        return "class";
+    }
     if (parent.type === "alias_declaration" || parent.type === "type_definition" && isInField(node, parent, "declarator"))
       return "type";
-    const container = findAncestor(node, cFamilyContainerTypes);
-    if (container?.type === "function_definition")
-      return "function";
-    if (container?.type === "declaration" && isFunctionDeclarator(node))
-      return "function";
-    if (container?.type === "type_definition")
-      return "type";
-    return "variable";
+    return cFamilyContainerClassifyDefinition(node);
   },
   isDeclarationName: (node) => {
+    if (isSpecifierNameField(node, ["class_specifier", "struct_specifier", "union_specifier", "enum_specifier"]))
+      return true;
     const parent = node.parent;
     if (!parent)
       return false;
-    if ((parent.type === "class_specifier" || parent.type === "struct_specifier" || parent.type === "union_specifier" || parent.type === "enum_specifier") && isInField(node, parent, "name"))
-      return true;
     if (parent.type === "namespace_definition" && isInField(node, parent, "name"))
       return true;
+    if (parent.type === "module_declaration" && isInField(node, parent, "name"))
+      return true;
+    if (parent.type === "module_name") {
+      const moduleDeclaration = findAncestor(node, /* @__PURE__ */ new Set(["module_declaration"]));
+      if (moduleDeclaration && isInField(node, moduleDeclaration, "name"))
+        return true;
+    }
     if (parent.type === "nested_namespace_specifier") {
       const namespaceDefinition = findAncestor(node, /* @__PURE__ */ new Set(["namespace_definition"]));
       if (namespaceDefinition && isInField(node, namespaceDefinition, "name"))
@@ -2188,27 +2940,33 @@ var CPP_DEF = createCFamilyLanguageDefinition({
       return true;
     if (parent.type === "concept_definition" && isInField(node, parent, "name"))
       return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["parameter_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["field_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["init_declarator"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["type_definition"])))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["function_definition"])) && !isInParameterList(node))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["declaration"])) && !isInParameterList(node))
-      return true;
     if (parent.type === "qualified_identifier" && parent.parent?.type === "using_declaration" && isInField(node, parent, "name"))
       return true;
-    if (parent.type === "enumerator" && isInField(node, parent, "name"))
-      return true;
-    if (parent.type === "preproc_def" && isInField(node, parent, "name"))
-      return true;
-    if (parent.type === "preproc_function_def" && isInField(node, parent, "name"))
-      return true;
-    return false;
+    return cFamilyIsDeclarationName(node);
   },
-  createsFunctionScope: (node) => node.type === "function_definition" || node.type === "lambda_expression"
+  createsFunctionScope: nodeTypeIn(["function_definition", "lambda_expression"])
 });
+var cppModuleQuery = `
+      (import_declaration name: (module_name) @from) @stmt
+      (import_declaration header: (string_literal) @from) @stmt
+      (import_declaration header: (system_lib_string) @from) @stmt
+    `;
+CPP_DEF.graph.imports += cppModuleQuery;
+CPP_DEF.graph.importBindings += cppModuleQuery;
 registerLanguage(CPP_DEF);
 
 // dist/languages/definitions/kotlin.js
+var KOTLIN_DECLARATION_NAME_PARENT_TYPES = [
+  "class_declaration",
+  "object_declaration",
+  "function_declaration",
+  "type_alias",
+  "variable_declaration",
+  "parameter",
+  "class_parameter",
+  "enum_entry",
+  "type_parameter"
+];
 var KOTLIN_DEF = {
   id: "kotlin",
   extensions: [".kt", ".kts", ".ktm"],
@@ -2255,7 +3013,7 @@ var KOTLIN_DEF = {
   },
   graph: {
     imports: `
-      (import (qualified_identifier) @mod) @stmt
+      (import (qualified_identifier) @from) @stmt
     `,
     exports: `
       (source_file
@@ -2298,46 +3056,20 @@ var KOTLIN_DEF = {
     propertyIdentifier: ["identifier"],
     memberExpression: "navigation_expression"
   },
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "class_declaration" || parent.type === "object_declaration")
-      return "class";
-    if (parent.type === "function_declaration")
-      return "function";
-    if (parent.type === "type_alias")
-      return "type";
-    return "variable";
-  },
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return false;
-    if (parent.type === "class_declaration" && node.type === "identifier")
-      return true;
-    if (parent.type === "object_declaration" && node.type === "identifier")
-      return true;
-    if (parent.type === "function_declaration" && node.type === "identifier")
-      return true;
-    if (parent.type === "type_alias" && node.type === "identifier")
-      return true;
-    if (parent.type === "variable_declaration" && node.type === "identifier")
-      return true;
-    if (parent.type === "parameter" && node.type === "identifier")
-      return true;
-    if (parent.type === "class_parameter" && node.type === "identifier")
-      return true;
-    if (parent.type === "enum_entry" && node.type === "identifier")
-      return true;
-    if (parent.type === "type_parameter" && node.type === "identifier")
-      return true;
-    return false;
-  },
+  classifyDefinition: classifyByParentType({
+    class_declaration: "class",
+    object_declaration: "class",
+    function_declaration: "function",
+    type_alias: "type"
+  }),
+  // The Kotlin grammar exposes no `name` field on these declarations, so the declared
+  // name is identified by parent type with a plain `identifier` child.
+  isDeclarationName: (node) => node.type === "identifier" && hasParentType(node, KOTLIN_DECLARATION_NAME_PARENT_TYPES),
   scopeDeclarationNames: "all",
-  createsFunctionScope: (node) => node.type === "function_declaration" || node.type === "anonymous_function" || node.type === "lambda_literal",
-  createsBlockScope: (node) => node.type === "function_body" || node.type === "class_body" || node.type === "block" || node.type === "catch_block" || node.type === "finally_block",
+  createsFunctionScope: nodeTypeIn(["function_declaration", "anonymous_function", "lambda_literal"]),
+  createsBlockScope: nodeTypeIn(["function_body", "class_body", "block", "catch_block", "finally_block"]),
   supportsCrossModuleSymbols: true,
+  membersAreImplicitlyInScope: true,
   exportScopeBlockers: ["function_body", "lambda_literal", "anonymous_function"]
 };
 registerLanguage(KOTLIN_DEF);
@@ -2420,8 +3152,12 @@ var SWIFT_DEF = {
     comments: ["comment", "multiline_comment"]
   },
   graph: {
+    // Pinned tree-sitter-swift: the path is always one `identifier` node, including
+    // dotted paths (`Foundation.NSString`). Kind keywords (`class`, `struct`, `func`,
+    // `enum`, `typealias`) are anonymous. `simple_identifier` is not a child of
+    // `import_declaration` (Impossible pattern). No alias or wildcard node.
     imports: `
-      (import_declaration (identifier) @mod) @stmt
+      (import_declaration (identifier) @from) @stmt
     `,
     exports: `
       (source_file (class_declaration declaration_kind: "class" name: (_) @name))
@@ -2482,6 +3218,7 @@ var SWIFT_DEF = {
       (macro_declaration (simple_identifier) @name)
       (operator_declaration [(custom_operator) (simple_identifier) (bang)] @name)
     `,
+    // Same path node as `imports`; Swift has no import alias or star token.
     importBindings: `
       (import_declaration (identifier) @from) @stmt
     `
@@ -2513,19 +3250,20 @@ var SWIFT_DEF = {
     const parent = node.parent;
     if (!parent)
       return false;
-    if (parent.type === "class_declaration" && parent.childForFieldName("name")?.id === node.id)
+    if (isNameFieldOnParent(node, ["class_declaration"]))
       return true;
     if (parent.type === "user_type" && parent.parent?.type === "class_declaration" && parent.parent.childForFieldName("name")?.id === parent.id)
       return true;
-    if (parent.type === "protocol_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "enum_entry" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "function_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "typealias_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "associatedtype_declaration" && parent.childForFieldName("name")?.id === node.id)
+    if (isNameFieldOnParent(node, [
+      "protocol_declaration",
+      "enum_entry",
+      "function_declaration",
+      "typealias_declaration",
+      "associatedtype_declaration",
+      "parameter",
+      "protocol_function_declaration",
+      "protocol_property_declaration"
+    ]))
       return true;
     if (parent.type === "macro_declaration" && node.type === "simple_identifier")
       return true;
@@ -2537,20 +3275,25 @@ var SWIFT_DEF = {
       return true;
     if (parent.type === "subscript_declaration" && node.type === "subscript")
       return true;
-    if (parent.type === "parameter" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "protocol_function_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "protocol_property_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "pattern" && parent.childForFieldName("bound_identifier")?.id === node.id && (parent.parent?.type === "property_declaration" || parent.parent?.type === "protocol_property_declaration"))
-      return true;
-    return false;
+    return parent.type === "pattern" && parent.childForFieldName("bound_identifier")?.id === node.id && (parent.parent?.type === "property_declaration" || parent.parent?.type === "protocol_property_declaration");
   },
   scopeDeclarationNames: "all",
-  createsFunctionScope: (node) => node.type === "function_declaration" || node.type === "init_declaration" || node.type === "deinit_declaration" || node.type === "subscript_declaration",
-  createsBlockScope: (node) => node.type === "function_body" || node.type === "class_body" || node.type === "protocol_body" || node.type === "enum_class_body" || node.type === "catch_block" || node.type === "willset_didset_block",
+  createsFunctionScope: nodeTypeIn([
+    "function_declaration",
+    "init_declaration",
+    "deinit_declaration",
+    "subscript_declaration"
+  ]),
+  createsBlockScope: nodeTypeIn([
+    "function_body",
+    "class_body",
+    "protocol_body",
+    "enum_class_body",
+    "catch_block",
+    "willset_didset_block"
+  ]),
   supportsCrossModuleSymbols: true,
+  membersAreImplicitlyInScope: true,
   exportScopeBlockers: ["function_body", "lambda_literal"]
 };
 registerLanguage(SWIFT_DEF);
@@ -2580,6 +3323,7 @@ var SQL_DEF = {
     comments: ["comment"]
   },
   graph: {
+    // SQL has no import specifier node; statements are the only capture.
     imports: "(statement) @stmt",
     exports: "",
     locals: "",
@@ -2613,8 +3357,9 @@ var ZIG_DEF = {
   },
   graph: {
     imports: `
-      (builtin_function (builtin_identifier) @fn (arguments (string) @mod) (#eq? @fn "@import")) @stmt
-      (builtin_function (builtin_identifier) @mod (arguments) (#eq? @mod "@cImport")) @stmt
+      (builtin_function (builtin_identifier) @fn (arguments (string) @from) (#eq? @fn "@import")) @stmt
+      ;; @cImport has no path argument; the builtin identifier is the specifier.
+      (builtin_function (builtin_identifier) @from (arguments) (#eq? @from "@cImport")) @stmt
     `,
     exports: `
       (source_file (function_declaration name: (identifier) @name))
@@ -2670,19 +3415,13 @@ var ZIG_DEF = {
       return "type";
     return "variable";
   },
-  createsFunctionScope: (node) => node.type === "function_declaration",
-  createsBlockScope: (node) => node.type === "block",
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return false;
-    if (parent.type === "function_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type !== "variable_declaration")
-      return false;
-    const declaredName = parent.namedChildren.find((child) => child.type === "identifier");
-    return declaredName?.id === node.id;
-  }
+  createsFunctionScope: nodeTypeIn(["function_declaration"]),
+  createsBlockScope: nodeTypeIn(["block"]),
+  isDeclarationName: (node) => isNameFieldOnParent(node, ["function_declaration"]) || // No named field distinguishes the declared identifier from an initializer that is
+  // itself a bare identifier (e.g. `const x = y;` puts both `x` and `y` directly under
+  // `variable_declaration`); the declared name is always the first identifier child,
+  // matching the lookup classifyDefinition above already relies on.
+  node.parent?.type === "variable_declaration" && node.parent.namedChildren.find((child) => child.type === "identifier")?.id === node.id
 };
 registerLanguage(ZIG_DEF);
 
@@ -2784,112 +3523,6 @@ import { Buffer as Buffer2 } from "node:buffer";
 // dist/languages.js
 import fs from "node:fs";
 import path from "node:path";
-
-// dist/util/comments.js
-function transformJsLikeTrivia(src, options) {
-  let out = "";
-  let i = 0;
-  let inSingle = false;
-  let inDouble = false;
-  let inTemplate = false;
-  let escapeNext = false;
-  const maskStrings = options?.maskStrings ?? false;
-  const preserveLength = options?.preserveLength ?? false;
-  const maskedChar = (ch) => ch === "\n" || ch === "\r" ? ch : " ";
-  while (i < src.length) {
-    const ch = src[i];
-    const next = src[i + 1] ?? "";
-    if (inSingle || inDouble || inTemplate) {
-      const isClosingQuote = !escapeNext && (inSingle && ch === "'" || inDouble && ch === '"' || inTemplate && ch === "`");
-      if (maskStrings) {
-        out += isClosingQuote ? ch : maskedChar(ch);
-      } else {
-        out += ch;
-      }
-      if (escapeNext) {
-        escapeNext = false;
-      } else if (ch === "\\") {
-        escapeNext = true;
-      } else if (inSingle && ch === "'") {
-        inSingle = false;
-      } else if (inDouble && ch === '"') {
-        inDouble = false;
-      } else if (inTemplate && ch === "`") {
-        inTemplate = false;
-      }
-      i += 1;
-      continue;
-    }
-    if (ch === "'") {
-      inSingle = true;
-      out += ch;
-      i += 1;
-      continue;
-    }
-    if (ch === '"') {
-      inDouble = true;
-      out += ch;
-      i += 1;
-      continue;
-    }
-    if (ch === "`") {
-      inTemplate = true;
-      out += ch;
-      i += 1;
-      continue;
-    }
-    if (ch === "/" && next === "*") {
-      if (preserveLength)
-        out += "  ";
-      i += 2;
-      let depth = 1;
-      while (i < src.length && depth > 0) {
-        if (options?.nestedBlockComments && src[i] === "/" && src[i + 1] === "*") {
-          if (preserveLength)
-            out += "  ";
-          depth += 1;
-          i += 2;
-          continue;
-        }
-        if (src[i] === "*" && src[i + 1] === "/") {
-          if (preserveLength)
-            out += "  ";
-          depth -= 1;
-          i += 2;
-          continue;
-        }
-        if (preserveLength)
-          out += maskedChar(src[i]);
-        else if (src[i] === "\n")
-          out += "\n";
-        i += 1;
-      }
-      continue;
-    }
-    if (ch === "/" && next === "/") {
-      if (preserveLength)
-        out += "  ";
-      i += 2;
-      while (i < src.length && src[i] !== "\n") {
-        if (preserveLength)
-          out += " ";
-        i += 1;
-      }
-      continue;
-    }
-    out += ch;
-    i += 1;
-  }
-  return out;
-}
-function maskJsLikeCommentsAndStrings(src) {
-  return transformJsLikeTrivia(src, {
-    maskStrings: true,
-    preserveLength: true
-  });
-}
-
-// dist/languages.js
 function adaptDefinition(def) {
   return {
     id: def.id,
@@ -2901,7 +3534,7 @@ function adaptDefinition(def) {
     scopeDeclarationNames: def.scopeDeclarationNames === "all" ? () => true : def.scopeDeclarationNames ?? (() => false),
     createsBlockScope: def.createsBlockScope || (() => false),
     createsFunctionScope: def.createsFunctionScope || (() => false),
-    membersAreImplicitlyInScope: def.membersAreImplicitlyInScope ?? true,
+    membersAreImplicitlyInScope: def.membersAreImplicitlyInScope ?? false,
     supportsCrossModuleSymbols: def.supportsCrossModuleSymbols || false,
     isTypeOnly: def.isTypeOnly || (() => false),
     exportScopeBlockers: def.exportScopeBlockers ?? [],