ts-wasms 1.1.0 → 3.0.0

package/out/gitattributes/highlights.scm

@@ -0,0 +1,52 @@
+(dir_sep) @punctuation.delimiter
+
+(quoted_pattern
+  "\"" @punctuation.special)
+
+(range_notation) @string.special
+
+(range_notation
+  [ "[" "]" ] @punctuation.bracket)
+
+(wildcard) @string.regexp
+
+(range_negation) @operator
+
+(character_class) @constant
+
+(class_range "-" @operator)
+
+[
+  (ansi_c_escape)
+  (escaped_char)
+] @escape
+
+(attribute
+  (attr_name) @variable.parameter)
+
+(attribute
+  (builtin_attr) @variable.builtin)
+
+[
+  (attr_reset)
+  (attr_unset)
+  (attr_set)
+] @operator
+
+(boolean_value) @boolean
+
+(string_value) @string
+
+(macro_tag) @keyword
+
+(macro_def
+  macro_name: (_) @property)
+
+[
+  (pattern_negation)
+  (redundant_escape)
+  (trailing_slash)
+  (ignored_value)
+] @error
+
+(comment) @comment

package/out/gitattributes/injections.scm

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

package/out/gitattributes/locals.scm

@@ -0,0 +1,8 @@
+(macro_def
+  (attr_name) @local.definition.macro)
+
+(attribute
+  (attr_name) @local.reference)
+
+(attribute
+  (builtin_attr) @local.reference)

package/out/gitignore/highlights.scm

@@ -0,0 +1,36 @@
+(comment) @comment @spell
+
+(pattern_char) @string.special.path
+
+[
+  (directory_separator)
+  (directory_separator_escaped)
+] @punctuation.delimiter
+
+[
+  (wildcard_char_single)
+  (wildcard_chars)
+  (wildcard_chars_allow_slash)
+] @character.special
+
+[
+  (pattern_char_escaped)
+  (bracket_char_escaped)
+] @string.escape
+
+(negation) @punctuation.special
+
+(bracket_negation) @operator
+
+; bracket expressions
+[
+  "["
+  "]"
+] @punctuation.bracket
+
+(bracket_char) @constant
+
+(bracket_range
+  "-" @operator)
+
+(bracket_char_class) @constant.builtin

package/out/gitignore/injections.scm

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

package/out/gleam/folds.scm

@@ -0,0 +1,7 @@
+; Folds
+[
+  (case)
+  (function)
+  (anonymous_function)
+  (type_definition)
+] @fold

package/out/gleam/highlights.scm

