ts-wasms 1.0.2

package/out/dart/highlights.scm

@@ -0,0 +1,224 @@
+(dotted_identifier_list) @string
+
+; Methods
+; --------------------
+;; TODO: does not work
+;(function_type
+  ;name: (identifier) @method)
+(super) @function
+
+; Annotations
+; --------------------
+(annotation
+  name: (identifier) @attribute)
+(marker_annotation
+  name: (identifier) @attribute)
+
+; Operators and Tokens
+; --------------------
+(template_substitution
+  "$" @punctuation.special
+  "{" @punctuation.special
+  "}" @punctuation.special
+) @none
+
+(template_substitution
+  "$" @punctuation.special
+  (identifier_dollar_escaped) @variable
+) @none
+
+(escape_sequence) @string.escape
+
+[
+ "@"
+ "=>"
+ ".."
+ "??"
+ "=="
+ "?"
+ ":"
+ "&&"
+ "%"
+ "<"
+ ">"
+ "="
+ ">="
+ "<="
+ "||"
+ (increment_operator)
+ (is_operator)
+ (prefix_operator)
+ (equality_operator)
+ (additive_operator)
+] @operator
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+]  @punctuation.bracket
+
+; Delimiters
+; --------------------
+[
+  ";"
+  "."
+  ","
+] @punctuation.delimiter
+
+; Types
+; --------------------
+(class_definition
+  name: (identifier) @type)
+(constructor_signature
+  name: (identifier) @type)
+;; TODO: does not work
+;(type_identifier
+  ;(identifier) @type)
+(scoped_identifier
+  scope: (identifier) @type)
+(function_signature
+  name: (identifier) @method)
+(getter_signature
+  (identifier) @method)
+(setter_signature
+  name: (identifier) @method)
+(enum_declaration
+  name: (identifier) @type)
+(enum_constant
+  name: (identifier) @type)
+(type_identifier) @type
+(void_type) @type
+
+((scoped_identifier
+  scope: (identifier) @type
+  name: (identifier) @type)
+ (#match? @type "^[a-zA-Z]"))
+
+(type_identifier) @type
+
+; Variables
+; --------------------
+; var keyword
+(inferred_type) @keyword
+
+(const_builtin) @constant.builtin
+(final_builtin) @constant.builtin
+
+((identifier) @type
+ (#match? @type "^_?[A-Z]"))
+
+("Function" @type)
+
+; properties
+; TODO: add method/call_expression to grammar and
+; distinguish method call from variable access
+(unconditional_assignable_selector
+  (identifier) @property)
+
+; assignments
+(assignment_expression
+  left: (assignable_expression) @variable)
+
+(this) @variable.builtin
+
+; Parameters
+; --------------------
+(formal_parameter
+    name: (identifier) @parameter)
+
+(named_argument
+  (label (identifier) @parameter))
+
+; Literals
+; --------------------
+[
+    (hex_integer_literal)
+    (decimal_integer_literal)
+    (decimal_floating_point_literal)
+    ; TODO: inaccessbile nodes
+    ; (octal_integer_literal)
+    ; (hex_floating_point_literal)
+] @number
+
+(symbol_literal) @symbol
+(string_literal) @string
+(true) @boolean
+(false) @boolean
+(null_literal) @constant.builtin
+
+(documentation_comment) @comment
+(comment) @comment
+
+; Keywords
+; --------------------
+["import" "library" "export"] @include
+
+; Reserved words (cannot be used as identifiers)
+; TODO: "rethrow" @keyword
+[
+    ; "assert"
+    (case_builtin)
+    "extension"
+    "on"
+    "class"
+    "enum"
+    "extends"
+    "in"
+    "is"
+    "new"
+    "return"
+    "super"
+    "with"
+] @keyword
+
+
+; Built in identifiers:
+; alone these are marked as keywords
+[
+    "abstract"
+    "as"
+    "async"
+    "async*"
+    "yield"
+    "sync*"
+    "await"
+    "covariant"
+    "deferred"
+    "dynamic"
+    "external"
+    "factory"
+    "get"
+    "implements"
+    "interface"
+    "library"
+    "operator"
+    "mixin"
+    "part"
+    "set"
+    "show"
+    "static"
+    "typedef"
+] @keyword
+
+; when used as an identifier:
+((identifier) @variable.builtin
+ (#vim-match? @variable.builtin "^(abstract|as|covariant|deferred|dynamic|export|external|factory|Function|get|implements|import|interface|library|operator|mixin|part|set|static|typedef)$"))
+
+["if" "else" "switch" "default"] @conditional
+
+[
+  "try"
+  "throw"
+  "catch"
+  "finally"
+  (break_statement)
+] @exception
+
+["do" "while" "continue" "for"] @repeat
+
+; Error
+(ERROR) @error

package/out/elisp/highlights.scm

@@ -0,0 +1,72 @@
+;; Special forms
+[
+  "and"
+  "catch"
+  "cond"
+  "condition-case"
+  "defconst"
+  "defvar"
+  "function"
+  "if"
+  "interactive"
+  "lambda"
+  "let"
+  "let*"
+  "or"
+  "prog1"
+  "prog2"
+  "progn"
+  "quote"
+  "save-current-buffer"
+  "save-excursion"
+  "save-restriction"
+  "setq"
+  "setq-default"
+  "unwind-protect"
+  "while"
+] @keyword
+
+;; Function definitions
+[
+ "defun"
+ "defsubst"
+ ] @keyword
+(function_definition name: (symbol) @function)
+(function_definition parameters: (list (symbol) @variable.parameter))
+(function_definition docstring: (string) @comment)
+
+;; Highlight macro definitions the same way as function definitions.
+"defmacro" @keyword
+(macro_definition name: (symbol) @function)
+(macro_definition parameters: (list (symbol) @variable.parameter))
+(macro_definition docstring: (string) @comment)
+
+(comment) @comment
+
+(integer) @number
+(float) @number
+(char) @number
+
+(string) @string
+
+[
+  "("
+  ")"
+  "#["
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  "`"
+  "#'"
+  "'"
+  ","
+  ",@"
+] @operator
+
+;; Highlight nil and t as constants, unlike other symbols
+[
+  "nil"
+  "t"
+] @constant.builtin

package/out/elisp/tags.scm

@@ -0,0 +1,5 @@
+;; defun/defsubst
+(function_definition name: (symbol) @name) @definition.function
+
+;; Treat macros as function definitions for the sake of TAGS.
+(macro_definition name: (symbol) @name) @definition.function

package/out/elixir/highlights.scm

@@ -0,0 +1,223 @@
+; Punctuation
+
+[
+ "%"
+] @punctuation
+
+[
+ ","
+ ";"
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "<<"
+  ">>"
+] @punctuation.bracket
+
+; Literals
+
+[
+  (boolean)
+  (nil)
+] @constant
+
+[
+  (integer)
+  (float)
+] @number
+
+(char) @constant
+
+; Identifiers
+
+; * regular
+(identifier) @variable
+
+; * unused
+(
+  (identifier) @comment.unused
+  (#match? @comment.unused "^_")
+)
+
+; * special
+(
+  (identifier) @constant.builtin
+  (#any-of? @constant.builtin "__MODULE__" "__DIR__" "__ENV__" "__CALLER__" "__STACKTRACE__")
+)
+
+; Comment
+
+(comment) @comment
+
+; Quoted content
+
+(interpolation "#{" @punctuation.special "}" @punctuation.special) @embedded
+
+(escape_sequence) @string.escape
+
+[
+  (string)
+  (charlist)
+] @string
+
+[
+  (atom)
+  (quoted_atom)
+  (keyword)
+  (quoted_keyword)
+] @string.special.symbol
+
+; Note that we explicitly target sigil quoted start/end, so they are not overridden by delimiters
+
+(sigil
+  (sigil_name) @__name__
+  quoted_start: _ @string.special
+  quoted_end: _ @string.special) @string.special
+
+(sigil
+  (sigil_name) @__name__
+  quoted_start: _ @string
+  quoted_end: _ @string
+  (#match? @__name__ "^[sS]$")) @string
+
+(sigil
+  (sigil_name) @__name__
+  quoted_start: _ @string.regex
+  quoted_end: _ @string.regex
+  (#match? @__name__ "^[rR]$")) @string.regex
+
+; Calls
+
+; * local function call
+(call
+  target: (identifier) @function)
+
+; * remote function call
+(call
+  target: (dot
+    right: (identifier) @function))
+
+; * field without parentheses or block
+(call
+  target: (dot
+    right: (identifier) @property)
+  .)
+
+; * remote call without parentheses or block (overrides above)
+(call
+  target: (dot
+    left: [
+      (alias)
+      (atom)
+    ]
+    right: (identifier) @function)
+  .)
+
+; * definition keyword
+(call
+  target: (identifier) @keyword
+  (#any-of? @keyword "def" "defdelegate" "defexception" "defguard" "defguardp" "defimpl" "defmacro" "defmacrop" "defmodule" "defn" "defnp" "defoverridable" "defp" "defprotocol" "defstruct"))
+
+; * kernel or special forms keyword
+(call
+  target: (identifier) @keyword
+  (#any-of? @keyword "alias" "case" "cond" "for" "if" "import" "quote" "raise" "receive" "require" "reraise" "super" "throw" "try" "unless" "unquote" "unquote_splicing" "use" "with"))
+
+; * just identifier in function definition
+(call
+  target: (identifier) @keyword
+  (arguments
+    [
+      (identifier) @function
+      (binary_operator
+        left: (identifier) @function
+        operator: "when")
+    ])
+  (#any-of? @keyword "def" "defdelegate" "defguard" "defguardp" "defmacro" "defmacrop" "defn" "defnp" "defp"))
+
+; * pipe into identifier (function call)
+(binary_operator
+  operator: "|>"
+  right: (identifier) @function)
+
+; * pipe into identifier (definition)
+(call
+  target: (identifier) @keyword
+  (arguments
+    (binary_operator
+      operator: "|>"
+      right: (identifier) @variable))
+  (#any-of? @keyword "def" "defdelegate" "defguard" "defguardp" "defmacro" "defmacrop" "defn" "defnp" "defp"))
+
+; * pipe into field without parentheses (function call)
+(binary_operator
+  operator: "|>"
+  right: (call
+    target: (dot
+      right: (identifier) @function)))
+
+; Operators
+
+; * capture operand
+(unary_operator
+  operator: "&"
+  operand: (integer) @operator)
+
+(operator_identifier) @operator
+
+(unary_operator
+  operator: _ @operator)
+
+(binary_operator
+  operator: _ @operator)
+
+(dot
+  operator: _ @operator)
+
+(stab_clause
+  operator: _ @operator)
+
+; * module attribute
+(unary_operator
+  operator: "@" @attribute
+  operand: [
+    (identifier) @attribute
+    (call
+      target: (identifier) @attribute)
+    (boolean) @attribute
+    (nil) @attribute
+  ])
+
+; * doc string
+(unary_operator
+  operator: "@" @comment.doc
+  operand: (call
+    target: (identifier) @comment.doc.__attribute__
+    (arguments
+      [
+        (string) @comment.doc
+        (charlist) @comment.doc
+        (sigil
+          quoted_start: _ @comment.doc
+          quoted_end: _ @comment.doc) @comment.doc
+        (boolean) @comment.doc
+      ]))
+  (#any-of? @comment.doc.__attribute__ "moduledoc" "typedoc" "doc"))
+
+; Module
+
+(alias) @module
+
+(call
+  target: (dot
+    left: (atom) @module))
+
+; Reserved keywords
+
+["when" "and" "or" "not" "in" "not in" "fn" "do" "end" "catch" "rescue" "after" "else"] @keyword

package/out/elixir/injections.scm

@@ -0,0 +1,55 @@
+; Phoenix HTML template
+((sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content)
+ (#any-of? @_sigil_name "H" "LVN" "HOLO")
+ (#set! injection.language "heex")
+ (#set! injection.combined))
+
+; Regex
+((sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content)
+ (#any-of? @_sigil_name "r" "R")
+ (#set! injection.language "regex")
+ (#set! injection.combined))
+
+; SQL injection
+((sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content)
+ (#eq? @_sigil_name "SQL")
+ (#set! injection.language "sql")
+ (#set! injection.combined))
+
+; Markdown
+((sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content)
+ (#eq? @_sigil_name "MD")
+ (#set! injection.language "markdown")
+ (#set! injection.combined))
+
+; Python
+((sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content)
+ (#eq? @_sigil_name "PY")
+ (#set! injection.language "python")
+ (#set! injection.combined))
+
+; JavaScript
+((sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content)
+ (#eq? @_sigil_name "JS")
+ (#set! injection.language "javascript")
+ (#set! injection.combined))
+
+; Vue
+((sigil
+  (sigil_name) @_sigil_name
+  (quoted_content) @injection.content)
+ (#eq? @_sigil_name "VUE")
+ (#set! injection.language "vue")
+ (#set! injection.combined))

package/out/elixir/tags.scm

@@ -0,0 +1,54 @@
+; Definitions
+
+; * modules and protocols
+(call
+  target: (identifier) @ignore
+  (arguments (alias) @name)
+  (#any-of? @ignore "defmodule" "defprotocol")) @definition.module
+
+; * functions/macros
+(call
+  target: (identifier) @ignore
+  (arguments
+    [
+      ; zero-arity functions with no parentheses
+      (identifier) @name
+      ; regular function clause
+      (call target: (identifier) @name)
+      ; function clause with a guard clause
+      (binary_operator
+        left: (call target: (identifier) @name)
+        operator: "when")
+    ])
+  (#any-of? @ignore "def" "defp" "defdelegate" "defguard" "defguardp" "defmacro" "defmacrop" "defn" "defnp")) @definition.function
+
+; References
+
+; ignore calls to kernel/special-forms keywords
+(call
+  target: (identifier) @ignore
+  (#any-of? @ignore "def" "defp" "defdelegate" "defguard" "defguardp" "defmacro" "defmacrop" "defn" "defnp" "defmodule" "defprotocol" "defimpl" "defstruct" "defexception" "defoverridable" "alias" "case" "cond" "else" "for" "if" "import" "quote" "raise" "receive" "require" "reraise" "super" "throw" "try" "unless" "unquote" "unquote_splicing" "use" "with"))
+
+; ignore module attributes
+(unary_operator
+  operator: "@"
+  operand: (call
+    target: (identifier) @ignore))
+
+; * function call
+(call
+  target: [
+   ; local
+   (identifier) @name
+   ; remote
+   (dot
+     right: (identifier) @name)
+  ]) @reference.call
+
+; * pipe into function call
+(binary_operator
+  operator: "|>"
+  right: (identifier) @name) @reference.call
+
+; * modules
+(alias) @name @reference.module

package/out/embedded-template/highlights.scm

@@ -0,0 +1,12 @@
+(comment_directive) @comment
+
+[
+  "<%#"
+  "<%"
+  "<%="
+  "<%_"
+  "<%-"
+  "%>"
+  "-%>"
+  "_%>"
+] @keyword

package/out/embedded-template/injections-ejs.scm

@@ -0,0 +1,7 @@
+((content) @injection.content
+ (#set! injection.language "html")
+ (#set! injection.combined))
+
+((code) @injection.content
+ (#set! injection.language "javascript")
+ (#set! injection.combined))

package/out/embedded-template/injections-erb.scm

@@ -0,0 +1,7 @@
+((content) @injection.content
+ (#set! injection.language "html")
+ (#set! injection.combined))
+
+((code) @injection.content
+ (#set! injection.language "ruby")
+ (#set! injection.combined))

package/out/embedded-template/injections-etlua.scm

@@ -0,0 +1,7 @@
+((content) @injection.content
+ (#set! injection.language "html")
+ (#set! injection.combined))
+
+((code) @injection.content
+ (#set! injection.language "lua")
+ (#set! injection.combined))