ts-wasms 1.0.6 → 2.0.0

package/out/matlab/highlights.scm

@@ -0,0 +1,218 @@
+; Includes
+((command_name) @keyword.import
+  (#eq? @keyword.import "import"))
+
+; Keywords
+[
+  "arguments"
+  "end"
+  "events"
+  "global"
+  "methods"
+  "persistent"
+  "properties"
+] @keyword
+
+"enumeration" @keyword.type
+
+(class_definition
+  [
+    "classdef"
+    "end"
+  ] @keyword.type)
+
+; Conditionals
+(if_statement
+  [
+    "if"
+    "end"
+  ] @keyword.conditional)
+
+(elseif_clause
+  "elseif" @keyword.conditional)
+
+(else_clause
+  "else" @keyword.conditional)
+
+(switch_statement
+  [
+    "switch"
+    "end"
+  ] @keyword.conditional)
+
+(case_clause
+  "case" @keyword.conditional)
+
+(otherwise_clause
+  "otherwise" @keyword.conditional)
+
+(break_statement) @keyword.conditional
+
+; Repeats
+(for_statement
+  [
+    "for"
+    "parfor"
+    "end"
+  ] @keyword.repeat)
+
+(while_statement
+  [
+    "while"
+    "end"
+  ] @keyword.repeat)
+
+(continue_statement) @keyword.repeat
+
+; Exceptions
+(try_statement
+  [
+    "try"
+    "end"
+  ] @keyword.exception)
+
+(catch_clause
+  "catch" @keyword.exception)
+
+; Variables
+(identifier) @variable
+
+; Constants
+(events
+  (identifier) @constant)
+
+(attribute
+  (identifier) @constant)
+
+"~" @constant.builtin
+
+; Fields/Properties
+(field_expression
+  field: (identifier) @variable.member)
+
+(superclass
+  "."
+  (identifier) @variable.member)
+
+(property_name
+  "."
+  (identifier) @variable.member)
+
+(property
+  name: (identifier) @variable.member)
+
+; Types
+(class_definition
+  name: (identifier) @type)
+
+(attributes
+  (identifier) @constant)
+
+(enum
+  .
+  (identifier) @type)
+
+((identifier) @type
+  (#lua-match? @type "^_*[A-Z][a-zA-Z0-9_]+$"))
+
+; Functions
+(function_definition
+  "function" @keyword.function
+  name: (identifier) @function
+  [
+    "end"
+    "endfunction"
+  ]? @keyword.function)
+
+(function_signature
+  name: (identifier) @function)
+
+(function_call
+  name: (identifier) @function.call)
+
+(handle_operator
+  (identifier) @function)
+
+(validation_functions
+  (identifier) @function)
+
+(command
+  (command_name) @function.call)
+
+(command_argument) @variable.parameter
+
+(return_statement) @keyword.return
+
+; Parameters
+(function_arguments
+  (identifier) @variable.parameter)
+
+; Punctuation
+[
+  ";"
+  ","
+  "."
+] @punctuation.delimiter
+
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+] @punctuation.bracket
+
+; Operators
+[
+  "+"
+  ".+"
+  "-"
+  ".*"
+  "*"
+  "/"
+  "./"
+  "\\"
+  ".\\"
+  "^"
+  ".^"
+  "'"
+  ".'"
+  "|"
+  "&"
+  "?"
+  "@"
+  "<"
+  "<="
+  ">"
+  ">="
+  "=="
+  "~="
+  "="
+  "&&"
+  "||"
+  ":"
+] @operator
+
+; Literals
+(string) @string
+
+(escape_sequence) @string.escape
+
+(formatting_sequence) @string.special
+
+(number) @number
+
+((identifier) @boolean
+  (#eq? @boolean "true"))
+
+((identifier) @boolean
+  (#eq? @boolean "false"))
+
+; Comments
+(comment) @comment @spell
+
+(line_continuation) @punctuation.special
+
+((comment) @keyword.directive
+  (#lua-match? @keyword.directive "^%%%% "))

package/out/matlab/indents.scm

@@ -0,0 +1,40 @@
+"end" @indent.end @indent.branch
+
+[
+  (arguments_statement)
+  (if_statement)
+  (for_statement)
+  (while_statement)
+  (switch_statement)
+  (try_statement)
+  (function_definition)
+  (class_definition)
+  (enumeration)
+  (events)
+  (methods)
+  (properties)
+] @indent.begin
+
+[
+  "elseif"
+  "else"
+  "case"
+  "otherwise"
+  "catch"
+] @indent.branch
+
+((matrix
+  (row) @indent.align)
+  (#set! indent.open_delimiter "[")
+  (#set! indent.close_delimiter "]"))
+
+((cell
+  (row) @indent.align)
+  (#set! indent.open_delimiter "{")
+  (#set! indent.close_delimiter "}"))
+
+((parenthesis) @indent.align
+  (#set! indent.open_delimiter "(")
+  (#set! indent.close_delimiter ")"))
+
+(comment) @indent.auto

package/out/matlab/injections.scm

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

package/out/matlab/locals.scm

@@ -0,0 +1,33 @@
+; References
+(identifier) @local.reference
+
+; Definitions
+(function_definition
+  name: (identifier) @local.definition.function
+  (function_arguments
+    (identifier)* @local.definition.parameter
+    (","
+      (identifier) @local.definition.parameter)*)?) @local.scope
+
+(assignment
+  left: (identifier) @local.definition.var)
+
+(multioutput_variable
+  (identifier) @local.definition.var)
+
+(iterator
+  .
+  (identifier) @local.definition.var)
+
+(lambda
+  (arguments
+    (identifier) @local.definition.parameter))
+
+(global_operator
+  (identifier) @local.definition.var)
+
+(persistent_operator
+  (identifier) @local.definition.var)
+
+(catch_clause
+  (identifier) @local.definition)

package/out/nim/folds.scm

@@ -0,0 +1,41 @@
+[
+  (const_section)
+  (var_section)
+  (let_section)
+  (type_section)
+  (using_section)
+  (object_declaration)
+  (tuple_type)
+  (enum_declaration)
+  (case)
+  (if)
+  (when)
+  (conditional_declaration)
+  (variant_declaration)
+  (of_branch)
+  (elif_branch)
+  (else_branch)
+  (for)
+  (while)
+  (block)
+  (static_statement)
+  (pragma_statement)
+  (try)
+  (except_branch)
+  (finally_branch)
+  (do_block)
+  (call
+    (argument_list
+      (statement_list)))
+  (proc_declaration)
+  (func_declaration)
+  (method_declaration)
+  (iterator_declaration)
+  (converter_declaration)
+  (template_declaration)
+  (macro_declaration)
+  (proc_expression)
+  (func_expression)
+  (iterator_expression)
+  (concept_declaration)
+] @fold

package/out/nim/highlights.scm

@@ -0,0 +1,186 @@
+; SPDX-FileCopyrightText: 2023 Leorize <leorize+oss@disroot.org>
+; SPDX-License-Identifier: MPL-2.0
+
+; Punctuations
+[ "." ";" "," ":" ] @punctuation.delimiter
+[ "(" ")" "[" "]" "{" "}" "{." ".}" ] @punctuation.bracket
+
+; Operator by default, but could be overriden
+[ "=" ] @operator
+
+; Special
+(blank_identifier) @variable.builtin
+
+; Calls
+(call
+  function: [
+    (identifier) @function.call
+    (dot_expression
+      right: (identifier) @function.call)
+  ])
+(generalized_string
+  function: [
+    (identifier) @function.call
+    (dot_expression
+      right: (identifier) @function.call)
+  ])
+
+; Declarations
+(exported_symbol "*" @type.qualifier)
+(_ "=" @punctuation.delimiter [body: (_) value: (_)])
+(proc_declaration name: (_) @function)
+(func_declaration name: (_) @function)
+(converter_declaration name: (_) @function)
+(method_declaration name: (_) @method)
+(template_declaration name: (_) @function.macro)
+(macro_declaration name: (_) @function.macro)
+(symbol_declaration name: (_) @variable)
+(parameter_declaration
+  (symbol_declaration_list
+    (symbol_declaration name: (_) @parameter)))
+(_
+  [
+    type: [
+      (type_expression (identifier))
+      (type_expression (accent_quoted (identifier)))
+    ] @type
+    return_type: [
+      (type_expression (identifier))
+      (type_expression (accent_quoted (identifier)))
+    ] @type
+  ])
+
+; Exceptions
+[
+  "try"
+  "except"
+  "finally"
+  "raise"
+] @exception
+
+(except_branch values: (expression_list
+  [
+    (identifier) @type
+    (infix_expression
+      left: (identifier) @type
+      operator: "as"
+      right: (identifier) @variable)
+  ]))
+
+; Expressions
+(dot_expression
+  right: (identifier) @field)
+
+; Literal/comments
+[
+  (comment)
+  (block_comment)
+] @comment
+
+[
+  (documentation_comment)
+  (block_documentation_comment)
+] @comment.documentation
+
+(interpreted_string_literal) @string
+(long_string_literal) @string
+(raw_string_literal) @string
+(generalized_string) @string
+(char_literal) @character
+(escape_sequence) @string.escape
+(integer_literal) @number
+(float_literal) @float
+(custom_numeric_literal) @number
+(nil_literal) @constant.builtin
+
+; Keyword
+[
+  "if"
+  "when"
+  "case"
+  "elif"
+  "else"
+] @conditional
+
+(of_branch "of" @conditional)
+
+[
+  "import"
+  "include"
+  "export"
+] @include
+
+(import_from_statement "from" @include)
+(except_clause "except" @include)
+
+[
+  "for"
+  "while"
+  "continue"
+  "break"
+] @repeat
+
+(for "in" @repeat)
+
+[
+  "macro"
+  "template"
+  "const"
+  "let"
+  "var"
+  "asm"
+  "bind"
+  "block"
+  "concept"
+  "defer"
+  "discard"
+  "distinct"
+  "do"
+  "enum"
+  "mixin"
+  "nil"
+  "object"
+  "out"
+  "ptr"
+  "ref"
+  "static"
+  "tuple"
+  "type"
+] @keyword
+
+[
+  "proc"
+  "func"
+  "method"
+  "converter"
+  "iterator"
+] @keyword.function
+
+[
+  "and"
+  "or"
+  "xor"
+  "not"
+  "div"
+  "mod"
+  "shl"
+  "shr"
+  "from"
+  "as"
+  "of"
+  "in"
+  "notin"
+  "is"
+  "isnot"
+  "cast"
+] @keyword.operator
+
+[
+  "return"
+  "yield"
+] @keyword.return
+
+; Operators
+(infix_expression operator: _ @operator)
+(prefix_expression operator: _ @operator)
+

package/out/nim/injections.scm

@@ -0,0 +1,79 @@
+; =============================================================================
+; generalized_strings
+; regex in generalized_strings
+(generalized_string
+  function: (identifier) @_string_prefix
+  .
+  (string_content) @injection.content
+  (#set! injection.language "regex")
+  (#any-of? @_string_prefix "re" "rex"))
+
+; format string in generalized_strings
+(generalized_string
+  function: (identifier) @_string_prefix
+  .
+  (string_content) @injection.content
+  (#set! injection.language "nim_format_string")
+  (#eq? @_string_prefix "fmt"))
+
+; format string in normal strings with & prefix
+(prefix_expression
+  operator: (operator) @_string_prefix
+  .
+  (_
+    (string_content) @injection.content)
+  (#set! injection.language "nim_format_string")
+  (#eq? @_string_prefix "&"))
+
+; sql in generalized_strings
+; and anything you like as long as the function name is the same as the injected language's parser
+(generalized_string
+  function: (identifier) @injection.language
+  (string_content) @injection.content
+  (#not-any-of? @injection.language "re" "rex" "fmt"))
+
+; =============================================================================
+; emit pragma
+; C / CPP / OBJC / JAVASCRIPT
+; a `#<no whitespace><language name>`
+; has to directly precede the {.emit: "<language code>".} pragma
+; eg.:
+; #objc
+; {.emit: "<objc code>".}
+; OR
+; #javascript
+; {.emit: "<javascript code>".}
+; normal strings
+((comment
+  (comment_content) @injection.language)
+  .
+  (pragma_statement
+    (pragma_list
+      (colon_expression
+        left: (identifier) @_emit_keyword
+        (#eq? @_emit_keyword "emit")
+        right: (_
+          (string_content) @injection.content)))))
+
+; =============================================================================
+; asm statement
+; works same as emit pragma, needs preceding comment with language name
+((comment
+  (comment_content) @injection.language)
+  .
+  (assembly_statement
+    (_
+      (string_content) @injection.content)))
+
+; =============================================================================
+; comments
+; NOTE: ts "comment" parser heavily impacts performance
+; markdown parser in documentation_comment
+(documentation_comment
+  (comment_content) @injection.content
+  (#set! injection.language "markdown_inline"))
+
+; markdown parser in block_documentation_comment
+(block_documentation_comment
+  (comment_content) @injection.content
+  (#set! injection.language "markdown"))