@lzehrung/codegraph 2.3.24 → 2.3.25

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

@@ -192,7 +192,7 @@ var BASE_STRUCTURE = {
     },
     {
       type: "module",
-      nameQuery: "name: (identifier) @chunk.name body: (statement_block) @chunk.block.namespace",
+      nameQuery: "name: [ (identifier) (string) ] @chunk.name body: (statement_block) @chunk.block.namespace",
       captureId: "namespace"
     },
     // Data
@@ -220,19 +220,25 @@ var BASE_GRAPH = {
   exports: `
     (export_statement) @stmt
     (export_statement declaration: (function_declaration name: (identifier) @name)) @stmt
+    (export_statement declaration: (function_signature name: (identifier) @name)) @stmt
     (export_statement declaration: (generator_function_declaration name: (identifier) @name)) @stmt
     (export_statement declaration: (class_declaration name: (type_identifier) @name)) @stmt
     (export_statement declaration: (abstract_class_declaration name: (type_identifier) @name)) @stmt
     (export_statement declaration: (enum_declaration name: [ (identifier) (type_identifier) ] @name)) @stmt
+    (export_statement declaration: (internal_module name: (identifier) @name)) @stmt
+    (export_statement declaration: (module name: (identifier) @name)) @stmt
+    (export_statement declaration: (ambient_declaration (function_signature name: (identifier) @name))) @stmt
+    (export_statement declaration: (ambient_declaration (internal_module name: (identifier) @name))) @stmt
+    (export_statement declaration: (ambient_declaration (module name: (identifier) @name))) @stmt
     (export_statement declaration: (function_declaration) @anon_default) @stmt
     (export_statement declaration: (generator_function_declaration) @anon_default) @stmt
     (export_statement declaration: (class_declaration) @anon_default) @stmt
     (export_statement declaration: (abstract_class_declaration) @anon_default) @stmt
     (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name))) @stmt
-    (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias)) (string) @from) @stmt
-    (export_statement (export_clause (export_specifier name: (identifier) @src !alias)) (string) @from) @stmt
-    (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias))) @stmt
-    (export_statement (export_clause (export_specifier name: (identifier) @src !alias))) @stmt
+    (export_statement (export_clause (export_specifier "type"? @type_kw name: (identifier) @src alias: (identifier) @alias)) (string) @from) @stmt
+    (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 (string) @from) @stmt
     (export_assignment (identifier) @ts_export_assign)
   `,
@@ -242,20 +248,23 @@ var BASE_GRAPH = {
     (method_definition name: (property_identifier) @name)
     (method_signature name: (property_identifier) @name)
     (abstract_method_signature name: (property_identifier) @name)
+    (function_signature name: (identifier) @name)
     (class_declaration name: (type_identifier) @name)
     (abstract_class_declaration name: (type_identifier) @name)
     (variable_declarator name: (identifier) @name)
     (interface_declaration name: (type_identifier) @name)
     (type_alias_declaration name: (type_identifier) @name)
     (enum_declaration name: [ (identifier) (type_identifier) ] @name)
+    (internal_module name: (identifier) @name)
+    (module name: (identifier) @name)
   `,
   importBindings: `
     (import_statement) @stmt
     (import_statement (string) @from) @stmt
     (import_statement (import_require_clause (identifier) @def (string) @from)) @stmt
     (import_statement (import_clause (identifier) @def) (string) @from) @stmt
-    (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname alias: (identifier) @alias))) (string) @from) @stmt
-    (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname))) (string) @from) @stmt
+    (import_statement (import_clause (named_imports (import_specifier "type"? @type_kw name: (identifier) @iname alias: (identifier) @alias))) (string) @from) @stmt
+    (import_statement (import_clause (named_imports (import_specifier "type"? @type_kw name: (identifier) @iname !alias))) (string) @from) @stmt
     (import_statement (import_clause (namespace_import (identifier) @ns)) (string) @from) @stmt
   `
 };
@@ -278,6 +287,8 @@ var BASE_HELPERS = {
       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")
@@ -286,7 +297,7 @@ var BASE_HELPERS = {
       return "interface";
     if (t === "type_alias_declaration")
       return "type";
-    if (t === "enum_declaration")
+    if (t === "enum_declaration" || t === "internal_module" || t === "module")
       return "type";
     return "variable";
   },
@@ -301,6 +312,9 @@ var BASE_HELPERS = {
       "interface_declaration",
       "type_alias_declaration",
       "enum_declaration",
+      "function_signature",
+      "internal_module",
+      "module",
       "import_specifier",
       "namespace_import",
       "import_clause",
@@ -312,7 +326,14 @@ var BASE_HELPERS = {
       "abstract_method_signature"
     ].includes(p);
   },
-  createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body",
+  // 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.
+  scopeDeclarationNames: (node) => {
+    const parent = node.parent?.type;
+    return parent === "function_signature" || parent === "internal_module" || parent === "module";
+  },
+  createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body" || n.type === "class_static_block",
   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,
   supportsCrossModuleSymbols: true
@@ -358,17 +379,17 @@ registerLanguage(TSX_DEF);
 // dist/languages/definitions/javascript.js
 var JS_OBJECT_METHOD_EXPORT_PATTERN = `
       ;; CJS: module.exports = { helper () {} }
-      (expression_statement (assignment_expression
+      ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
         right: (object (pair key: (property_identifier) @cjs_export_name value: (function_declaration) @cjs_fn))))
