ts-wasms 1.0.2 → 1.0.3

package/out/julia/highlights.scm

@@ -0,0 +1,375 @@
+; Identifiers
+(identifier) @variable
+
+(field_expression
+  (identifier) @variable.member .)
+
+; Symbols
+(quote_expression
+  ":" @string.special.symbol
+  [
+    (identifier)
+    (operator)
+  ] @string.special.symbol)
+
+; Function calls
+(call_expression
+  (identifier) @function.call)
+
+(call_expression
+  (field_expression
+    (identifier) @function.call .))
+
+(broadcast_call_expression
+  (identifier) @function.call)
+
+(broadcast_call_expression
+  (field_expression
+    (identifier) @function.call .))
+
+(binary_expression
+  (_)
+  (operator) @_pipe
+  (identifier) @function.call
+  (#any-of? @_pipe "|>" ".|>"))
+
+; Macros
+(macro_identifier
+  "@" @function.macro
+  (identifier) @function.macro)
+
+(macro_definition
+  (signature
+    (call_expression
+      .
+      (identifier) @function.macro)))
+
+; Built-in functions
+; print.("\"", filter(name -> getglobal(Core, name) isa Core.Builtin, names(Core)), "\" ")
+((identifier) @function.builtin
+  (#any-of? @function.builtin
+    "applicable" "fieldtype" "getfield" "getglobal" "invoke" "isa" "isdefined" "isdefinedglobal"
+    "modifyfield!" "modifyglobal!" "nfields" "replacefield!" "replaceglobal!" "setfield!"
+    "setfieldonce!" "setglobal!" "setglobalonce!" "swapfield!" "swapglobal!" "throw" "tuple"
+    "typeassert" "typeof"))
+
+; Type definitions
+(type_head
+  (_) @type.definition)
+
+; Type annotations
+(parametrized_type_expression
+  [
+    (identifier) @type
+    (field_expression
+      (identifier) @type .)
+  ]
+  (curly_expression
+    (_) @type))
+
+(typed_expression
+  (identifier) @type .)
+
+(unary_typed_expression
+  (identifier) @type .)
+
+(where_expression
+  [
+    (curly_expression
+      (_) @type)
+    (_) @type
+  ] .)
+
+(unary_expression
+  (operator) @operator
+  (_) @type
+  (#any-of? @operator "<:" ">:"))
+
+(binary_expression
+  (_) @type
+  (operator) @operator
+  (_) @type
+  (#any-of? @operator "<:" ">:"))
+
+; Built-in types
+; print.("\"", filter(name -> typeof(Base.eval(Core, name)) in [DataType, UnionAll], names(Core)), "\" ")
+((identifier) @type.builtin
+  (#any-of? @type.builtin
+    "AbstractArray" "AbstractChar" "AbstractFloat" "AbstractString" "Any" "ArgumentError" "Array"
+    "AssertionError" "AtomicMemory" "AtomicMemoryRef" "Bool" "BoundsError" "Char"
+    "ConcurrencyViolationError" "Cvoid" "DataType" "DenseArray" "DivideError" "DomainError"
+    "ErrorException" "Exception" "Expr" "FieldError" "Float16" "Float32" "Float64" "Function"
+    "GenericMemory" "GenericMemoryRef" "GlobalRef" "IO" "InexactError" "InitError" "Int" "Int128"
+    "Int16" "Int32" "Int64" "Int8" "Integer" "InterruptException" "LineNumberNode" "LoadError"
+    "Memory" "MemoryRef" "Method" "MethodError" "Module" "NTuple" "NamedTuple" "Nothing" "Number"
+    "OutOfMemoryError" "OverflowError" "Pair" "Ptr" "QuoteNode" "ReadOnlyMemoryError" "Real" "Ref"
+    "SegmentationFault" "Signed" "StackOverflowError" "String" "Symbol" "Task" "Tuple" "Type"
+    "TypeError" "TypeVar" "UInt" "UInt128" "UInt16" "UInt32" "UInt64" "UInt8" "UndefInitializer"
+    "UndefKeywordError" "UndefRefError" "UndefVarError" "Union" "UnionAll" "Unsigned" "VecElement"
+    "WeakRef"))
+
+; Keywords
+[
+  "global"
+  "local"
+] @keyword
+
+(compound_statement
+  [
+    "begin"
+    "end"
+  ] @keyword)
+
+(quote_statement
+  [
+    "quote"
+    "end"
+  ] @keyword)
+
+(let_statement
+  [
+    "let"
+    "end"
+  ] @keyword)
+
+(if_statement
+  [
+    "if"
+    "end"
+  ] @keyword.conditional)
+
+(elseif_clause
+  "elseif" @keyword.conditional)
+
+(else_clause
+  "else" @keyword.conditional)
+
+(ternary_expression
+  [
+    "?"
+    ":"
+  ] @keyword.conditional.ternary)
+
+(try_statement
+  [
+    "try"
+    "end"
+  ] @keyword.exception)
+
+(catch_clause
+  "catch" @keyword.exception)
+
+(finally_clause
+  "finally" @keyword.exception)
+
+(for_statement
+  [
+    "for"
+    "end"
+  ] @keyword.repeat)
+
+(for_binding
+  "outer" @keyword.repeat)
+
+; comprehensions
+(for_clause
+  "for" @keyword.repeat)
+
+(if_clause
+  "if" @keyword.conditional)
+
+(while_statement
+  [
+    "while"
+    "end"
+  ] @keyword.repeat)
+
+[
+  (break_statement)
+  (continue_statement)
+] @keyword.repeat
+
+[
+  "const"
+  "mutable"
+] @keyword.modifier
+
+(function_definition
+  [
+    "function"
+    "end"
+  ] @keyword.function)
+
+(do_clause
+  [
+    "do"
+    "end"
+  ] @keyword.function)
+
+(macro_definition
+  [
+    "macro"
+    "end"
+  ] @keyword)
+
+(return_statement
+  "return" @keyword.return)
+
+(module_definition
+  [
+    "module"
+    "baremodule"
+    "end"
+  ] @keyword.import)
+
+(export_statement
+  "export" @keyword.import)
+
+(public_statement
+  "public" @keyword.import)
+
+(import_statement
+  "import" @keyword.import)
+
+(using_statement
+  "using" @keyword.import)
+
+(import_alias
+  "as" @keyword.import)
+
+(selected_import
+  ":" @punctuation.delimiter)
+
+(struct_definition
+  [
+    "mutable"
+    "struct"
+    "end"
+  ] @keyword.type)
+
+(abstract_definition
+  [
+    "abstract"
+    "type"
+    "end"
+  ] @keyword.type)
+
+(primitive_definition
+  [
+    "primitive"
+    "type"
+    "end"
+  ] @keyword.type)
+
+; Operators & Punctuation
+(operator) @operator
+
+(adjoint_expression
+  "'" @operator)
+
+(range_expression
+  ":" @operator)
+
+(arrow_function_expression
+  "->" @operator)
+
+[
+  "."
+  "..."
+] @punctuation.special
+
+[
+  ","
+  ";"
+  "::"
+] @punctuation.delimiter
+
+; Treat `::` as operator in type contexts, see
+; https://github.com/nvim-treesitter/nvim-treesitter/pull/7392
+(typed_expression
+  "::" @operator)
+
+(unary_typed_expression
+  "::" @operator)
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Interpolation
+(string_interpolation
+  .
+  "$" @punctuation.special)
+
+(interpolation_expression
+  .
+  "$" @punctuation.special)
+
+; Keyword operators
+((operator) @keyword.operator
+  (#any-of? @keyword.operator "in" "isa"))
+
+(where_expression
+  "where" @keyword.operator)
+
+; Built-in constants
+((identifier) @constant.builtin
+  (#any-of? @constant.builtin "nothing" "missing"))
+
+((identifier) @variable.builtin
+  (#any-of? @variable.builtin "begin" "end")
+  (#has-ancestor? @variable.builtin index_expression))
+
+; Literals
+(boolean_literal) @boolean
+
+(integer_literal) @number
+
+(float_literal) @number.float
+
+((identifier) @number.float
+  (#any-of? @number.float "NaN" "NaN16" "NaN32" "Inf" "Inf16" "Inf32"))
+
+(character_literal) @character
+
+(escape_sequence) @string.escape
+
+(string_literal) @string
+
+(prefixed_string_literal
+  prefix: (identifier) @function.macro) @string
+
+(command_literal) @string.special
+
+(prefixed_command_literal
+  prefix: (identifier) @function.macro) @string.special
+
+((string_literal) @string.documentation
+  .
+  [
+    (abstract_definition)
+    (assignment)
+    (const_statement)
+    (function_definition)
+    (macro_definition)
+    (module_definition)
+    (struct_definition)
+  ])
+
+(source_file
+  (string_literal) @string.documentation
+  .
+  [
+    (identifier)
+    (call_expression)
+  ])
+
+[
+  (line_comment)
+  (block_comment)
+] @comment

package/out/julia/injections.scm

@@ -0,0 +1,42 @@
+; Inject markdown in docstrings
+((string_literal
+  (content) @injection.content)
+  .
+  [
+    (module_definition)
+    (abstract_definition)
+    (struct_definition)
+    (function_definition)
+    (macro_definition)
+    (assignment)
+    (const_statement)
+    (call_expression)
+    (identifier)
+  ]
+  (#set! injection.language "markdown"))
+
+; Inject comments
+([
+  (line_comment)
+  (block_comment)
+] @injection.content
+  (#set! injection.language "comment"))
+
+; Inject regex in r"..." and r"""...""" (e.g. r"hello\bworld")
+(prefixed_string_literal
+  prefix: (identifier) @_prefix
+  (content) @injection.content
+  (#eq? @_prefix "r")
+  (#set! injection.language "regex"))
+
+; Inject markdown in md"..." and md"""...""" (e.g. md"**Bold** and _Italics_")
+(prefixed_string_literal
+  prefix: (identifier) @_prefix
+  (content) @injection.content
+  (#eq? @_prefix "md")
+  (#set! injection.language "markdown"))
+
+; Inject bash in `...` and ```...``` (e.g. `git add --help`)
+(command_literal
+  (content) @injection.content
+  (#set! injection.language "bash"))

package/out/julia/locals.scm

@@ -0,0 +1,71 @@
+; References
+(identifier) @local.reference
+
+; Definitions
+(assignment
+  .
+  (identifier) @local.definition)
+
+(assignment
+  .
+  (tuple_expression
+    (identifier) @local.definition))
+
+(assignment
+  .
+  (open_tuple
+    (identifier) @local.definition))
+
+(for_binding
+  .
+  (identifier) @local.definition)
+
+(for_binding
+  .
+  (tuple_expression
+    (identifier) @local.definition))
+
+(import_statement
+  (identifier) @local.definition)
+
+(using_statement
+  (identifier) @local.definition)
+
+(selected_import
+  (identifier) @local.definition)
+
+(module_definition
+  .
+  (identifier) @local.definition)
+
+(type_head
+  (identifier) @local.definition)
+
+(type_head
+  (binary_expression
+    .
+    (identifier) @local.definition))
+
+(function_definition
+  (signature
+    (call_expression
+      .
+      (identifier) @local.definition.function))) @local.scope
+
+(macro_definition
+  (signature
+    (call_expression
+      .
+      (identifier) @local.definition.function))) @local.scope
+
+; Scopes
+[
+  (quote_statement)
+  (let_statement)
+  (for_statement)
+  (while_statement)
+  (try_statement)
+  (catch_clause)
+  (finally_clause)
+  (do_clause)
+] @local.scope

package/out/lua/highlights.scm

@@ -0,0 +1,201 @@
+; Keywords
+"return" @keyword.return
+
+[
+  "goto"
+  "in"
+  "local"
+] @keyword
+
+(label_statement) @label
+
+(break_statement) @keyword
+
+(do_statement
+  [
+    "do"
+    "end"
+  ] @keyword)
+
+(while_statement
+  [
+    "while"
+    "do"
+    "end"
+  ] @repeat)
+
+(repeat_statement
+  [
+    "repeat"
+    "until"
+  ] @repeat)
+
+(if_statement
+  [
+    "if"
+    "elseif"
+    "else"
+    "then"
+    "end"
+  ] @conditional)
+
+(elseif_statement
+  [
+    "elseif"
+    "then"
+    "end"
+  ] @conditional)
+
+(else_statement
+  [
+    "else"
+    "end"
+  ] @conditional)
+
+(for_statement
+  [
+    "for"
+    "do"
+    "end"
+  ] @repeat)
+
+(function_declaration
+  [
+    "function"
+    "end"
+  ] @keyword.function)
+
+(function_definition
+  [
+    "function"
+    "end"
+  ] @keyword.function)
+
+; Operators
+(binary_expression
+  operator: _ @operator)
+
+(unary_expression
+  operator: _ @operator)
+
+[
+  "and"
+  "not"
+  "or"
+] @keyword.operator
+
+; Punctuations
+[
+  ";"
+  ":"
+  ","
+  "."
+] @punctuation.delimiter
+
+; Brackets
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Variables
+(identifier) @variable
+
+((identifier) @variable.builtin
+  (#eq? @variable.builtin "self"))
+
+(variable_list
+  (attribute
+    "<" @punctuation.bracket
+    (identifier) @attribute
+    ">" @punctuation.bracket))
+
+; Constants
+((identifier) @constant
+  (#match? @constant "^[A-Z][A-Z_0-9]*$"))
+
+(vararg_expression) @constant
+
+(nil) @constant.builtin
+
+[
+  (false)
+  (true)
+] @boolean
+
+; Tables
+(field
+  name: (identifier) @field)
+
+(dot_index_expression
+  field: (identifier) @field)
+
+(table_constructor
+  [
+    "{"
+    "}"
+  ] @constructor)
+
+; Functions
+(parameters
+  (identifier) @parameter)
+
+(function_declaration
+  name: [
+    (identifier) @function
+    (dot_index_expression
+      field: (identifier) @function)
+  ])
+
+(function_declaration
+  name: (method_index_expression
+    method: (identifier) @method))
+
+(assignment_statement
+  (variable_list
+    .
+    name: [
+      (identifier) @function
+      (dot_index_expression
+        field: (identifier) @function)
+    ])
+  (expression_list
+    .
+    value: (function_definition)))
+
+(table_constructor
+  (field
+    name: (identifier) @function
+    value: (function_definition)))
+
+(function_call
+  name: [
+    (identifier) @function.call
+    (dot_index_expression
+      field: (identifier) @function.call)
+    (method_index_expression
+      method: (identifier) @method.call)
+  ])
+
+(function_call
+  (identifier) @function.builtin
+  (#any-of? @function.builtin
+    ; built-in functions in Lua 5.1
+    "assert" "collectgarbage" "dofile" "error" "getfenv" "getmetatable" "ipairs" "load" "loadfile"
+    "loadstring" "module" "next" "pairs" "pcall" "print" "rawequal" "rawget" "rawset" "require"
+    "select" "setfenv" "setmetatable" "tonumber" "tostring" "type" "unpack" "xpcall"))
+
+; Others
+(comment) @comment
+
+(hash_bang_line) @preproc
+
+(number) @number
+
+(string) @string
+
+(escape_sequence) @string.escape

package/out/lua/injections.scm

@@ -0,0 +1,12 @@
+((function_call
+  name: [
+    (identifier) @_cdef_identifier
+    (_
+      _
+      (identifier) @_cdef_identifier)
+  ]
+  arguments: (arguments
+    (string
+      content: _ @injection.content
+      (#set! injection.language "c"))))
+  (#eq? @_cdef_identifier "cdef"))