@@ -0,0 +1,137 @@
+; Punctuation
+[
+  "("
+  ")"
+  "["
+  "]"
+  "{"
+  "}"
+  "<<"
+  ">>"
+] @punctuation.bracket
+[
+  "."
+  ","
+  ;; Controversial -- maybe some are operators?
+  ":"
+  "#"
+  "="
+  "->"
+  ".."
+  "-"
+  "<-"
+] @punctuation.delimiter
+
+; Variables
+(identifier) @variable
+(discard) @comment.unused
+
+; Comments
+(module_comment) @comment
+(statement_comment) @comment
+(comment) @comment
+
+; Constants
+(constant
+  name: (identifier) @constant)
+
+; "Properties"
+; Assumed to be intended to refer to a name for a field; something that comes
+; before ":" or after "."
+; e.g. record field names, tuple indices, names for named arguments, etc
+(label) @property
+(tuple_access
+  index: (integer) @property)
+
+; Modules
+(module) @module
+(import alias: (identifier) @module)
+(remote_type_identifier
+  module: (identifier) @module)
+(remote_constructor_name
+  module: (identifier) @module)
+
+; Functions
+(unqualified_import (identifier) @function)
+(unqualified_import "type" (type_identifier) @type)
+(unqualified_import (type_identifier) @constructor)
+(function
+  name: (identifier) @function)
+(external_function
+  name: (identifier) @function)
+(function_parameter
+  name: (identifier) @variable.parameter)
+((function_call
+   function: (identifier) @function)
+ (#is-not? local))
+((binary_expression
+   operator: "|>"
+   right: (identifier) @function)
+ (#is-not? local))
+
+; TODO: `#is-not? local` applies to entire patterns but ideally it would accept
+; a capture to check as a local. This needs to be suggested upstream. Until this
+; is a part of the CLI's highlighter we can't distinguish between function calls
+; on modules and accesses of record fields.
+(function_call function: (field_access field: (label) @function)) ; Ideally this pattern would be removed,
+((field_access
+  record: (identifier) @module)
+  ; field: (label) @function)                                     ; this line would be uncommented,
+ (#is-not? local))                                                ; and this line would be `(#is-not? local @module)`.
+
+; Attributes
+(attribute
+  "@" @attribute
+  name: (identifier) @attribute)
+
+(attribute_value (identifier) @constant)
+
+; Type names
+(remote_type_identifier) @type
+(type_identifier) @type
+
+; Data constructors
+(constructor_name) @constructor
+
+; Literals
+(string) @string
+(escape_sequence) @string.escape
+((escape_sequence) @warning
+ ; Deprecated in v0.33.0-rc2:
+ (#eq? @warning "\\e"))
+(bit_array_segment_option) @function.builtin
+(integer) @number
+(float) @number
+
+; Reserved identifiers
+; TODO: when tree-sitter supports `#any-of?` in the Rust bindings,
+; refactor this to use `#any-of?` rather than `#match?`
+((identifier) @error
+ (#any-of? @error "auto" "delegate" "derive" "else" "implement" "macro" "test"))
+
+; Keywords
+[
+  (visibility_modifier) ; "pub"
+  (opacity_modifier) ; "opaque"
+  "as"
+  "assert"
+  "case"
+  "const"
+  "echo"
+  ; DEPRECATED: 'external' was removed in v0.30.
+  "external"
+  "fn"
+  "if"
+  "import"
+  "let"
+  "panic"
+  "todo"
+  "type"
+  "use"
+] @keyword
+
+; Operators
+(binary_expression
+  operator: _ @operator)
+(boolean_negation "!" @operator)
+(integer_negation "-" @operator)

package/out/gleam/indents.scm

@@ -0,0 +1,28 @@
+; Gleam indents similar to Rust and JavaScript
+[
+  (anonymous_function)
+  (assert)
+  (case)
+  (case_clause)
+  (constant)
+  (external_function)
+  (function)
+  (let)
+  (list)
+  (type_definition)
+  (type_alias)
+  (todo)
+  (tuple)
+  (unqualified_imports)
+] @indent.begin
+
+[
+  ")"
+  "]"
+  "}"
+] @indent.end @indent.branch
+
+; Gleam pipelines are not indented, but other binary expression chains are
+((binary_expression
+  operator: _ @_operator) @indent.begin
+  (#not-eq? @_operator "|>"))

package/out/gleam/injections.scm

@@ -0,0 +1,3 @@
+((doc_comment_content) @injection.content
+ (#set! injection.language "markdown")
+ (#set! injection.combined))

package/out/gleam/locals.scm

@@ -0,0 +1,17 @@
+; Scopes
+(block) @local.scope
+
+(function) @local.scope
+
+(case_clause) @local.scope
+
+; Definitions
+(let pattern: (identifier) @local.definition)
+(function_parameter name: (identifier) @local.definition)
+(list_pattern (identifier) @local.definition)
+(list_pattern assign: (identifier) @local.definition)
+(tuple_pattern (identifier) @local.definition)
+(record_pattern_argument pattern: (identifier) @local.definition)
+
+; References
+(identifier) @local.reference

package/out/gleam/tags.scm

@@ -0,0 +1,41 @@
+; Modules
+(module) @name @reference.module
+(import alias: (identifier) @name) @reference.module
+(remote_type_identifier
+  module: (identifier) @name) @reference.module
+((field_access
+  record: (identifier) @name)
+ (#is-not? local)) @reference.module
+
+; Functions
+(function
+  name: (identifier) @name) @definition.function
+(external_function
+  name: (identifier) @name) @definition.function
+(unqualified_import (identifier) @name) @reference.function
+((function_call
+   function: (identifier) @name) @reference.function
+ (#is-not? local))
+((field_access
+  record: (identifier) @ignore
+  field: (label) @name)
+ (#is-not? local)) @reference.function
+((binary_expression
+   operator: "|>"
+   right: (identifier) @name)
+ (#is-not? local)) @reference.function
+
+; Types
+(type_definition
+  (type_name
+    name: (type_identifier) @name)) @definition.type
+(type_definition
+  (data_constructors
+    (data_constructor
+      name: (constructor_name) @name))) @definition.constructor
+(external_type
+  (type_name
+    name: (type_identifier) @name)) @definition.type
+
+(type_identifier) @name @reference.type
+(constructor_name) @name @reference.constructor

package/out/glsl/folds.scm

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

package/out/glsl/highlights.scm

@@ -0,0 +1,115 @@
+"break" @keyword
+"case" @keyword
+"const" @keyword
+"continue" @keyword
+"default" @keyword
+"do" @keyword
+"else" @keyword
+"enum" @keyword
+"extern" @keyword
+"for" @keyword
+"if" @keyword
+"inline" @keyword
+"return" @keyword
+"sizeof" @keyword
+"static" @keyword
+"struct" @keyword
+"switch" @keyword
+"typedef" @keyword
+"union" @keyword
+"volatile" @keyword
+"while" @keyword
+
+"#define" @keyword
+"#elif" @keyword
+"#else" @keyword
+"#endif" @keyword
+"#if" @keyword
+"#ifdef" @keyword
+"#ifndef" @keyword
+"#include" @keyword
+(preproc_directive) @keyword
+
+"--" @operator
+"-" @operator
+"-=" @operator
+"->" @operator
+"=" @operator
+"!=" @operator
+"*" @operator
+"&" @operator
+"&&" @operator
+"+" @operator
+"++" @operator
+"+=" @operator
+"<" @operator
+"==" @operator
+">" @operator
+"||" @operator
+
+"." @delimiter
+";" @delimiter
+
+(string_literal) @string
+(system_lib_string) @string
+
+(null) @constant
+(number_literal) @number
+(char_literal) @number
+
+(call_expression
+  function: (identifier) @function)
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @function))
+(function_declarator
+  declarator: (identifier) @function)
+(preproc_function_def
+  name: (identifier) @function.special)
+
+(field_identifier) @property
+(statement_identifier) @label
+(type_identifier) @type
+(primitive_type) @type
+(sized_type_specifier) @type
+
+((identifier) @constant
+ (#match? @constant "^[A-Z][A-Z\\d_]*$"))
+
+(identifier) @variable
+
+(comment) @comment
+; inherits: c
+[
+  "in"
+  "out"
+  "inout"
+  "uniform"
+  "shared"
+  "layout"
+  "attribute"
+  "varying"
+  "buffer"
+  "coherent"
+  "readonly"
+  "writeonly"
+  "precision"
+  "highp"
+  "mediump"
+  "lowp"
+  "centroid"
+  "sample"
+  "patch"
+  "smooth"
+  "flat"
+  "noperspective"
+  "invariant"
+  "precise"
+] @type.qualifier
+
+"subroutine" @keyword.function
+
+(extension_storage_class) @keyword.storage
+
+((identifier) @variable.builtin
+  (#lua-match? @variable.builtin "^gl_"))

package/out/glsl/indents.scm

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

package/out/glsl/injections.scm

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

package/out/glsl/locals.scm

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

package/out/go/folds.scm

@@ -0,0 +1,19 @@
+[
+  (const_declaration)
+  (expression_switch_statement)
+  (expression_case)
+  (default_case)
+  (type_switch_statement)
+  (type_case)
+  (for_statement)
+  (func_literal)
+  (function_declaration)
+  (if_statement)
+  (import_declaration)
+  (method_declaration)
+  (type_declaration)
+  (var_declaration)
+  (composite_literal)
+  (literal_element)
+  (block)
+] @fold

package/out/go/indents.scm

@@ -0,0 +1,48 @@
+[
+  (import_declaration)
+  (const_declaration)
+  (var_declaration)
+  (type_declaration)
+  (func_literal)
+  (literal_value)
+  (expression_case)
+  (communication_case)
+  (type_case)
+  (default_case)
+  (block)
+  (call_expression)
+  (parameter_list)
+  (field_declaration_list)
+  (interface_type)
+] @indent.begin
+
+(literal_value
+  "}" @indent.branch)
+
+(block
+  "}" @indent.branch)
+
+(field_declaration_list
+  "}" @indent.branch)
+
+(interface_type
+  "}" @indent.branch)
+
+(const_declaration
+  ")" @indent.branch)
+
+(import_spec_list
+  ")" @indent.branch)
+
+(var_spec_list
+  ")" @indent.branch)
+
+[
+  "}"
+  ")"
+] @indent.end
+
+(parameter_list
+  ")" @indent.branch)
+
+(comment) @indent.ignore

package/out/go/injections.scm

@@ -0,0 +1,42 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+(call_expression
+  (selector_expression) @_function
+  (#any-of? @_function
+    "regexp.Match" "regexp.MatchReader" "regexp.MatchString" "regexp.Compile" "regexp.CompilePOSIX"
+    "regexp.MustCompile" "regexp.MustCompilePOSIX")
+  (argument_list
+    .
+    [
+      (raw_string_literal
+        (raw_string_literal_content) @injection.content)
+      (interpreted_string_literal
+        (interpreted_string_literal_content) @injection.content)
+    ]
+    (#set! injection.language "regex")))
+
+((comment) @injection.content
+  (#match? @injection.content "/\\*!([a-zA-Z]+:)?re2c")
+  (#set! injection.language "re2c"))
+
+((call_expression
+  function: (selector_expression
+    field: (field_identifier) @_method)
+  arguments: (argument_list
+    .
+    (interpreted_string_literal
+      (interpreted_string_literal_content) @injection.content)))
+  (#any-of? @_method "Printf" "Sprintf" "Fatalf" "Scanf" "Errorf" "Skipf" "Logf")
+  (#set! injection.language "printf"))
+
+((call_expression
+  function: (selector_expression
+    field: (field_identifier) @_method)
+  arguments: (argument_list
+    (_)
+    .
+    (interpreted_string_literal
+      (interpreted_string_literal_content) @injection.content)))
+  (#any-of? @_method "Fprintf" "Fscanf" "Appendf" "Sscanf")
+  (#set! injection.language "printf"))

package/out/go/locals.scm

@@ -0,0 +1,88 @@
+((function_declaration
+  name: (identifier) @local.definition.function) ; @function
+  )
+
+((method_declaration
+  name: (field_identifier) @local.definition.method) ; @function.method
+  )
+
+(short_var_declaration
+  left: (expression_list
+    (identifier) @local.definition.var))
+
+(var_spec
+  name: (identifier) @local.definition.var)
+
+(parameter_declaration
+  (identifier) @local.definition.var)
+
+(variadic_parameter_declaration
+  (identifier) @local.definition.var)
+
+(for_statement
+  (range_clause
+    left: (expression_list
+      (identifier) @local.definition.var)))
+
+(const_declaration
+  (const_spec
+    name: (identifier) @local.definition.var))
+
+(type_declaration
+  (type_spec
+    name: (type_identifier) @local.definition.type))
+
+; reference
+(identifier) @local.reference
+
+(type_identifier) @local.reference
+
+(field_identifier) @local.reference
+
+((package_identifier) @local.reference
+  (#set! reference.kind "namespace"))
+
+(package_clause
+  (package_identifier) @local.definition.namespace)
+
+(import_spec_list
+  (import_spec
+    name: (package_identifier) @local.definition.namespace))
+
+; Call references
+((call_expression
+  function: (identifier) @local.reference)
+  (#set! reference.kind "call"))
+
+((call_expression
+  function: (selector_expression
+    field: (field_identifier) @local.reference))
+  (#set! reference.kind "call"))
+
+((call_expression
+  function: (parenthesized_expression
+    (identifier) @local.reference))
+  (#set! reference.kind "call"))
+
+((call_expression
+  function: (parenthesized_expression
+    (selector_expression
+      field: (field_identifier) @local.reference)))
+  (#set! reference.kind "call"))
+
+; Scopes
+(func_literal) @local.scope
+
+(source_file) @local.scope
+
+(function_declaration) @local.scope
+
+(if_statement) @local.scope
+
+(block) @local.scope
+
+(expression_switch_statement) @local.scope
+
+(for_statement) @local.scope
+
+(method_declaration) @local.scope

package/out/godot_resource/folds.scm

@@ -0,0 +1 @@
+(section) @fold