-        (#eq? @mod "module") (#eq? @prop "exports")
+        (#eq? @mod "module") (#eq? @prop "exports"))
 `;
 var JS_OBJECT_METHOD_EXPORT_NATIVE_PATTERN = `
       ;; CJS: module.exports = { helper () {} }
-      (expression_statement (assignment_expression
+      ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
         right: (object (method_definition name: (property_identifier) @cjs_export_name) @cjs_fn)))
-        (#eq? @mod "module") (#eq? @prop "exports")
+        (#eq? @mod "module") (#eq? @prop "exports"))
 `;
 var JAVASCRIPT_DEF = {
   id: "js",
@@ -401,58 +422,63 @@ var JAVASCRIPT_DEF = {
       (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias)))
       (export_statement (export_clause (export_specifier name: (identifier) @src !alias)))
       (export_statement (string) @from)
-      (expression_statement (assignment_expression
+      ;; CJS whole-module export: module.exports = function () {} / = () => {}
+      ((expression_statement (assignment_expression
+        left: (member_expression object: (identifier) @mod property: (property_identifier) @cjs_export_name)
+        right: [ (function) (arrow_function) ] @cjs_fn))
+        (#eq? @mod "module") (#eq? @cjs_export_name "exports"))
+      ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
         right: (object (shorthand_property_identifier) @cjs_shorthand)))
-        (#eq? @mod "module") (#eq? @prop "exports")
+        (#eq? @mod "module") (#eq? @prop "exports"))
       ;; CJS spread export: module.exports = { ...base }
       ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
         right: (object (spread_element (identifier) @cjs_spread))) @stmt)
         (#eq? @mod "module") (#eq? @prop "exports"))
-      (expression_statement (assignment_expression
+      ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
         right: (object (pair key: (property_identifier) @cjs_export_name value: (identifier) @cjs_local))))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      (expression_statement (assignment_expression
+        (#eq? @mod "module") (#eq? @prop "exports"))
+      ((expression_statement (assignment_expression
         left: (member_expression object: (member_expression object: (identifier) @mod property: (property_identifier) @prop) property: (property_identifier) @cjs_export_name)
         right: (identifier) @cjs_local))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      (expression_statement (assignment_expression
+        (#eq? @mod "module") (#eq? @prop "exports"))
+      ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @exp property: (property_identifier) @cjs_export_name)
         right: (identifier) @cjs_local))
-        (#eq? @exp "exports")
+        (#eq? @exp "exports"))
       ;; CJS function/arrow direct exports
-      (expression_statement (assignment_expression
+      ((expression_statement (assignment_expression
         left: (member_expression object: (member_expression object: (identifier) @mod property: (property_identifier) @prop) property: (property_identifier) @cjs_export_name)
         right: (function) @cjs_fn))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      (expression_statement (assignment_expression
+        (#eq? @mod "module") (#eq? @prop "exports"))
+      ((expression_statement (assignment_expression
         left: (member_expression object: (member_expression object: (identifier) @mod property: (property_identifier) @prop) property: (property_identifier) @cjs_export_name)
         right: (arrow_function) @cjs_fn))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      (expression_statement (assignment_expression
+        (#eq? @mod "module") (#eq? @prop "exports"))
+      ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @exp property: (property_identifier) @cjs_export_name)
         right: (function) @cjs_fn))
-        (#eq? @exp "exports")
-      (expression_statement (assignment_expression
+        (#eq? @exp "exports"))
+      ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @exp property: (property_identifier) @cjs_export_name)
         right: (arrow_function) @cjs_fn))
-        (#eq? @exp "exports")
+        (#eq? @exp "exports"))
       ;; CJS object export with function value
-      (expression_statement (assignment_expression
+      ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
         right: (object (pair key: (property_identifier) @cjs_export_name value: (function) @cjs_fn))))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      (expression_statement (assignment_expression
+        (#eq? @mod "module") (#eq? @prop "exports"))
+      ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
         right: (object (pair key: (property_identifier) @cjs_export_name value: (arrow_function) @cjs_fn))))
-        (#eq? @mod "module") (#eq? @prop "exports")
+        (#eq? @mod "module") (#eq? @prop "exports"))
       ;; CJS: module.exports = { helper () {} }
-      (expression_statement (assignment_expression
+      ((expression_statement (assignment_expression
         left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
         right: (object (pair key: (property_identifier) @cjs_export_name value: (function_declaration) @cjs_fn))))
-        (#eq? @mod "module") (#eq? @prop "exports")
+        (#eq? @mod "module") (#eq? @prop "exports"))
     `,
     locals: `
       (function_declaration name: (identifier) @name)
@@ -466,10 +492,12 @@ var JAVASCRIPT_DEF = {
       (import_statement (string) @from) @stmt
       (import_statement (import_clause (identifier) @def) (string) @from) @stmt
       (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname alias: (identifier) @alias))) (string) @from) @stmt
-      (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname))) (string) @from) @stmt
+      (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname !alias))) (string) @from) @stmt
       (import_statement (import_clause (namespace_import (identifier) @ns)) (string) @from) @stmt
-      (lexical_declaration (variable_declarator name:(identifier) @def value: (call_expression (identifier) @req arguments: (arguments (string) @from)))) (#eq? @req "require")
-      (lexical_declaration (variable_declarator (object_pattern) @pattern value: (call_expression (identifier) @req arguments: (arguments (string) @from)))) (#eq? @req "require")
+      ((lexical_declaration (variable_declarator name:(identifier) @def value: (call_expression (identifier) @req arguments: (arguments (string) @from))))
+        (#eq? @req "require"))
+      ((lexical_declaration (variable_declarator (object_pattern) @pattern value: (call_expression (identifier) @req arguments: (arguments (string) @from))))
+        (#eq? @req "require"))
     `
   },
   nodeTypes: {
@@ -486,6 +514,8 @@ var JAVASCRIPT_DEF = {
       return "function";
     if (t === "method_definition")
       return "function";
+    if (t === "function" || t === "function_expression")
+      return "function";
     if (t === "class_declaration")
       return "class";
     return "variable";
@@ -502,10 +532,19 @@ var JAVASCRIPT_DEF = {
       "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"
+      "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);
   },
-  createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body",
+  // 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,
   supportsCrossModuleSymbols: true,
@@ -538,9 +577,24 @@ var GO_IDENTIFIER_SOURCE = String.raw`[\p{L}_][\p{L}\p{Nd}_]*`;
 var KOTLIN_IDENTIFIER_SOURCE = String.raw`[\p{L}_][\p{L}\p{Nd}_]*`;
 
 // dist/languages/definitions/python.js
+function isTypeAliasLeftName(node) {
+  const parent = node.parent;
+  if (!parent)
+    return false;
+  if (parent.type === "type") {
+    const stmt = parent.parent;
+    return stmt?.type === "type_alias_statement" && stmt.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;
+  }
+  return false;
+}
 var PYTHON_DEF = {
   id: "python",
-  extensions: [".py", ".pyi"],
+  extensions: [".py", ".pyi", ".pyw"],
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -564,9 +618,14 @@ var PYTHON_DEF = {
       // Top level assignments
       {
         type: "assignment",
-        nameQuery: "left: (identifier) @chunk.name",
+        nameQuery: "left: [(identifier) @chunk.name (pattern_list (identifier) @chunk.name) (tuple_pattern (identifier) @chunk.name)]",
         captureId: "module_var"
       },
+      {
+        type: "type_alias_statement",
+        nameQuery: "left: (type [(identifier) @chunk.name (generic_type (identifier) @chunk.name)])",
+        captureId: "type"
+      },
       // Imports
       { type: "import_statement", captureId: "imports" },
       { type: "import_from_statement", captureId: "imports" }
@@ -593,35 +652,60 @@ var PYTHON_DEF = {
     // This is a known limitation - such patterns are rare in practice.
     exports: `
       ;; __all__ = ["a", "b"] - simple list assignment
-      (assignment left: (identifier) @left right: (list (string)+ @all_item)) @stmt
+      (module (expression_statement (assignment left: (identifier) @left right: (list (string) @all_item)) @stmt))
       ;; __all__ = ("a", "b") - tuple assignment
-      (assignment left: (identifier) @left right: (tuple (string)+ @all_item)) @stmt
+      (module (expression_statement (assignment left: (identifier) @left right: (tuple (string) @all_item)) @stmt))
       ;; __all__ = ["a"] + ["b"] - concatenation (captures strings in both sides)
-      (assignment left: (identifier) @left right: (binary_operator (list (string)+ @all_item))) @stmt
-      (assignment left: (identifier) @left right: (binary_operator right: (list (string)+ @all_item))) @stmt
+      (module (expression_statement (assignment left: (identifier) @left right: (binary_operator (list (string) @all_item))) @stmt))
+      (module (expression_statement (assignment left: (identifier) @left right: (binary_operator right: (list (string) @all_item))) @stmt))
       ;; __all__.extend(["a"]) - extend pattern
-      (expression_statement (call function: (attribute object: (identifier) @left attribute: (identifier) @method) arguments: (argument_list (list (string)+ @all_item)))) @stmt
+      (module (expression_statement (call function: (attribute object: (identifier) @left attribute: (identifier) @method) arguments: (argument_list (list (string) @all_item)))) @stmt)
       ;; __all__.append("a") - append pattern
-      (expression_statement (call function: (attribute object: (identifier) @left attribute: (identifier) @method) arguments: (argument_list (string) @all_item))) @stmt
+      (module (expression_statement (call function: (attribute object: (identifier) @left attribute: (identifier) @method) arguments: (argument_list (string) @all_item))) @stmt)
       ;; __all__ += ["a"] - augmented assignment
-      (augmented_assignment left: (identifier) @left right: (list (string)+ @all_item)) @stmt
-      (function_definition name: (identifier) @name)
-      (class_definition name: (identifier) @name)
-      (assignment left: (identifier) @name)
+      (module (expression_statement (augmented_assignment left: (identifier) @left right: (list (string) @all_item)) @stmt))
+      ;; An empty static list or tuple still defines an explicit export set.
+      (module (expression_statement (assignment left: (identifier) @left right: [(list) (tuple)]) @stmt))
+      (module (function_definition name: (identifier) @name))
+      (module (class_definition name: (identifier) @name))
+      (module (decorated_definition (function_definition name: (identifier) @name)))
+      (module (decorated_definition (class_definition name: (identifier) @name)))
+      (module (expression_statement (assignment left: (identifier) @name)))
+      (module (expression_statement (assignment left: [(pattern_list (identifier) @name) (tuple_pattern (identifier) @name)])))
+      (module (expression_statement (named_expression name: (identifier) @name)))
+      (module (type_alias_statement left: (type [(identifier) @name (generic_type (identifier) @name)])))
+      (class_definition body: (block (function_definition name: (identifier) @name)))
+      (class_definition body: (block (class_definition name: (identifier) @name)))
+      (class_definition body: (block (decorated_definition (function_definition name: (identifier) @name))))
+      (class_definition body: (block (decorated_definition (class_definition name: (identifier) @name))))
+      (class_definition body: (block (expression_statement (assignment left: (identifier) @name))))
+      (class_definition body: (block (expression_statement (assignment left: [(pattern_list (identifier) @name) (tuple_pattern (identifier) @name)]))))
+      (class_definition body: (block (expression_statement (named_expression name: (identifier) @name))))
+      (class_definition body: (block (type_alias_statement left: (type [(identifier) @name (generic_type (identifier) @name)]))))
     `,
     locals: `
       (function_definition name: (identifier) @name)
       (class_definition name: (identifier) @name)
       (assignment left: (identifier) @name)
-      ;; \`case Point(x=x, y=y):\` binds the right-hand identifier of a keyword
-      ;; pattern as a new local, distinct from the left-hand attribute name it
-      ;; matches against.
+      (assignment left: [(pattern_list (identifier) @name) (tuple_pattern (identifier) @name)])
+      (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 ->
+      ;; case_pattern -> keyword_pattern. The binding is the dotted_name child;
+      ;; the left-hand attribute is a bare identifier and must not be captured.
+      ;; Anchoring to the first and last (named) child restricts the match to a
+      ;; single-segment dotted_name, so a qualified value like \`x=module.CONST\`
+      ;; does not create locals for \`module\` or \`CONST\`.
+      (keyword_pattern (dotted_name . (identifier) @name .))
       ;; A bare identifier in a case pattern is represented as a single-name
       ;; dotted_name inside a case_pattern. Nested tuple/list/or patterns
-      ;; preserve this shape for each capture.
-      (case_pattern (dotted_name (identifier) @name))
+      ;; preserve this shape for each capture. The same anchor keeps a qualified
+      ;; value pattern such as \`case module.CONST:\` from creating locals.
+      (case_pattern (dotted_name . (identifier) @name .))
       ;; \`case value as alias:\` binds the direct identifier child as its alias.
-      (as_pattern (identifier) @name)
+      ;; \`except E as err\` / \`with ctx as handle\` put the binding in alias.
+      (as_pattern !alias (identifier) @name)
+      (as_pattern alias: (as_pattern_target (identifier) @name))
       ;; \`case [head, *tail]:\` binds the capture after the splat.
       (splat_pattern (identifier) @name)
     `,
@@ -642,27 +726,39 @@ var PYTHON_DEF = {
       return "function";
     if (t === "class_definition")
       return "class";
+    if (isTypeAliasLeftName(n))
+      return "type";
     return "variable";
   },
   scopeDeclarationNames: (node) => {
     const parentType = node.parent?.type;
-    return parentType === "case_pattern" || parentType === "as_pattern" || parentType === "splat_pattern" || parentType === "dotted_name";
+    return parentType === "case_pattern" || parentType === "as_pattern" || parentType === "as_pattern_target" || parentType === "splat_pattern" || parentType === "dotted_name" || parentType === "named_expression" || parentType === "pattern_list" || parentType === "tuple_pattern" || parentType === "type" || parentType === "generic_type";
   },
   isDeclarationName: (node) => {
     const parent = node.parent;
     const t = parent?.type;
     if (t === "dotted_name" && parent && parent.namedChildren.length === 1 && (parent.parent?.type === "keyword_pattern" || parent.parent?.type === "case_pattern"))
       return true;
-    if (parent?.type === "as_pattern")
+    if (t === "as_pattern_target")
       return true;
+    if (t === "as_pattern")
+      return parent?.childForFieldName("alias") == null;
     if (t === "splat_pattern")
       return true;
+    if (t === "named_expression")
+      return parent?.childForFieldName("name")?.id === node.id;
+    if (t === "pattern_list" || t === "tuple_pattern")
+      return true;
+    if (isTypeAliasLeftName(node))
+      return true;
     return !!t && ["function_definition", "class_definition", "assignment", "aliased_import"].includes(t);
   },
   createsBlockScope: (n) => n.type === "module" || n.type === "block",
   createsFunctionScope: (n) => n.type === "function_definition" || n.type === "lambda",
   membersAreImplicitlyInScope: false,
   supportsCrossModuleSymbols: true,
+  // A function body and a class body are both `block`, so only the function form blocks exports.
+  exportScopeBlockers: ["function_definition>block"],
   normalizeIdentifier: (name) => hasNonAsciiCodePoint(name) ? name.normalize("NFKC") : name
 };
 registerLanguage(PYTHON_DEF);
@@ -670,7 +766,7 @@ registerLanguage(PYTHON_DEF);
 // dist/languages/definitions/php.js
 var PHP_DEF = {
   id: "php",
-  extensions: [".php"],
+  extensions: [".php", ".phtml", ".php4", ".php8"],
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -824,12 +920,12 @@ registerLanguage(PHP_DEF);
 // dist/languages/definitions/html.js
 var HTML_DEF = {
   id: "html",
-  extensions: [".html", ".htm"],
+  extensions: [".html", ".htm", ".xhtml"],
   structure: {
     blocks: [
       {
         type: "element",
-        nameQuery: `(start_tag (attribute (attribute_name) @attr (#eq? @attr "id") (quoted_attribute_value (attribute_value) @chunk.name)))`,
+        nameQuery: `(start_tag (attribute (attribute_name) @attr (#match? @attr "^(?i)id$") (quoted_attribute_value (attribute_value) @chunk.name)))`,
         captureId: "element"
       },
       { type: "script_element", captureId: "script" },
@@ -840,22 +936,22 @@ var HTML_DEF = {
   },
   graph: {
     imports: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt
-      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#match? @tag "^(link|a)$")
-      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#match? @tag "^(link|a)$")
-      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#eq? @tag "img")
-      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#eq? @tag "img")
+      (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$"))
     `,
     exports: "",
     locals: `
-      (attribute (attribute_name) @attr (#eq? @attr "id") (quoted_attribute_value (attribute_value) @name))
+      (attribute (attribute_name) @attr (#match? @attr "^(?i)id$") (quoted_attribute_value (attribute_value) @name))
     `,
     importBindings: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt
-      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @from)))) @stmt (#match? @tag "^(link|a)$")
-      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @from)))) @stmt (#match? @tag "^(link|a)$")
-      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt (#eq? @tag "img")
-      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt (#eq? @tag "img")
+      (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$"))
     `
   },
   nodeTypes: {
@@ -954,16 +1050,10 @@ var CSS_DEF = {
 registerLanguage(CSS_DEF);
 
 // dist/languages/definitions/scss.js
-var SCSS_SYMBOL_QUERY_PATTERNS = [
-  "(mixin_statement (name) @name)",
-  "(function_statement (name) @name)",
-  "(variable_declaration (variable) @name)",
-  "(class_selector (class_name) @name)",
-  "(id_selector (id_name) @name)"
-];
 var SCSS_DEF = {
   id: "scss",
   extensions: [".scss"],
+  usesQueryDrivenLocals: true,
   structure: {
     blocks: [
       { type: "rule_set", captureId: "rule" },
@@ -978,33 +1068,43 @@ var SCSS_DEF = {
   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
     `,
     exports: `
-      (mixin_statement (name) @name)
-      (function_statement (name) @name)
-      (variable_declaration (variable) @name)
+      (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) @name)
-      (function_statement (name) @name)
-      (variable_declaration (variable) @name)
+      (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
     `
   },
   nodeTypes: {
-    identifier: ["name", "variable", "class_name", "id_name"]
+    identifier: ["identifier", "variable", "class_name", "id_name", "property_name"]
   },
-  native: {
-    normalizeQuery: (_kind, query) => SCSS_SYMBOL_QUERY_PATTERNS.some((pattern) => query.includes(pattern)) ? "" : query,
-    notes: ["skips unsupported SCSS symbol queries in the native runtime"]
+  classifyDefinition: (node) => {
+    const parent = node.parent?.type;
+    if (parent === "mixin_statement" || parent === "function_statement")
+      return "function";
+    return "variable";
   }
 };
 registerLanguage(SCSS_DEF);
@@ -1080,17 +1180,17 @@ registerLanguage(SVELTE_DEF);
 // dist/languages/definitions/ruby.js
 var RUBY_DEF = {
   id: "ruby",
-  extensions: [".rb"],
+  extensions: [".rb", ".rbw", ".rake", ".gemspec"],
   structure: {
     blocks: [
       {
         type: "class",
-        nameQuery: "name: (constant) @chunk.name",
+        nameQuery: "name: [(constant) (scope_resolution)] @chunk.name",
         captureId: "class"
       },
       {
         type: "module",
-        nameQuery: "name: (constant) @chunk.name",
+        nameQuery: "name: [(constant) (scope_resolution)] @chunk.name",
         captureId: "module"
       },
       {
@@ -1109,23 +1209,25 @@ var RUBY_DEF = {
   },
   graph: {
     imports: `
-      (call method: (identifier) @method arguments: (argument_list (string (string_content) @mod)) (#match? @method "^(require|require_relative)$")) @stmt
+      (call method: (identifier) @method arguments: (argument_list (string (string_content) @mod)) (#match? @method "^(require|require_relative|load|autoload)$")) @stmt
     `,
     exports: `
-      (class name: (constant) @name)
-      (module name: (constant) @name)
-      (method name: (identifier) @name)
+      (class name: [(constant) (scope_resolution)] @name)
+      (module name: [(constant) (scope_resolution)] @name)
+      (method name: [(identifier) (setter)] @name)
+      (singleton_method name: [(identifier) (setter)] @name)
       (assignment left: (constant) @name)
     `,
     locals: `
-      (class name: (constant) @name)
-      (module name: (constant) @name)
-      (method name: (identifier) @name)
+      (class name: [(constant) (scope_resolution)] @name)
+      (module name: [(constant) (scope_resolution)] @name)
+      (method name: [(identifier) (setter)] @name)
+      (singleton_method name: [(identifier) (setter)] @name)
       (assignment left: (identifier) @name)
       (assignment left: (constant) @name)
     `,
     importBindings: `
-      ((call method: (identifier) @method arguments: (argument_list (string (string_content) @from))) @stmt (#match? @method "^(require|require_relative)$"))
+      ((call method: (identifier) @method arguments: (argument_list (string (string_content) @from))) @stmt (#match? @method "^(require|require_relative|load|autoload)$"))
     `
   },
   nodeTypes: {
@@ -1202,9 +1304,9 @@ var GO_DEF = {
     exports: `
       (function_declaration name: (identifier) @name)
       (method_declaration name: (field_identifier) @name)
-      (type_spec name: (type_identifier) @name)
-      (const_spec name: (identifier) @name)
-      (var_spec name: (identifier) @name)
+      (source_file (type_declaration (type_spec name: (type_identifier) @name)))
+      (source_file (const_declaration (const_spec (identifier) @name)))
+      (source_file (var_declaration (var_spec (identifier) @name)))
     `,
     locals: `
       (function_declaration name: (identifier) @name)
@@ -1212,9 +1314,10 @@ var GO_DEF = {
       (type_spec name: (type_identifier) @name)
       (parameter_declaration name: (identifier) @name)
       (variadic_parameter_declaration name: (identifier) @name)
+      (type_parameter_declaration name: (identifier) @name)
       (short_var_declaration left: (expression_list (identifier) @name))
-      (var_spec name: (identifier) @name)
-      (const_spec name: (identifier) @name)
+      (var_spec (identifier) @name)
+      (const_spec (identifier) @name)
       (type_spec type: (struct_type (field_declaration_list (field_declaration name: (field_identifier) @name))))
       (range_clause left: (expression_list (identifier) @name) (#not-eq? @name "_"))
     `,
@@ -1236,6 +1339,8 @@ var GO_DEF = {
       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",
@@ -1251,9 +1356,9 @@ var GO_DEF = {
       return true;
     if (p.type === "type_spec" && p.childForFieldName("name")?.id === node.id)
       return true;
-    if (p.type === "var_spec" && p.childForFieldName("name")?.id === node.id)
+    if ((p.type === "var_spec" || p.type === "const_spec") && node.type === "identifier")
       return true;
-    if (p.type === "const_spec" && p.childForFieldName("name")?.id === node.id)
+    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";
@@ -1340,6 +1445,9 @@ var JAVA_DEF = {
       (enum_constant name: (identifier) @name)
       (method_declaration name: (identifier) @name)
       (variable_declarator name: (identifier) @name)
+      (formal_parameter name: (identifier) @name)
+      (spread_parameter (variable_declarator name: (identifier) @name))
+      (receiver_parameter (identifier) @name)
     `,
     importBindings: `
       (import_declaration . (_) @from) @stmt
@@ -1350,6 +1458,7 @@ var JAVA_DEF = {
     memberExpression: "field_access"
   },
   supportsCrossModuleSymbols: true,
+  exportScopeBlockers: ["block", "constructor_body"],
   classifyDefinition: (node) => {
     const parent = node.parent;
     if (!parent)
@@ -1388,6 +1497,8 @@ var JAVA_DEF = {
       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;
   },
   normalizeIdentifier: (name) => hasNonAsciiCodePoint(name, true) ? name.replace(JAVA_IDENTIFIER_IGNORABLE_PATTERN, "") : name
@@ -1398,7 +1509,7 @@ registerLanguage(JAVA_DEF);
 var CSHARP_IDENTIFIER_FORMAT_PATTERN = new RegExp(`[${CSHARP_IDENTIFIER_FORMAT_SOURCE}]`, "gu");
 var CSHARP_DEF = {
   id: "csharp",
-  extensions: [".cs"],
+  extensions: [".cs", ".csx"],
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -1407,6 +1518,11 @@ var CSHARP_DEF = {
         nameQuery: "name: (identifier) @chunk.name",
         captureId: "class"
       },
+      {
+        type: "struct_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "struct"
+      },
       {
         type: "record_declaration",
         nameQuery: "name: (identifier) @chunk.name",
@@ -1431,6 +1547,11 @@ var CSHARP_DEF = {
         type: "namespace_declaration",
         nameQuery: "name: (identifier) @chunk.name",
         captureId: "namespace"
+      },
+      {
+        type: "file_scoped_namespace_declaration",
+        nameQuery: "name: (identifier) @chunk.name",
+        captureId: "namespace"
       }
     ],
     splitPoints: [
@@ -1445,30 +1566,41 @@ var CSHARP_DEF = {
   },
   graph: {
     imports: `
-      (using_directive . (_) @mod) @stmt
+      (using_directive !name (_) @mod) @stmt
+      (using_directive name: (identifier) (_) @mod) @stmt
+      (extern_alias_directive name: (identifier) @mod) @stmt
     `,
     exports: `
       (class_declaration name: (identifier) @name)
       (record_declaration name: (identifier) @name)
+      (struct_declaration name: (identifier) @name)
       (interface_declaration name: (identifier) @name)
       (enum_declaration name: (identifier) @name)
       (enum_member_declaration name: (identifier) @name)
       (method_declaration name: (identifier) @name)
+      (delegate_declaration name: (identifier) @name)
       (property_declaration name: (identifier) @name)
+      (field_declaration (variable_declaration (variable_declarator name: (identifier) @name)))
+      (event_field_declaration (variable_declaration (variable_declarator name: (identifier) @name)))
     `,
     locals: `
       (class_declaration name: (identifier) @name)
       (record_declaration name: (identifier) @name)
+      (struct_declaration name: (identifier) @name)
       (interface_declaration name: (identifier) @name)
       (enum_declaration name: (identifier) @name)
       (enum_member_declaration name: (identifier) @name)
       (method_declaration name: (identifier) @name)
-      (variable_declarator (identifier) @name)
+      (delegate_declaration name: (identifier) @name)
+      (local_function_statement name: (identifier) @name)
+      (property_declaration name: (identifier) @name)
+      (variable_declarator name: (identifier) @name)
       (declaration_pattern name: (identifier) @name)
     `,
     importBindings: `
-      (using_directive name: (identifier) @alias . (_) @from) @stmt
-      (using_directive . (_) @from) @stmt
+      (using_directive name: (identifier) @alias (_) @from) @stmt
+      (using_directive !name (_) @from) @stmt
+      (extern_alias_directive name: (identifier) @alias) @stmt
     `
   },
   nodeTypes: {
@@ -1480,35 +1612,25 @@ var CSHARP_DEF = {
     const parent = node.parent;
     if (!parent)
       return "variable";
-    if (parent.type === "method_declaration" || parent.type === "constructor_declaration")
+    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")
+    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")
+    if (parent.type === "enum_declaration" || parent.type === "delegate_declaration")
       return "type";
     return "variable";
   },
-  createsFunctionScope: (node) => node.type === "method_declaration" || node.type === "constructor_declaration",
+  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.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)
+    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 === "enum_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_member_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 === "variable_declarator" && p.child(0)?.id === node.id)
+    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;
@@ -1572,8 +1694,11 @@ var RUST_DEF = {
     `,
     exports: `
       (function_item name: (identifier) @name) @stmt
+      (function_signature_item name: (identifier) @name) @stmt
       (struct_item name: (type_identifier) @name) @stmt
       (trait_item name: (type_identifier) @name) @stmt
+      (type_item name: (type_identifier) @name) @stmt
+      (associated_type name: (type_identifier) @name) @stmt
       (enum_item name: (type_identifier) @name) @stmt
       (enum_variant name: (identifier) @name) @stmt
       (const_item name: (identifier) @name) @stmt
@@ -1587,14 +1712,19 @@ var RUST_DEF = {
       ;; form above. The shared path may itself be scoped, so it is captured
       ;; generically rather than requiring a single bare identifier segment.
       (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (identifier) @src))) @stmt
-      ;; Aliased members inside a group (\`use foo::{Bar as Baz}\`) export
-      ;; under their alias, matching how a single aliased import behaves.
-      (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (use_as_clause alias: (identifier) @src)))) @stmt
+      ;; Aliased members (\`use foo::Bar as Baz;\` and \`use foo::{Bar as Baz}\`) export under the
+      ;; alias while keeping the original member as the source, so a consumer of the alias
+      ;; resolves to the real definition.
+      (use_declaration argument: (use_as_clause path: (scoped_identifier path: (_) @from name: (identifier) @src) alias: (identifier) @alias)) @stmt
+      (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (use_as_clause path: (identifier) @src alias: (identifier) @alias)))) @stmt
     `,
     locals: `
       (function_item name: (identifier) @name)
+      (function_signature_item name: (identifier) @name)
       (struct_item name: (type_identifier) @name)
       (trait_item name: (type_identifier) @name)
+      (type_item name: (type_identifier) @name)
+      (associated_type name: (type_identifier) @name)
       (enum_item name: (type_identifier) @name)
       (enum_variant name: (identifier) @name)
       (const_item name: (identifier) @name)
@@ -1622,14 +1752,15 @@ var RUST_DEF = {
     memberExpression: "field_expression"
   },
   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 === "macro_definition")
+    if (parent.type === "function_item" || parent.type === "function_signature_item" || parent.type === "macro_definition")
       return "function";
-    if (parent.type === "enum_item")
+    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";
@@ -1644,10 +1775,16 @@ var RUST_DEF = {
       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)
@@ -1705,6 +1842,9 @@ function cFunctionNameQuery(captureName, includeFieldIdentifier) {
     patterns.push(`(pointer_declarator declarator: (function_declarator declarator: (${identifierType}) @${captureName}))`);
     patterns.push(`(function_declarator declarator: (parenthesized_declarator (pointer_declarator declarator: (${identifierType}) @${captureName})))`);
   }
+  if (includeFieldIdentifier) {
+    patterns.push(`(function_declarator declarator: (qualified_identifier name: (identifier) @${captureName}))`, `(function_declarator declarator: (qualified_identifier name: (destructor_name) @${captureName}))`, `(function_declarator declarator: (qualified_identifier name: (operator_name) @${captureName}))`, `(function_declarator declarator: (qualified_identifier name: (template_function name: (identifier) @${captureName})))`, `(function_declarator declarator: (destructor_name) @${captureName})`, `(function_declarator declarator: (operator_name) @${captureName})`, `(reference_declarator (function_declarator declarator: (qualified_identifier name: (identifier) @${captureName})))`, `(reference_declarator (function_declarator declarator: (qualified_identifier name: (destructor_name) @${captureName})))`, `(reference_declarator (function_declarator declarator: (qualified_identifier name: (operator_name) @${captureName})))`, `(reference_declarator (function_declarator declarator: (operator_name) @${captureName}))`);
+  }
   return `
   declarator: [
     ${patterns.join("\n    ")}
@@ -1713,21 +1853,31 @@ function cFunctionNameQuery(captureName, includeFieldIdentifier) {
 }
 function cFamilyCoreExportQueries(functionNameQuery) {
   return [
-    `(function_definition ${functionNameQuery})`,
-    `(declaration ${functionNameQuery})`,
+    // Keep scope/storage evidence even when the native syntax-tree projection is unavailable.
+    `(compound_statement) @export_scope`,
+    `((declaration (storage_class_specifier) @storage) @private_declaration (#eq? @storage "static"))`,
+    `((function_definition (storage_class_specifier) @storage) @private_declaration (#eq? @storage "static"))`,
+    `(function_definition ${functionNameQuery}) @declaration`,
+    `(declaration ${functionNameQuery}) @declaration`,
     `(struct_specifier name: (type_identifier) @name)`,
     `(enum_specifier name: (type_identifier) @name)`,
-    `(type_definition declarator: (type_identifier) @name)`,
-    `(declaration declarator: (identifier) @name)`,
-    `(declaration declarator: (init_declarator declarator: (identifier) @name))`
+    `(type_definition declarator: (_) @declarator)`,
+    `((declaration type: (_) @type declarator: (identifier) @name) @declaration
+      (#not-match? @type "^(import|export)$"))`,
+    `((declaration type: (_) @type declarator: (init_declarator declarator: (identifier) @name)) @declaration
+      (#not-match? @type "^(import|export)$"))`
   ];
 }
 function cFamilyCoreLocalQueries(functionNameQuery) {
   return [
     `(function_definition ${functionNameQuery})`,
+    // A prototype is a `declaration`, not a `function_definition`; without this a header that only
+    // declares its API has no function locals at all.
+    `(declaration ${functionNameQuery})`,
     `(struct_specifier name: (type_identifier) @name)`,
     `(enum_specifier name: (type_identifier) @name)`,
-    `(type_definition declarator: (type_identifier) @name)`,
+    // Resolve the declarator chain in the consumer, without a fixed pointer/array depth.
+    `(type_definition declarator: (_) @declarator)`,
     `(declaration declarator: (identifier) @name)`,
     `(declaration declarator: (init_declarator declarator: (identifier) @name))`,
     `(parameter_declaration declarator: (identifier) @name)`,
@@ -1782,6 +1932,9 @@ 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
   };
 }
@@ -1851,6 +2004,7 @@ var C_DEF = createCFamilyLanguageDefinition({
   id: "c",
   extensions: [".c", ".h", ".i"],
   includeFieldIdentifier: false,
+  usesQueryDrivenLocals: true,
   blocks: (functionNameQuery) => [
     cFamilyFunctionBlock(functionNameQuery),
     cFamilyTypeIdentifierBlock("struct_specifier", "struct"),
@@ -1892,6 +2046,8 @@ var C_DEF = createCFamilyLanguageDefinition({
       return "function";
     if (container?.type === "declaration" && isFunctionDeclarator(node))
       return "function";
+    if (container?.type === "type_definition")
+      return "type";
     return "variable";
   },
   isDeclarationName: (node) => {
@@ -1936,16 +2092,34 @@ var CPP_DEF = createCFamilyLanguageDefinition({
   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)`,
-    `(using_declaration (qualified_identifier name: (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: [
     `(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)`,
-    `(alias_declaration name: (type_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))))`
   ],
   nodeTypes: {
     identifier: ["identifier", "field_identifier", "type_identifier", "namespace_identifier"],
@@ -1958,7 +2132,7 @@ var CPP_DEF = createCFamilyLanguageDefinition({
       return "variable";
     if (parent.type === "enum_specifier")
       return "type";
-    if (parent.type === "class_specifier" || parent.type === "struct_specifier" || parent.type === "namespace_definition")
+    if (parent.type === "class_specifier" || parent.type === "struct_specifier" || parent.type === "union_specifier" || parent.type === "namespace_definition" || parent.type === "nested_namespace_specifier")
       return "class";
     if (parent.type === "alias_declaration" || parent.type === "type_definition" && isInField(node, parent, "declarator"))
       return "type";
@@ -1967,18 +2141,27 @@ var CPP_DEF = createCFamilyLanguageDefinition({
       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 === "class_specifier" || parent.type === "struct_specifier" || parent.type === "enum_specifier") && isInField(node, parent, "name"))
+    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 === "nested_namespace_specifier") {
+      const namespaceDefinition = findAncestor(node, /* @__PURE__ */ new Set(["namespace_definition"]));
+      if (namespaceDefinition && isInField(node, namespaceDefinition, "name"))
+        return true;
+    }
     if (parent.type === "alias_declaration" && isInField(node, parent, "name"))
       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))
@@ -1989,6 +2172,10 @@ var CPP_DEF = createCFamilyLanguageDefinition({
       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;
   },
   createsFunctionScope: (node) => node.type === "function_definition" || node.type === "lambda_expression"
@@ -1996,51 +2183,35 @@ var CPP_DEF = createCFamilyLanguageDefinition({
 registerLanguage(CPP_DEF);
 
 // dist/languages/definitions/kotlin.js
-function normalizeKotlinNativeQuery(kind, query) {
-  if (kind === "imports") {
-    return `
-      (import (qualified_identifier) @mod) @stmt
-    `;
-  }
-  if (kind === "importBindings") {
-    return `
-      (import (qualified_identifier) @from (identifier) @alias) @stmt
-      (import (qualified_identifier) @from "*" @wild) @stmt
-      (import (qualified_identifier) @from) @stmt
-    `;
-  }
-  const normalized = query.replace(/\bimport_header\b/g, "import").replace(/\bsimple_identifier\b/g, "identifier").replace(/\btype_identifier\b/g, "identifier");
-  return normalized;
-}
 var KOTLIN_DEF = {
   id: "kotlin",
-  extensions: [".kt", ".kts"],
+  extensions: [".kt", ".kts", ".ktm"],
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
       {
         type: "class_declaration",
-        nameQuery: "(type_identifier) @chunk.name",
+        nameQuery: "(identifier) @chunk.name",
         captureId: "class"
       },
       {
         type: "object_declaration",
-        nameQuery: "(type_identifier) @chunk.name",
+        nameQuery: "(identifier) @chunk.name",
         captureId: "object"
       },
       {
         type: "function_declaration",
-        nameQuery: "(simple_identifier) @chunk.name",
+        nameQuery: "(identifier) @chunk.name",
         captureId: "function"
       },
       {
         type: "property_declaration",
-        nameQuery: "(variable_declaration (simple_identifier) @chunk.name)",
+        nameQuery: "(variable_declaration (identifier) @chunk.name)",
         captureId: "property"
       },
       {
         type: "type_alias",
-        nameQuery: "(type_identifier) @chunk.name",
+        nameQuery: "(identifier) @chunk.name",
         captureId: "type"
       }
     ],
@@ -2058,36 +2229,47 @@ var KOTLIN_DEF = {
   },
   graph: {
     imports: `
-      (import_header (identifier) @mod) @stmt
+      (import (qualified_identifier) @mod) @stmt
     `,
     exports: `
-      (class_declaration (type_identifier) @name)
-      (object_declaration (type_identifier) @name)
-      (function_declaration (simple_identifier) @name)
-      (property_declaration (variable_declaration (simple_identifier) @name))
-      (type_alias (type_identifier) @name)
-      (enum_entry (simple_identifier) @name)
+      (source_file
+        [
+          (class_declaration name: (identifier) @name)
+          (object_declaration name: (identifier) @name)
+          (function_declaration name: (identifier) @name)
+          (property_declaration (variable_declaration (identifier) @name))
+          (type_alias type: (identifier) @name)
+        ])
+      (class_body
+        [
+          (class_declaration name: (identifier) @name)
+          (object_declaration name: (identifier) @name)
+          (function_declaration name: (identifier) @name)
+          (property_declaration (variable_declaration (identifier) @name))
+          (type_alias type: (identifier) @name)
+        ])
+      (enum_class_body (enum_entry (identifier) @name))
     `,
     locals: `
-      (class_declaration (type_identifier) @name)
-      (object_declaration (type_identifier) @name)
-      (function_declaration (simple_identifier) @name)
-      (property_declaration (variable_declaration (simple_identifier) @name))
-      (type_alias (type_identifier) @name)
-      (enum_entry (simple_identifier) @name)
-      (parameter (simple_identifier) @name)
-      (class_parameter (simple_identifier) @name)
-      (type_parameter (type_identifier) @name)
+      (class_declaration name: (identifier) @name)
+      (object_declaration name: (identifier) @name)
+      (function_declaration name: (identifier) @name)
+      (property_declaration (variable_declaration (identifier) @name))
+      (type_alias type: (identifier) @name)
+      (enum_entry (identifier) @name)
+      (parameter (identifier) @name)
+      (class_parameter (identifier) @name)
+      (type_parameter (identifier) @name)
     `,
     importBindings: `
-      (import_header (identifier) @from (import_alias (type_identifier) @alias)) @stmt
-      (import_header (identifier) @from (wildcard_import) @wild) @stmt
-      (import_header (identifier) @from) @stmt
+      (import (qualified_identifier) @from (identifier) @alias) @stmt
+      (import (qualified_identifier) @from ("*") @wild) @stmt
+      (import (qualified_identifier) @from) @stmt
     `
   },
   nodeTypes: {
-    identifier: ["identifier", "interpolated_identifier", "simple_identifier", "type_identifier"],
-    propertyIdentifier: ["simple_identifier", "type_identifier"],
+    identifier: ["identifier"],
+    propertyIdentifier: ["identifier"],
     memberExpression: "navigation_expression"
   },
   classifyDefinition: (node) => {
@@ -2106,35 +2288,31 @@ var KOTLIN_DEF = {
     const parent = node.parent;
     if (!parent)
       return false;
-    if (parent.type === "class_declaration" && node.type === "type_identifier")
+    if (parent.type === "class_declaration" && node.type === "identifier")
       return true;
-    if (parent.type === "object_declaration" && node.type === "type_identifier")
+    if (parent.type === "object_declaration" && node.type === "identifier")
       return true;
-    if (parent.type === "function_declaration" && (node.type === "simple_identifier" || node.type === "identifier"))
+    if (parent.type === "function_declaration" && node.type === "identifier")
       return true;
-    if (parent.type === "type_alias" && node.type === "type_identifier")
+    if (parent.type === "type_alias" && node.type === "identifier")
       return true;
-    if (parent.type === "variable_declaration" && node.type === "simple_identifier")
+    if (parent.type === "variable_declaration" && node.type === "identifier")
       return true;
-    if (parent.type === "parameter" && (node.type === "simple_identifier" || node.type === "identifier"))
+    if (parent.type === "parameter" && node.type === "identifier")
       return true;
-    if (parent.type === "class_parameter" && (node.type === "simple_identifier" || node.type === "identifier"))
+    if (parent.type === "class_parameter" && node.type === "identifier")
       return true;
-    if (parent.type === "enum_entry" && (node.type === "simple_identifier" || node.type === "identifier"))
+    if (parent.type === "enum_entry" && node.type === "identifier")
       return true;
-    if (parent.type === "type_parameter" && node.type === "type_identifier")
+    if (parent.type === "type_parameter" && node.type === "identifier")
       return true;
     return false;
   },
   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 === "control_structure_body" || node.type === "catch_block" || node.type === "finally_block",
+  createsBlockScope: (node) => node.type === "function_body" || node.type === "class_body" || node.type === "block" || node.type === "catch_block" || node.type === "finally_block",
   supportsCrossModuleSymbols: true,
-  native: {
-    normalizeQuery: normalizeKotlinNativeQuery,
-    authoritativeKinds: ["imports", "importBindings", "exports", "locals"],
-    notes: ["normalizes kotlin import and identifier node names for the native grammar"]
-  }
+  exportScopeBlockers: ["function_body", "lambda_literal", "anonymous_function"]
 };
 registerLanguage(KOTLIN_DEF);
 
@@ -2220,18 +2398,45 @@ var SWIFT_DEF = {
       (import_declaration (identifier) @mod) @stmt
     `,
     exports: `
-      (class_declaration declaration_kind: "class" name: (_) @name)
-      (class_declaration declaration_kind: "struct" name: (_) @name)
-      (class_declaration declaration_kind: "enum" name: (_) @name)
-      (class_declaration declaration_kind: "extension" name: (user_type (type_identifier) @name))
-      (class_declaration declaration_kind: "actor" name: (_) @name)
-      (enum_entry name: (simple_identifier) @name)
-      (protocol_declaration name: (type_identifier) @name)
-      (function_declaration name: (simple_identifier) @name)
-      (typealias_declaration name: (type_identifier) @name)
-      (property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
-      (protocol_function_declaration name: (simple_identifier) @name)
-      (protocol_property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
+      (source_file (class_declaration declaration_kind: "class" name: (_) @name))
+      (class_body (class_declaration declaration_kind: "class" name: (_) @name))
+      (enum_class_body (class_declaration declaration_kind: "class" name: (_) @name))
+      (source_file (class_declaration declaration_kind: "struct" name: (_) @name))
+      (class_body (class_declaration declaration_kind: "struct" name: (_) @name))
+      (enum_class_body (class_declaration declaration_kind: "struct" name: (_) @name))
+      (source_file (class_declaration declaration_kind: "enum" name: (_) @name))
+      (class_body (class_declaration declaration_kind: "enum" name: (_) @name))
+      (enum_class_body (class_declaration declaration_kind: "enum" name: (_) @name))
+      (source_file (class_declaration declaration_kind: "extension" name: (user_type (type_identifier) @name)))
+      (class_body (class_declaration declaration_kind: "extension" name: (user_type (type_identifier) @name)))
+      (enum_class_body (class_declaration declaration_kind: "extension" name: (user_type (type_identifier) @name)))
+      (source_file (class_declaration declaration_kind: "actor" name: (_) @name))
+      (class_body (class_declaration declaration_kind: "actor" name: (_) @name))
+      (enum_class_body (class_declaration declaration_kind: "actor" name: (_) @name))
+      (enum_class_body (enum_entry name: (simple_identifier) @name))
+      (source_file (protocol_declaration name: (type_identifier) @name))
+      (class_body (protocol_declaration name: (type_identifier) @name))
+      (enum_class_body (protocol_declaration name: (type_identifier) @name))
+      (source_file (function_declaration name: (simple_identifier) @name))
+      (class_body (function_declaration name: (simple_identifier) @name))
+      (enum_class_body (function_declaration name: (simple_identifier) @name))
+      (source_file (typealias_declaration name: (type_identifier) @name))
+      (class_body (typealias_declaration name: (type_identifier) @name))
+      (enum_class_body (typealias_declaration name: (type_identifier) @name))
+      (protocol_body (typealias_declaration name: (type_identifier) @name))
+      (source_file (property_declaration name: (pattern bound_identifier: (simple_identifier) @name)))
+      (class_body (property_declaration name: (pattern bound_identifier: (simple_identifier) @name)))
+      (enum_class_body (property_declaration name: (pattern bound_identifier: (simple_identifier) @name)))
+      (protocol_body (protocol_function_declaration name: (simple_identifier) @name))
+      (protocol_body (protocol_property_declaration name: (pattern bound_identifier: (simple_identifier) @name)))
+      (source_file (associatedtype_declaration name: (type_identifier) @name))
+      (protocol_body (associatedtype_declaration name: (type_identifier) @name))
+      (class_body (associatedtype_declaration name: (type_identifier) @name))
+      (enum_class_body (associatedtype_declaration name: (type_identifier) @name))
+      (source_file (macro_declaration (simple_identifier) @name))
+      (source_file (operator_declaration [(custom_operator) (simple_identifier) (bang)] @name))
+      (class_body (operator_declaration [(custom_operator) (simple_identifier) (bang)] @name))
+      (enum_class_body (operator_declaration [(custom_operator) (simple_identifier) (bang)] @name))
     `,
     locals: `
       (class_declaration declaration_kind: "class" name: (_) @name)
@@ -2247,6 +2452,9 @@ var SWIFT_DEF = {
       (parameter name: (simple_identifier) @name)
       (protocol_function_declaration name: (simple_identifier) @name)
       (protocol_property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
+      (associatedtype_declaration name: (type_identifier) @name)
+      (macro_declaration (simple_identifier) @name)
+      (operator_declaration [(custom_operator) (simple_identifier) (bang)] @name)
     `,
     importBindings: `
       (import_declaration (identifier) @from) @stmt
@@ -2261,9 +2469,7 @@ var SWIFT_DEF = {
     const parent = node.parent;
     if (!parent)
       return "variable";
-    if (parent.type === "function_declaration")
-      return "function";
-    if (parent.type === "protocol_function_declaration")
+    if (parent.type === "function_declaration" || parent.type === "protocol_function_declaration" || parent.type === "init_declaration" || parent.type === "deinit_declaration" || parent.type === "subscript_declaration" || parent.type === "macro_declaration" || parent.type === "operator_declaration")
       return "function";
     if (parent.type === "class_declaration") {
       const declarationKind = parent.childForFieldName("declaration_kind")?.text;
@@ -2273,7 +2479,7 @@ var SWIFT_DEF = {
     }
     if (parent.type === "user_type" && parent.parent?.type === "class_declaration")
       return "class";
-    if (parent.type === "protocol_declaration" || parent.type === "typealias_declaration")
+    if (parent.type === "protocol_declaration" || parent.type === "typealias_declaration" || parent.type === "associatedtype_declaration")
       return "type";
     return "variable";
   },
@@ -2293,6 +2499,18 @@ var SWIFT_DEF = {
       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)
+      return true;
+    if (parent.type === "macro_declaration" && node.type === "simple_identifier")
+      return true;
+    if (parent.type === "operator_declaration" && (node.type === "custom_operator" || node.type === "simple_identifier" || node.type === "bang"))
+      return true;
+    if (parent.type === "init_declaration" && node.type === "init")
+      return true;
+    if (parent.type === "deinit_declaration" && node.type === "deinit")
+      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)
@@ -2306,14 +2524,15 @@ var SWIFT_DEF = {
   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",
-  supportsCrossModuleSymbols: true
+  supportsCrossModuleSymbols: true,
+  exportScopeBlockers: ["function_body", "lambda_literal"]
 };
 registerLanguage(SWIFT_DEF);
 
 // dist/languages/definitions/sql.js
 var SQL_DEF = {
   id: "sql",
-  extensions: [".sql"],
+  extensions: [".sql", ".ddl", ".pgsql", ".mysql"],
   structure: {
     blocks: [
       { type: "statement", nameQuery: "(create_table)", captureId: "create" },
@@ -2351,7 +2570,8 @@ var ZIG_TYPE_INITIALIZER_TYPES = /* @__PURE__ */ new Set([
   "enum_declaration",
   "union_declaration",
   "opaque_declaration",
-  "error_set_declaration"
+  "error_set_declaration",
+  "error_union_type"
 ]);
 var ZIG_DEF = {
   id: "zig",
@@ -2363,13 +2583,16 @@ var ZIG_DEF = {
       { type: "test_declaration", nameQuery: "(string) @chunk.name", captureId: "test" }
     ],
     splitPoints: ["if_expression", "for_expression", "while_expression", "switch_expression"],
-    comments: ["line_comment", "doc_comment"]
+    comments: ["comment"]
   },
   graph: {
-    imports: '(builtin_function (builtin_identifier) @fn (arguments (string) @mod) (#eq? @fn "@import")) @stmt',
+    imports: `
+      (builtin_function (builtin_identifier) @fn (arguments (string) @mod) (#eq? @fn "@import")) @stmt
+      (builtin_function (builtin_identifier) @mod (arguments) (#eq? @mod "@cImport")) @stmt
+    `,
     exports: `
-      (function_declaration name: (identifier) @name)
-      (variable_declaration (identifier) @name)
+      (source_file (function_declaration name: (identifier) @name))
+      (source_file (variable_declaration (identifier) @name))
     `,
     locals: `
       (function_declaration name: (identifier) @name)
@@ -2381,6 +2604,13 @@ var ZIG_DEF = {
         (identifier) @alias
         (builtin_function (builtin_identifier) @fn (arguments (string) @from) (#eq? @fn "@import"))
       ) @stmt
+      (variable_declaration
+        (identifier) @alias
+        (builtin_function (builtin_identifier) @from (arguments) (#eq? @from "@cImport"))
+      ) @stmt
+      (using_namespace_declaration
+        (builtin_function (builtin_identifier) @fn (arguments (string) @from) (#eq? @fn "@import"))
+      ) @stmt @wild
     `
   },
   nodeTypes: {
@@ -2399,7 +2629,17 @@ var ZIG_DEF = {
     const declaredName = parent.namedChildren.find((child) => child.type === "identifier");
     if (declaredName?.id !== node.id)
       return "variable";
-    const initializer = parent.namedChildren.find((child) => child.id !== node.id);
+    let equalsEndIndex = -1;
+    for (let index = 0; ; index++) {
+      const child = parent.child(index);
+      if (!child)
+        break;
+      if (child.type === "=") {
+        equalsEndIndex = child.endIndex;
+        break;
+      }
+    }
+    const initializer = parent.namedChildren.find((child) => child.startIndex >= equalsEndIndex);
     if (initializer && ZIG_TYPE_INITIALIZER_TYPES.has(initializer.type))
       return "type";
     return "variable";
@@ -2515,6 +2755,103 @@ 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;
+      while (i < src.length) {
+        if (src[i] === "*" && src[i + 1] === "/") {
+          if (preserveLength)
+            out += "  ";
+          i += 2;
+          break;
+        }
+        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,
@@ -2529,6 +2866,7 @@ function adaptDefinition(def) {
     membersAreImplicitlyInScope: def.membersAreImplicitlyInScope ?? true,
     supportsCrossModuleSymbols: def.supportsCrossModuleSymbols || false,
     isTypeOnly: def.isTypeOnly || (() => false),
+    exportScopeBlockers: def.exportScopeBlockers ?? [],
     supportsExportFromReferences: def.supportsExportFromReferences ?? false,
     usesQueryDrivenLocals: def.usesQueryDrivenLocals || false,
     normalizeIdentifier: def.normalizeIdentifier || ((name) => name),
@@ -2618,7 +2956,8 @@ function supportById(id) {
   return LANGUAGE_SUPPORTS.find((s) => s.id === id);
 }
 var HEADER_SAMPLE_SIZE = 8e3;
-var CPP_HEADER_HINT = /\b(class|namespace|template|typename|constexpr|operator|using\s+namespace)\b|::/;
+var CPP_HEADER_HINT = /\b(?:class|namespace|template|typename|constexpr)\b(?!\s*(?:;|,|\)|=|\[|\())|\boperator\b(?!\s*[;,):])|\bconcept\s+\w+\s*=|\bco_await\s+\w|\busing\s+(?:namespace|\w+\s*=)|::/;
+var CPP_MODULE_IMPORT_HINT = /^\s*(?:export\s+)?import\s+(?:[\w.:]+|<[^>\n]+>|"[^"\n]*")\s*;/m;
 function readFileSample(filePath) {
   try {
     const contents = fs.readFileSync(filePath, "utf8");
@@ -2628,7 +2967,8 @@ function readFileSample(filePath) {
   }
 }
 function isLikelyCppHeader(sample) {
-  return CPP_HEADER_HINT.test(sample);
+  const masked = maskJsLikeCommentsAndStrings(sample);
+  return CPP_HEADER_HINT.test(masked) || CPP_MODULE_IMPORT_HINT.test(masked);
 }
 
 // dist/native/runtime.js