@willbooster/tree-sitter-typescript 1.2.4 → 1.2.6

package/README.md

@@ -67,7 +67,9 @@ const parser = new Parser();
 parser.setLanguage(await Language.load(typescript));
 ```
 
-The package also ships the node types in `typescript/src/node-types.json` and `tsx/src/node-types.json`.
+The package also ships the node types in `typescript/src/node-types.json` and `tsx/src/node-types.json`, and the
+highlighting, injection, locals, and tags queries that `tree-sitter.json` lists: this grammar's in `queries/` and, in
+`javascript/queries/`, those of the JavaScript grammar it extends.
 
 In Rust, depend on the [crate](https://crates.io/crates/willbooster-tree-sitter-typescript) and on
 [willbooster-tree-sitter](https://crates.io/crates/willbooster-tree-sitter), the runtime this package is tested and
@@ -86,6 +88,8 @@ parser.set_language(&tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into())?;
 // or `tree_sitter_typescript::LANGUAGE_TSX` for TSX
 ```
 
+The crate ships the same `tree-sitter.json` and query files as the npm package.
+
 ## Development
 
 ```sh
@@ -105,7 +109,8 @@ cargo test
   Cases run with the `typescript` grammar unless they carry `:language(tsx)`;
 - an incremental-parsing check (`test/unit/incremental.test.ts`): `script/fuzz-corpus` runs `tree-sitter fuzz`, which
   edits each corpus case of each grammar at random, reparses it, undoes the edits, and reparses again, on the
-  WillBooster/tree-sitter runtime version locked in `Cargo.lock` (the first run builds that CLI with `cargo`).
+  WillBooster/tree-sitter runtime version locked in `Cargo.lock` (the first run downloads that CLI from its GitHub
+  Release, or builds it with `cargo` when the download fails or the release has no binary that runs here).
   `TREE_SITTER_SEED`, `TREE_SITTER_ITERATIONS`, and `TREE_SITTER_EDITS` run other or more edits;
 - a check that the real-world files in `examples/`, the checked-in ones and those of the cloned repositories, fail to
   parse exactly as listed in `script/known-failures.txt`. `.ts` files are parsed with the `typescript` grammar and
@@ -115,6 +120,10 @@ cargo test
 - a performance check (`test/unit/performance.test.ts`) that recovering from an error on each of 10,000 lines takes
   linear time with each grammar, since consumers parse files while they are being edited. It loads the Wasm builds
   through @willbooster/web-tree-sitter, which `bun run build/ci` rebuilds after regenerating the parsers;
+- a check (`test/unit/queries.test.ts`) that the queries `tree-sitter.json` lists compile against each grammar, are
+  published in the npm package and the crate, and that `javascript/queries/` matches the queries of the installed
+  @willbooster/tree-sitter-javascript; after updating that dependency, `script/copy-javascript-queries` refreshes the
+  copies;
 - checks that both Wasm builds load and parse through @willbooster/web-tree-sitter in Chromium
   (`test/unit/browser/`) and in Cloudflare Workers with and without Node.js compatibility
   (`test/unit/workers.test.ts`, running the Worker in `test/fixtures/worker/`).

package/common/defineGrammar.js

@@ -1,6 +1,26 @@
 // oxlint-disable unicorn/prefer-module -- This package is CommonJS, so tree-sitter loads the grammar as CommonJS.
 const JavaScript = require('@willbooster/tree-sitter-javascript/grammar');
 
+// Words that are keywords only in some positions and identifiers elsewhere, besides the JavaScript grammar's.
+const TYPESCRIPT_CONTEXTUAL_KEYWORDS = [
+  'declare',
+  'namespace',
+  'type',
+  'public',
+  'private',
+  'protected',
+  'override',
+  'readonly',
+  'module',
+  'any',
+  'number',
+  'boolean',
+  'string',
+  'symbol',
+  'object',
+  'new',
+];
+
 module.exports = function defineGrammar(dialect) {
   return grammar(JavaScript, {
     name: dialect,
@@ -63,6 +83,8 @@ module.exports = function defineGrammar(dialect) {
       [$.primary_expression, $._for_header, $._for_using_declaration],
       [$._for_header, $._binding_identifier],
       [$.expression, $.call_expression, $.instantiation_expression],
+      [$._field_name, $._property_name],
+      [$._property_name, $.public_field_definition],
 
       // This appears to be necessary to parse a parenthesized class expression
       [$.class],
@@ -118,6 +140,9 @@ module.exports = function defineGrammar(dialect) {
     ],
 
     rules: {
+      // A field named `get`, `set`, or `static` is told apart from a member that the word modifies by the line-break
+      // sentinels allowed right after the name, as in the JavaScript grammar's field_definition. They are not allowed
+      // after a type annotation, which may continue on the next line.
       public_field_definition: ($) =>
         seq(
           repeat(field('decorator', $.decorator)),
@@ -128,17 +153,64 @@ module.exports = function defineGrammar(dialect) {
             )
           ),
           choice(
-            seq(optional('static'), optional($.override_modifier), optional('readonly')),
-            seq(optional('abstract'), optional('readonly')),
-            seq(optional('readonly'), optional('abstract')),
-            optional('accessor')
-          ),
-          field('name', $._property_name),
-          optional(choice('?', '!')),
-          field('type', optional($.type_annotation)),
-          optional($._initializer)
+            seq(
+              choice(
+                seq(optional('static'), optional($.override_modifier), optional('readonly')),
+                seq(optional('abstract'), optional('readonly')),
+                seq(optional('readonly'), optional('abstract')),
+                optional('accessor')
+              ),
+              choice(
+                seq(
+                  field('name', $._field_name),
+                  choice(
+                    optional(choice($._initializer, $._line_break_after_field)),
+                    seq($._field_annotations, optional($._initializer))
+                  )
+                ),
+                // A line break after `get` or `set` continues a getter or setter. Allowing both sentinels here tells
+                // the scanner that a `*` on the next line cannot continue the member, unlike after `static`.
+                seq(
+                  field('name', alias(choice('get', 'set'), $.property_identifier)),
+                  choice(
+                    optional(choice($._initializer, $._line_break_after_modifier, $._line_break_after_field)),
+                    seq($._field_annotations, optional($._initializer))
+                  )
+                )
+              )
+            ),
+            // A line break after a leading `static` continues a static member.
+            seq(
+              field('name', alias('static', $.property_identifier)),
+              choice(
+                optional(choice($._initializer, $._line_break_after_modifier)),
+                seq($._field_annotations, optional($._initializer))
+              )
+            ),
+            // After a modifier, `static` is a field name, which a line break ends.
+            seq(
+              choice(
+                seq('static', optional($.override_modifier), optional('readonly')),
+                seq($.override_modifier, optional('readonly')),
+                seq('readonly', optional('abstract')),
+                seq('abstract', optional('readonly')),
+                'accessor'
+              ),
+              field('name', alias('static', $.property_identifier)),
+              choice(
+                optional(choice($._initializer, $._line_break_after_field)),
+                seq($._field_annotations, optional($._initializer))
+              )
+            )
+          )
         ),
 
+      _field_annotations: ($) =>
+        choice(seq(choice('?', '!'), field('type', optional($.type_annotation))), field('type', $.type_annotation)),
+
+      _field_name: ($, previous) =>
+        choice(previous, alias(choice(...TYPESCRIPT_CONTEXTUAL_KEYWORDS), $.property_identifier)),
+
       // override original catch_clause, add optional type annotation
       catch_clause: ($) =>
         seq(
@@ -251,15 +323,6 @@ module.exports = function defineGrammar(dialect) {
           )
         ),
 
-      // Any identifier name may name a JSX attribute, such as `class` in `<div class="x" />`, which the JavaScript
-      // grammar's reserved words reject (WillBooster/tree-sitter-javascript#25).
-      _jsx_attribute_name: ($) =>
-        choice(
-          alias($.jsx_identifier, $.property_identifier),
-          alias(reserved('properties', $.identifier), $.property_identifier),
-          $.jsx_namespace_name
-        ),
-
       // This rule is only referenced by expression when the dialect is 'tsx'
       jsx_opening_element: ($) => prec.dynamic(-1, seq($._jsx_start_opening_element, '>')),
 
@@ -268,9 +331,7 @@ module.exports = function defineGrammar(dialect) {
 
       export_specifier: (_, previous) => seq(optional(choice('type', 'typeof')), previous),
 
-      // Any identifier name may be exported or imported. The JavaScript grammar rejects reserved words other than
-      // `default`, for which it leaves no node (WillBooster/tree-sitter-javascript#17 and #24).
-      _module_export_name: ($) => choice(reserved('properties', $.identifier), $.string),
+      _local_export_specifier: (_, previous) => seq(optional(choice('type', 'typeof')), previous),
 
       _import_identifier: ($) => choice($.identifier, alias('type', $.identifier)),
 
@@ -301,7 +362,7 @@ module.exports = function defineGrammar(dialect) {
           'import',
           optional(choice('type', 'typeof')),
           choice(seq($.import_clause, $._from_clause), $.import_require_clause, field('source', $.string)),
-          optional($.import_attribute),
+          optional(choice($.import_attribute, $._line_break_before_attributes)),
           $._semicolon
         ),
 
@@ -314,33 +375,6 @@ module.exports = function defineGrammar(dialect) {
           seq('export', 'as', 'namespace', $.identifier, $._semicolon)
         ),
 
-      // The JavaScript grammar leaves `await (x).y` ambiguous with a call of an identifier named `await`, and GLR keeps
-      // the call; TypeScript and V8 read the operator (WillBooster/tree-sitter-javascript#23).
-      await_expression: ($) => prec.dynamic(2, prec('unary_void', seq('await', $.expression))),
-
-      // The JavaScript grammar's for header takes no `using` declaration, although ECMAScript allows one.
-      for_statement: ($) =>
-        seq(
-          'for',
-          '(',
-          choice(
-            field(
-              'initializer',
-              choice(
-                alias($.for_lexical_declaration, $.lexical_declaration),
-                alias($.for_variable_declaration, $.variable_declaration),
-                alias($._for_using_declaration, $.using_declaration)
-              )
-            ),
-            seq(field('initializer', $._expressions), ';'),
-            field('initializer', $.empty_statement)
-          ),
-          field('condition', choice(seq($._expressions, ';'), $.empty_statement)),
-          field('increment', optional($._expressions)),
-          ')',
-          field('body', $.statement)
-        ),
-
       // ECMAScript binds only identifiers in a using declaration, so `using [a] = b` assigns to a subscript of a
       // variable named `using`.
       using_declaration: ($) =>
@@ -391,8 +425,11 @@ module.exports = function defineGrammar(dialect) {
         choice(
           seq(
             field('name', choice($._binding_identifier, $._destructuring_pattern)),
-            field('type', optional($.type_annotation)),
-            optional($._initializer)
+            // The line-break sentinel applies only right after the name: a type may continue on the next line.
+            choice(
+              optional(choice($._initializer, $._line_break_after_binding)),
+              seq(field('type', $.type_annotation), optional($._initializer))
+            )
           ),
           prec('declaration', seq(field('name', $._binding_identifier), '!', field('type', $.type_annotation)))
         ),
@@ -450,7 +487,14 @@ module.exports = function defineGrammar(dialect) {
         prec(
           'call',
           seq(
-            field('function', choice($.identifier, alias($.decorator_member_expression, $.member_expression))),
+            field(
+              'function',
+              choice(
+                $.identifier,
+                alias($.decorator_member_expression, $.member_expression),
+                alias($.decorator_parenthesized_expression, $.parenthesized_expression)
+              )
+            ),
             optional(field('type_arguments', $.type_arguments)),
             field('arguments', $.arguments)
           )
@@ -458,18 +502,6 @@ module.exports = function defineGrammar(dialect) {
 
       decorator_parenthesized_expression: ($) => seq('(', $._expressions, ')'),
 
-      // A decorator's member name may be any identifier name, as a member expression's may, which the JavaScript
-      // grammar's reserved words reject.
-      decorator_member_expression: ($) =>
-        prec(
-          'member',
-          seq(
-            field('object', choice($.identifier, alias($.decorator_member_expression, $.member_expression))),
-            '.',
-            field('property', reserved('properties', alias($.identifier, $.property_identifier)))
-          )
-        ),
-
       class_body: ($) =>
         seq(
           '{',
@@ -508,7 +540,7 @@ module.exports = function defineGrammar(dialect) {
             field('name', $._property_name),
             optional('?'),
             $._call_signature,
-            field('body', $.statement_block)
+            field('body', alias($._class_member_body, $.statement_block))
           )
         ),
 
@@ -619,17 +651,6 @@ module.exports = function defineGrammar(dialect) {
 
       import_alias: ($) => seq('import', $.identifier, '=', choice($.identifier, $.nested_identifier), $._semicolon),
 
-      // A qualified name may end in any identifier name, as a member expression may.
-      nested_identifier: ($) =>
-        prec(
-          'member',
-          seq(
-            field('object', choice($.identifier, alias($.nested_identifier, $.member_expression))),
-            '.',
-            field('property', reserved('properties', alias($.identifier, $.property_identifier)))
-          )
-        ),
-
       nested_type_identifier: ($) =>
         prec(
           'member',
@@ -1112,29 +1133,7 @@ module.exports = function defineGrammar(dialect) {
       // allowed on the identifier inside the alias: around the alias, the keyword token still wins in the lexer.
       _type_identifier: ($) => alias(reserved('properties', $.identifier), $.type_identifier),
 
-      _reserved_identifier: (_, previous) =>
-        choice(
-          'declare',
-          'namespace',
-          'type',
-          'public',
-          'private',
-          'protected',
-          'override',
-          'readonly',
-          'module',
-          'any',
-          'number',
-          'boolean',
-          'string',
-          'symbol',
-          'export',
-          'object',
-          'new',
-          'readonly',
-          'using',
-          previous
-        ),
+      _reserved_identifier: (_, previous) => choice(...TYPESCRIPT_CONTEXTUAL_KEYWORDS, previous),
     },
   });
 };

package/javascript/queries/highlights-jsx.scm

@@ -0,0 +1,8 @@
+(jsx_opening_element (identifier) @tag (#match? @tag "^[a-z][^.]*$"))
+(jsx_closing_element (identifier) @tag (#match? @tag "^[a-z][^.]*$"))
+(jsx_self_closing_element (identifier) @tag (#match? @tag "^[a-z][^.]*$"))
+
+(jsx_attribute (property_identifier) @attribute)
+(jsx_opening_element (["<" ">"]) @punctuation.bracket)
+(jsx_closing_element (["</" ">"]) @punctuation.bracket)
+(jsx_self_closing_element (["<" "/>"]) @punctuation.bracket)

package/javascript/queries/highlights.scm

@@ -0,0 +1,218 @@
+; Variables
+;----------
+
+(identifier) @variable
+
+; Properties
+;-----------
+
+(property_identifier) @property
+
+; Function and method definitions
+;--------------------------------
+
+(function_expression
+  name: (identifier) @function)
+(function_declaration
+  name: (identifier) @function)
+(method_definition
+  name: (property_identifier) @function.method)
+
+(pair
+  key: (property_identifier) @function.method
+  value: [(function_expression) (arrow_function)])
+
+(assignment_expression
+  left: (member_expression
+    property: (property_identifier) @function.method)
+  right: [(function_expression) (arrow_function)])
+
+(variable_declarator
+  name: (identifier) @function
+  value: [(function_expression) (arrow_function)])
+
+(assignment_expression
+  left: (identifier) @function
+  right: [(function_expression) (arrow_function)])
+
+; Function and method calls
+;--------------------------
+
+(call_expression
+  function: (identifier) @function)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @function.method))
+
+; Special identifiers
+;--------------------
+
+((identifier) @constructor
+ (#match? @constructor "^[A-Z]"))
+
+([
+    (identifier)
+    (shorthand_property_identifier)
+    (shorthand_property_identifier_pattern)
+ ] @constant
+ (#match? @constant "^[A-Z_][A-Z\\d_]+$"))
+
+((identifier) @variable.builtin
+ (#match? @variable.builtin "^(arguments|module|console|window|document)$")
+ (#is-not? local))
+
+((identifier) @function.builtin
+ (#eq? @function.builtin "require")
+ (#is-not? local))
+
+; Literals
+;---------
+
+(this) @variable.builtin
+(super) @variable.builtin
+
+[
+  (true)
+  (false)
+  (null)
+  (undefined)
+] @constant.builtin
+
+(comment) @comment
+
+[
+  (string)
+  (template_string)
+] @string
+
+(regex) @string.special
+(number) @number
+
+; Tokens
+;-------
+
+[
+  ";"
+  (optional_chain)
+  "."
+  ","
+] @punctuation.delimiter
+
+[
+  "-"
+  "--"
+  "-="
+  "+"
+  "++"
+  "+="
+  "*"
+  "*="
+  "**"
+  "**="
+  "/"
+  "/="
+  "%"
+  "%="
+  "<"
+  "<="
+  "<<"
+  "<<="
+  "="
+  "=="
+  "==="
+  "!"
+  "!="
+  "!=="
+  "=>"
+  ">"
+  ">="
+  ">>"
+  ">>="
+  ">>>"
+  ">>>="
+  "~"
+  "^"
+  "&"
+  "|"
+  "^="
+  "&="
+  "|="
+  "&&"
+  "||"
+  "??"
+  "&&="
+  "||="
+  "??="
+] @operator
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+]  @punctuation.bracket
+
+(template_substitution
+  "${" @punctuation.special
+  "}" @punctuation.special) @embedded
+
+[
+  "as"
+  "async"
+  "await"
+  "break"
+  "case"
+  "catch"
+  "class"
+  "const"
+  "continue"
+  "debugger"
+  "default"
+  "delete"
+  "do"
+  "else"
+  "export"
+  "extends"
+  "finally"
+  "for"
+  "from"
+  "function"
+  "get"
+  "if"
+  "import"
+  "in"
+  "instanceof"
+  "let"
+  "new"
+  "of"
+  "return"
+  "set"
+  "static"
+  "switch"
+  "target"
+  "throw"
+  "try"
+  "typeof"
+  "var"
+  "void"
+  "while"
+  "with"
+  "yield"
+] @keyword
+
+; `default` as a module export name is an identifier node.
+(export_specifier
+  name: (identifier) @keyword
+  (#eq? @keyword "default"))
+(export_specifier
+  alias: (identifier) @keyword
+  (#eq? @keyword "default"))
+(import_specifier
+  name: (identifier) @keyword
+  (#eq? @keyword "default"))
+(namespace_export
+  (identifier) @keyword
+  (#eq? @keyword "default"))

package/javascript/queries/injections.scm

@@ -0,0 +1,31 @@
+; Parse the contents of tagged template literals using
+; a language inferred from the tag.
+
+(call_expression
+  function: [
+    (identifier) @injection.language
+    (member_expression
+      property: (property_identifier) @injection.language)
+  ]
+  arguments: (template_string (string_fragment) @injection.content)
+  (#set! injection.combined)
+  (#set! injection.include-children))
+
+
+; Parse regex syntax within regex literals
+
+((regex_pattern) @injection.content
+ (#set! injection.language "regex"))
+
+ ; Parse JSDoc annotations in comments
+
+((comment) @injection.content
+ (#set! injection.language "jsdoc"))
+
+; Parse Ember/Glimmer/Handlebars/HTMLBars/etc. template literals
+; e.g.: await render(hbs`<SomeComponent />`)
+(call_expression
+  function: ((identifier) @_name
+             (#eq? @_name "hbs"))
+  arguments: ((template_string) @glimmer
+              (#offset! @glimmer 0 1 0 -1)))

package/javascript/queries/locals.scm

@@ -0,0 +1,23 @@
+; Scopes
+;-------
+
+[
+  (statement_block)
+  (function_expression)
+  (arrow_function)
+  (function_declaration)
+  (method_definition)
+] @local.scope
+
+; Definitions
+;------------
+
+(pattern/identifier) @local.definition
+
+(variable_declarator
+  name: (identifier) @local.definition)
+
+; References
+;------------
+
+(identifier) @local.reference

package/javascript/queries/tags.scm

@@ -0,0 +1,99 @@
+(
+  (comment)* @doc
+  .
+  (method_definition
+    name: (property_identifier) @name) @definition.method
+  (#not-eq? @name "constructor")
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.method)
+)
+
+(
+  (comment)* @doc
+  .
+  [
+    (class
+      name: (_) @name)
+    (class_declaration
+      name: (_) @name)
+  ] @definition.class
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.class)
+)
+
+(
+  (comment)* @doc
+  .
+  [
+    (function_expression
+      name: (identifier) @name)
+    (function_declaration
+      name: (identifier) @name)
+    (generator_function
+      name: (identifier) @name)
+    (generator_function_declaration
+      name: (identifier) @name)
+  ] @definition.function
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (lexical_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: [(arrow_function) (function_expression)]) @definition.function)
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (variable_declaration
+    (variable_declarator
+      name: (identifier) @name
+      value: [(arrow_function) (function_expression)]) @definition.function)
+  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
+  (#select-adjacent! @doc @definition.function)
+)
+
+(assignment_expression
+  left: [
+    (identifier) @name
+    (member_expression
+      property: (property_identifier) @name)
+  ]
+  right: [(arrow_function) (function_expression)]
+) @definition.function
+
+(pair
+  key: (property_identifier) @name
+  value: [(arrow_function) (function_expression)]) @definition.function
+
+(
+  (call_expression
+    function: (identifier) @name) @reference.call
+  (#not-match? @name "^(require)$")
+)
+
+(call_expression
+  function: (member_expression
+    property: (property_identifier) @name)
+  arguments: (_) @reference.call)
+
+(new_expression
+  constructor: (_) @name) @reference.class
+
+(export_statement value: (assignment_expression left: (identifier) @name right: ([
+ (number)
+ (string)
+ (identifier)
+ (undefined)
+ (null)
+ (new_expression)
+ (binary_expression)
+ (call_expression)
+]))) @definition.constant

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@willbooster/tree-sitter-typescript",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "TypeScript and TSX grammars for tree-sitter",
   "keywords": [
     "incremental",
@@ -22,6 +22,8 @@
     "tree-sitter.json",
     "typescript/src/node-types.json",
     "tsx/src/node-types.json",
+    "queries/*.scm",
+    "javascript/queries/*.scm",
     "*.wasm"
   ],
   "scripts": {
@@ -48,7 +50,7 @@
     "@vitest/browser-playwright": "5.0.1",
     "@willbooster/oxfmt-config": "1.2.2",
     "@willbooster/oxlint-config": "1.4.8",
-    "@willbooster/tree-sitter-javascript": "1.0.3",
+    "@willbooster/tree-sitter-javascript": "1.0.16",
     "@willbooster/wb": "22.13.0",
     "@willbooster/web-tree-sitter": "1.0.7",
     "conventional-changelog-conventionalcommits": "10.4.0",

package/queries/highlights.scm

@@ -0,0 +1,35 @@
+; Types
+
+(type_identifier) @type
+(predefined_type) @type.builtin
+
+((identifier) @type
+ (#match? @type "^[A-Z]"))
+
+(type_arguments
+  "<" @punctuation.bracket
+  ">" @punctuation.bracket)
+
+; Variables
+
+(required_parameter (identifier) @variable.parameter)
+(optional_parameter (identifier) @variable.parameter)
+
+; Keywords
+
+[ "abstract"
+  "declare"
+  "enum"
+  "export"
+  "implements"
+  "interface"
+  "keyof"
+  "namespace"
+  "private"
+  "protected"
+  "public"
+  "type"
+  "readonly"
+  "override"
+  "satisfies"
+] @keyword

package/queries/locals.scm

@@ -0,0 +1,2 @@
+(required_parameter (identifier) @local.definition)
+(optional_parameter (identifier) @local.definition)

package/queries/tags.scm

@@ -0,0 +1,23 @@
+(function_signature
+  name: (identifier) @name) @definition.function
+
+(method_signature
+  name: (property_identifier) @name) @definition.method
+
+(abstract_method_signature
+  name: (property_identifier) @name) @definition.method
+
+(abstract_class_declaration
+  name: (type_identifier) @name) @definition.class
+
+(module
+  name: (identifier) @name) @definition.module
+
+(interface_declaration
+  name: (type_identifier) @name) @definition.interface
+
+(type_annotation
+  (type_identifier) @name) @reference.type
+
+(new_expression
+  constructor: (identifier) @name) @reference.class

package/tree-sitter.json

@@ -14,16 +14,16 @@
       ],
       "highlights": [
         "queries/highlights.scm",
-        "node_modules/@willbooster/tree-sitter-javascript/queries/highlights.scm"
+        "javascript/queries/highlights.scm"
       ],
-      "injections": "node_modules/@willbooster/tree-sitter-javascript/queries/injections.scm",
+      "injections": "javascript/queries/injections.scm",
       "locals": [
         "queries/locals.scm",
-        "node_modules/@willbooster/tree-sitter-javascript/queries/locals.scm"
+        "javascript/queries/locals.scm"
       ],
       "tags": [
         "queries/tags.scm",
-        "node_modules/@willbooster/tree-sitter-javascript/queries/tags.scm"
+        "javascript/queries/tags.scm"
       ],
       "injection-regex": "^(ts|typescript)$"
     },
@@ -40,14 +40,17 @@
       ],
       "highlights": [
         "queries/highlights.scm",
-        "node_modules/@willbooster/tree-sitter-javascript/queries/highlights-jsx.scm",
-        "node_modules/@willbooster/tree-sitter-javascript/queries/highlights.scm"
+        "javascript/queries/highlights-jsx.scm",
+        "javascript/queries/highlights.scm"
+      ],
+      "injections": "javascript/queries/injections.scm",
+      "locals": [
+        "queries/locals.scm",
+        "javascript/queries/locals.scm"
       ],
-      "injections": "node_modules/@willbooster/tree-sitter-javascript/queries/injections.scm",
-      "locals": "node_modules/@willbooster/tree-sitter-javascript/queries/locals.scm",
       "tags": [
         "queries/tags.scm",
-        "node_modules/@willbooster/tree-sitter-javascript/queries/tags.scm"
+        "javascript/queries/tags.scm"
       ],
       "injection-regex": "^(ts|typescript)$"
     },
@@ -64,20 +67,23 @@
       ],
       "highlights": [
         "queries/highlights.scm",
-        "node_modules/@willbooster/tree-sitter-javascript/queries/highlights-jsx.scm",
-        "node_modules/@willbooster/tree-sitter-javascript/queries/highlights.scm"
+        "javascript/queries/highlights-jsx.scm",
+        "javascript/queries/highlights.scm"
+      ],
+      "injections": "javascript/queries/injections.scm",
+      "locals": [
+        "queries/locals.scm",
+        "javascript/queries/locals.scm"
       ],
-      "injections": "node_modules/@willbooster/tree-sitter-javascript/queries/injections.scm",
-      "locals": "node_modules/@willbooster/tree-sitter-javascript/queries/locals.scm",
       "tags": [
         "queries/tags.scm",
-        "node_modules/@willbooster/tree-sitter-javascript/queries/tags.scm"
+        "javascript/queries/tags.scm"
       ],
       "content-regex": "@flow"
     }
   ],
   "metadata": {
-    "version": "1.2.4",
+    "version": "1.2.6",
     "license": "MIT",
     "description": "TypeScript and TSX grammars for tree-sitter",
     "authors": [

package/tsx/src/node-types.json

@@ -159,6 +159,10 @@
         "type": "object_pattern",
         "named": true
       },
+      {
+        "type": "parenthesized_expression",
+        "named": true
+      },
       {
         "type": "rest_pattern",
         "named": true
@@ -2018,7 +2022,7 @@
       }
     },
     "children": {
-      "multiple": false,
+      "multiple": true,
       "required": false,
       "types": [
         {
@@ -2033,6 +2037,10 @@
           "type": "identifier",
           "named": true
         },
+        {
+          "type": "import_attribute",
+          "named": true
+        },
         {
           "type": "namespace_export",
           "named": true
@@ -4739,6 +4747,10 @@
           "type": "object_pattern",
           "named": true
         },
+        {
+          "type": "parenthesized_expression",
+          "named": true
+        },
         {
           "type": "subscript_expression",
           "named": true

package/typescript/src/node-types.json

@@ -155,6 +155,10 @@
         "type": "object_pattern",
         "named": true
       },
+      {
+        "type": "parenthesized_expression",
+        "named": true
+      },
       {
         "type": "rest_pattern",
         "named": true
@@ -2014,7 +2018,7 @@
       }
     },
     "children": {
-      "multiple": false,
+      "multiple": true,
       "required": false,
       "types": [
         {
@@ -2029,6 +2033,10 @@
           "type": "identifier",
           "named": true
         },
+        {
+          "type": "import_attribute",
+          "named": true
+        },
         {
           "type": "namespace_export",
           "named": true
@@ -4490,6 +4498,10 @@
           "type": "object_pattern",
           "named": true
         },
+        {
+          "type": "parenthesized_expression",
+          "named": true
+        },
         {
           "type": "subscript_expression",
           "named": true