ts-wasms 1.0.6 → 2.0.0

package/out/python/indents.scm

@@ -0,0 +1,213 @@
+[
+  (import_from_statement)
+  (generator_expression)
+  (list_comprehension)
+  (set_comprehension)
+  (dictionary_comprehension)
+  (tuple_pattern)
+  (list_pattern)
+  (binary_operator)
+  (lambda)
+  (concatenated_string)
+] @indent.begin
+
+((list) @indent.align
+  (#set! indent.open_delimiter "[")
+  (#set! indent.close_delimiter "]"))
+
+((dictionary) @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}"))
+
+((set) @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}"))
+
+((parenthesized_expression) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((for_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((if_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((while_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((try_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+(ERROR
+  "try"
+  .
+  ":"
+  (#set! indent.immediate 1)) @indent.begin
+
+(ERROR
+  "try"
+  .
+  ":"
+  (ERROR
+    (block
+      (expression_statement
+        (identifier) @_except) @indent.branch))
+  (#eq? @_except "except"))
+
+((function_definition) @indent.begin
+  (#set! indent.immediate 1))
+
+((class_definition) @indent.begin
+  (#set! indent.immediate 1))
+
+((with_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((match_statement) @indent.begin
+  (#set! indent.immediate 1))
+
+((case_clause) @indent.begin
+  (#set! indent.immediate 1))
+
+; if (cond1
+;     or cond2
+;         or cond3):
+;     pass
+;
+(if_statement
+  condition: (parenthesized_expression) @indent.align
+  (#lua-match? @indent.align "^%([^\n]")
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+; while (
+;     cond1
+;     or cond2
+;         or cond3):
+;     pass
+;
+(while_statement
+  condition: (parenthesized_expression) @indent.align
+  (#lua-match? @indent.align "[^\n ]%)$")
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+; if (
+;     cond1
+;     or cond2
+;         or cond3):
+;     pass
+;
+(if_statement
+  condition: (parenthesized_expression) @indent.align
+  (#lua-match? @indent.align "[^\n ]%)$")
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+(ERROR
+  "(" @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  .
+  (_))
+
+((argument_list) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((parameters) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+((parameters) @indent.align
+  (#lua-match? @indent.align "[^\n ]%)$")
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")")
+  (#set! indent.avoid_last_matching_next 1))
+
+((tuple) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+(ERROR
+  "[" @indent.align
+  (#set! indent.open_delimiter "[")
+  (#set! indent.close_delimiter "]")
+  .
+  (_))
+
+(ERROR
+  "{" @indent.align
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}")
+  .
+  (_))
+
+[
+  (break_statement)
+  (continue_statement)
+] @indent.dedent
+
+(ERROR
+  (_) @indent.branch
+  ":"
+  .
+  (#lua-match? @indent.branch "^else"))
+
+(ERROR
+  (_) @indent.branch @indent.dedent
+  ":"
+  .
+  (#lua-match? @indent.branch "^elif"))
+
+(generator_expression
+  ")" @indent.end)
+
+(list_comprehension
+  "]" @indent.end)
+
+(set_comprehension
+  "}" @indent.end)
+
+(dictionary_comprehension
+  "}" @indent.end)
+
+(tuple_pattern
+  ")" @indent.end)
+
+(list_pattern
+  "]" @indent.end)
+
+(return_statement
+  [
+    (_) @indent.end
+    (_
+      [
+        (_)
+        ")"
+        "}"
+        "]"
+      ] @indent.end .)
+    (attribute
+      attribute: (_) @indent.end)
+    (call
+      arguments: (_
+        ")" @indent.end))
+    "return" @indent.end
+  ] .)
+
+[
+  ")"
+  "]"
+  "}"
+  (elif_clause)
+  (else_clause)
+  (except_clause)
+  (finally_clause)
+] @indent.branch
+
+(string) @indent.auto

package/out/python/injections.scm

@@ -0,0 +1,30 @@
+(call
+  function: (attribute
+    object: (identifier) @_re)
+  arguments: (argument_list
+    (string
+      (string_content) @injection.content))
+  (#eq? @_re "re")
+  (#set! injection.language "regex"))
+
+(call
+  function: (attribute
+    object: (identifier) @_re)
+  arguments: (argument_list
+    (concatenated_string
+      [
+        (string
+          (string_content) @injection.content)
+        (comment)
+      ]+))
+  (#eq? @_re "re")
+  (#set! injection.language "regex"))
+
+((binary_operator
+  left: (string
+    (string_content) @injection.content)
+  operator: "%")
+  (#set! injection.language "printf"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))

package/out/python/locals.scm

@@ -0,0 +1,124 @@
+; Program structure
+(module) @local.scope
+
+(class_definition
+  body: (block
+    (expression_statement
+      (assignment
+        left: (identifier) @local.definition.field)))) @local.scope
+
+(class_definition
+  body: (block
+    (expression_statement
+      (assignment
+        left: (_
+          (identifier) @local.definition.field))))) @local.scope
+
+; Imports
+(aliased_import
+  alias: (identifier) @local.definition.import) @local.scope
+
+(import_statement
+  name: (dotted_name
+    (identifier) @local.definition.import)) @local.scope
+
+(import_from_statement
+  name: (dotted_name
+    (identifier) @local.definition.import)) @local.scope
+
+; Function with parameters, defines parameters
+(parameters
+  (identifier) @local.definition.parameter)
+
+(default_parameter
+  (identifier) @local.definition.parameter)
+
+(typed_parameter
+  (identifier) @local.definition.parameter)
+
+(typed_default_parameter
+  (identifier) @local.definition.parameter)
+
+; *args parameter
+(parameters
+  (list_splat_pattern
+    (identifier) @local.definition.parameter))
+
+; **kwargs parameter
+(parameters
+  (dictionary_splat_pattern
+    (identifier) @local.definition.parameter))
+
+; Function defines function and scope
+((function_definition
+  name: (identifier) @local.definition.function) @local.scope
+  (#set! definition.function.scope "parent"))
+
+((class_definition
+  name: (identifier) @local.definition.type) @local.scope
+  (#set! definition.type.scope "parent"))
+
+(class_definition
+  body: (block
+    (function_definition
+      name: (identifier) @local.definition.method)))
+
+; Loops
+; not a scope!
+(for_statement
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(for_statement
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(for_statement
+  left: (identifier) @local.definition.var)
+
+; not a scope!
+;(while_statement) @local.scope
+; for in list comprehension
+(for_in_clause
+  left: (identifier) @local.definition.var)
+
+(for_in_clause
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(for_in_clause
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(dictionary_comprehension) @local.scope
+
+(list_comprehension) @local.scope
+
+(set_comprehension) @local.scope
+
+; Assignments
+(assignment
+  left: (identifier) @local.definition.var)
+
+(assignment
+  left: (pattern_list
+    (identifier) @local.definition.var))
+
+(assignment
+  left: (tuple_pattern
+    (identifier) @local.definition.var))
+
+(assignment
+  left: (attribute
+    (identifier)
+    (identifier) @local.definition.field))
+
+; Walrus operator  x := 1
+(named_expression
+  (identifier) @local.definition.var)
+
+(as_pattern
+  alias: (as_pattern_target) @local.definition.var)
+
+; REFERENCES
+(identifier) @local.reference

package/out/qmljs/folds.scm

@@ -0,0 +1,8 @@
+[
+  (ui_object_definition)
+  (function_declaration)
+  (statement_block)
+  (if_statement)
+  (ui_binding)
+  (comment)
+] @fold

package/out/qmljs/highlights.scm

@@ -0,0 +1,61 @@
+;;; Annotations
+
+(ui_annotation
+  "@" @operator
+  type_name: [
+    (identifier) @attribute
+    (nested_identifier (identifier) @attribute)
+  ])
+
+;;; Properties
+
+(ui_object_definition_binding
+  name: [
+    (identifier) @property
+    (nested_identifier (identifier) @property)
+  ])
+
+(ui_binding
+  name: [
+    (identifier) @property
+    (nested_identifier (identifier) @property)
+  ])
+
+;; locals query appears not working unless id: <ref> isn't a parameter.
+(ui_binding
+  name: (identifier) @property
+  (#eq? @property "id")
+  value: (expression_statement (identifier) @variable.parameter))
+
+(ui_property
+  name: (identifier) @property)
+
+(ui_required
+  name: (identifier) @property)
+
+(ui_list_property_type
+  ["<" ">"] @punctuation.bracket)
+
+;;; Signals
+
+(ui_signal
+  name: (identifier) @function.signal)
+
+(ui_signal_parameter
+  (identifier) @variable.parameter)
+
+;;; Keywords
+
+[
+  "as"
+  "component"
+  "default"
+  "final"
+  "import"
+  "on"
+  "pragma"
+  "property"
+  "readonly"
+  "required"
+  "signal"
+] @keyword

package/out/qmljs/injections.scm

@@ -0,0 +1 @@
+; inherits: ecma

package/out/qmljs/locals.scm

@@ -0,0 +1,6 @@
+;;; Definitions
+
+(ui_binding
+  name: (identifier) @property
+  (#eq? @property "id")
+  value: (expression_statement (identifier) @local.definition))

package/out/query/folds.scm

@@ -0,0 +1,6 @@
+[
+  (named_node)
+  (predicate)
+  (grouping)
+  (list)
+] @fold

package/out/query/highlights.scm

@@ -0,0 +1,102 @@
+(string) @string
+
+(escape_sequence) @string.escape
+
+(capture
+  (identifier) @type)
+
+(predicate
+  name: (identifier) @function.call)
+
+(named_node
+  name: (identifier) @variable)
+
+(missing_node
+  name: (identifier) @variable)
+
+(field_definition
+  name: (identifier) @variable.member)
+
+(negated_field
+  "!" @operator
+  (identifier) @property)
+
+(comment) @comment @spell
+
+(quantifier) @operator
+
+(predicate_type) @punctuation.special
+
+"." @operator
+
+[
+  "["
+  "]"
+  "("
+  ")"
+] @punctuation.bracket
+
+[
+  ":"
+  "/"
+] @punctuation.delimiter
+
+[
+  "@"
+  "#"
+] @punctuation.special
+
+(predicate
+  "." @punctuation.special)
+
+"_" @character.special
+
+"MISSING" @keyword
+
+((parameters
+  (identifier) @number)
+  (#match? @number "^[-+]?[0-9]+(.[0-9]+)?$"))
+
+((program
+  .
+  (comment)*
+  .
+  (comment) @keyword.import @nospell)
+  (#lua-match? @keyword.import "^;+ *inherits *:"))
+
+((program
+  .
+  (comment)*
+  .
+  (comment) @keyword.directive @nospell)
+  (#lua-match? @keyword.directive "^;+ *extends *$"))
+
+((comment) @keyword.directive @nospell
+  (#lua-match? @keyword.directive "^;+%s*format%-ignore%s*$"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    .
+    (capture)?
+    .
+    (identifier) @property))
+  (#eq? @_name "set"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      "\"" @string
+      "\"" @string) @string.regexp))
+  (#any-of? @_name "match" "not-match" "vim-match" "not-vim-match" "lua-match" "not-lua-match"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      "\"" @string
+      "\"" @string) @string.regexp
+    .
+    (string) .))
+  (#any-of? @_name "gsub" "not-gsub"))

package/out/query/indents.scm

@@ -0,0 +1,25 @@
+[
+  (list)
+  (named_node)
+  (grouping)
+  (predicate)
+  "["
+] @indent.begin
+
+; ERROR node indents
+(ERROR
+  "(") @indent.begin
+
+"]" @indent.branch @indent.end
+
+[
+  ")"
+  "?"
+  "*"
+  "+"
+] @indent.end
+
+; Captures always mark the end of a node
+; Because of that, mark it as indent.end
+(capture
+  name: (identifier) @indent.end)

package/out/query/injections.scm

@@ -0,0 +1,28 @@
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      (string_content) @injection.content)))
+  (#any-of? @_name "match" "not-match" "any-match" "vim-match" "not-vim-match" "any-vim-match")
+  (#set! injection.language "regex"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      (string_content) @injection.content)))
+  (#any-of? @_name "lua-match" "not-lua-match" "any-lua-match")
+  (#set! injection.language "luap"))
+
+((predicate
+  name: (identifier) @_name
+  parameters: (parameters
+    (string
+      (string_content) @injection.content)
+    .
+    (string) .))
+  (#any-of? @_name "gsub" "not-gsub")
+  (#set! injection.language "luap"))
+
+((comment) @injection.content
+  (#set! injection.language "comment"))

package/out/query/locals.scm

@@ -0,0 +1,21 @@
+(program) @local.scope
+
+(program
+  (named_node) @local.scope)
+
+(program
+  (anonymous_node) @local.scope)
+
+(program
+  (grouping) @local.scope)
+
+(identifier) @local.reference
+
+(named_node
+  (capture) @local.definition.var)
+
+(anonymous_node
+  (capture) @local.definition.var)
+
+(grouping
+  (capture) @local.definition.var)

package/out/r/indents.scm

@@ -0,0 +1,33 @@
+[
+  (braced_expression)
+  (parenthesized_expression)
+  (call)
+  "if"
+  "else"
+  "while"
+  "repeat"
+  "for"
+] @indent.begin
+
+(binary_operator
+  rhs: (_) @_no_indent
+  (#not-kind-eq? @_no_indent function_definition)) @indent.begin
+
+[
+  "}"
+  ")"
+] @indent.branch
+
+((parameters
+  .
+  (parameter
+    name: (identifier))) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+[
+  ")"
+  "}"
+] @indent.end
+
+(comment) @indent.ignore

package/out/r/injections.scm

@@ -0,0 +1,2 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))

package/out/racket/folds.scm

@@ -0,0 +1,2 @@
+(program
+  (list) @fold)

package/out/racket/injections.scm

@@ -0,0 +1,5 @@
+([
+  (comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))

package/out/ruby/folds.scm

@@ -0,0 +1,12 @@
+[
+  (method)
+  (singleton_method)
+  (class)
+  (module)
+  (if)
+  (else)
+  (case)
+  (do_block)
+  (singleton_class)
+  (lambda)
+] @fold