ts-wasms 1.0.6 → 2.0.0

package/out/ruby/indents.scm

@@ -0,0 +1,43 @@
+[
+  (class)
+  (singleton_class)
+  (method)
+  (singleton_method)
+  (module)
+  (call)
+  (if)
+  (block)
+  (do_block)
+  (hash)
+  (array)
+  (argument_list)
+  (case)
+  (while)
+  (until)
+  (for)
+  (begin)
+  (unless)
+  (assignment)
+  (parenthesized_statements)
+] @indent.begin
+
+[
+  "end"
+  ")"
+  "}"
+  "]"
+] @indent.end
+
+[
+  "end"
+  ")"
+  "}"
+  "]"
+  (when)
+  (elsif)
+  (else)
+  (rescue)
+  (ensure)
+] @indent.branch
+
+(comment) @indent.ignore

package/out/ruby/injections.scm

@@ -0,0 +1,34 @@
+((comment) @injection.content
+  (#set! injection.language "comment"))
+
+((comment) @injection.content
+  (#lua-match? @injection.content "^#:")
+  (#set! injection.language "rbs"))
+
+((comment) @injection.content
+  (#lua-match? @injection.content "^#%s+@rbs")
+  (#set! injection.language "rbs"))
+
+((comment) @injection.content
+  (#lua-match? @injection.content "^#%s+|")
+  (#set! injection.language "rbs"))
+
+(heredoc_body
+  (heredoc_content) @injection.content
+  (heredoc_end) @injection.language)
+
+(regex
+  (string_content) @injection.content
+  (#set! injection.language "regex"))
+
+((call
+  receiver: (identifier) @_receiver
+  method: (identifier) @_method
+  arguments: (argument_list
+    (pair
+      key: (hash_key_symbol)
+      value: (string
+        (string_content) @injection.content))))
+  (#eq? @_receiver "binding")
+  (#any-of? @_method "b" "break")
+  (#set! injection.self))

package/out/rust/folds.scm

@@ -0,0 +1,25 @@
+[
+  (mod_item)
+  (foreign_mod_item)
+  (function_item)
+  (struct_item)
+  (trait_item)
+  (enum_item)
+  (impl_item)
+  (type_item)
+  (union_item)
+  (const_item)
+  (let_declaration)
+  (loop_expression)
+  (for_expression)
+  (while_expression)
+  (if_expression)
+  (match_expression)
+  (call_expression)
+  (array_expression)
+  (macro_definition)
+  (macro_invocation)
+  (attribute_item)
+  (block)
+  (use_declaration)+
+] @fold

package/out/rust/indents.scm

@@ -0,0 +1,133 @@
+[
+  (mod_item)
+  (struct_item)
+  (enum_item)
+  (impl_item)
+  (struct_expression)
+  (struct_pattern)
+  (tuple_struct_pattern)
+  (tuple_expression)
+  (tuple_type)
+  (tuple_pattern)
+  (match_block)
+  (call_expression)
+  (assignment_expression)
+  (arguments)
+  (block)
+  (where_clause)
+  (use_list)
+  (array_expression)
+  (ordered_field_declaration_list)
+  (field_declaration_list)
+  (enum_variant_list)
+  (parameters)
+  (token_tree)
+  (token_repetition)
+  (macro_definition)
+] @indent.begin
+
+(trait_item
+  body: (_) @indent.begin)
+
+(string_literal
+  (escape_sequence)) @indent.begin
+
+; Typing in "(" inside macro definitions breaks the tree entirely
+; Making macro_definition becoming errors
+; Offset this by adding back one indent for start of macro rules
+(ERROR
+  .
+  "macro_rules!"
+  [
+    "("
+    "{"
+    "["
+  ] @indent.begin
+  (#set! indent.immediate)
+  (#set! indent.start_at_same_line))
+
+(macro_definition
+  [
+    ")"
+    "}"
+    "]"
+  ] @indent.end)
+
+(trait_item
+  body: (_) @indent.begin)
+
+(string_literal
+  (escape_sequence)) @indent.begin
+
+(block
+  "}" @indent.end)
+
+(enum_item
+  body: (enum_variant_list
+    "}" @indent.end))
+
+(impl_item
+  body: (declaration_list
+    "}" @indent.end))
+
+(match_expression
+  body: (match_block
+    "}" @indent.end))
+
+(mod_item
+  body: (declaration_list
+    "}" @indent.end))
+
+(struct_item
+  body: (field_declaration_list
+    "}" @indent.end))
+
+(struct_expression
+  body: (field_initializer_list
+    "}" @indent.end))
+
+(struct_pattern
+  "}" @indent.end)
+
+(tuple_struct_pattern
+  ")" @indent.end)
+
+; Typing in "(" inside macro definitions breaks the tree entirely
+; Making macro_definition becoming errors
+; Offset this by adding back one indent for start of macro rules
+(ERROR
+  .
+  "macro_rules!"
+  "(" @indent.begin
+  (#set! indent.immediate)
+  (#set! indent.start_at_same_line))
+
+(tuple_type
+  ")" @indent.end)
+
+(tuple_pattern
+  ")" @indent.end)
+
+(trait_item
+  body: (declaration_list
+    "}" @indent.end))
+
+(impl_item
+  (where_clause) @indent.dedent)
+
+[
+  "where"
+  ")"
+  "]"
+  "}"
+] @indent.branch
+
+(impl_item
+  (declaration_list) @indent.branch)
+
+[
+  (line_comment)
+  (string_literal)
+] @indent.ignore
+
+(raw_string_literal) @indent.auto

package/out/rust/locals.scm

@@ -0,0 +1,98 @@
+; Imports
+(extern_crate_declaration
+  name: (identifier) @local.definition.import)
+
+(use_declaration
+  argument: (scoped_identifier
+    name: (identifier) @local.definition.import))
+
+(use_as_clause
+  alias: (identifier) @local.definition.import)
+
+(use_list
+  (identifier) @local.definition.import) ; use std::process::{Child, Command, Stdio};
+
+; Functions
+(function_item
+  name: (identifier) @local.definition.function)
+
+(function_item
+  name: (identifier) @local.definition.method
+  parameters: (parameters
+    (self_parameter)))
+
+; Variables
+(parameter
+  pattern: (identifier) @local.definition.var)
+
+(let_declaration
+  pattern: (identifier) @local.definition.var)
+
+(const_item
+  name: (identifier) @local.definition.var)
+
+(tuple_pattern
+  (identifier) @local.definition.var)
+
+(let_condition
+  pattern: (_
+    (identifier) @local.definition.var))
+
+(tuple_struct_pattern
+  (identifier) @local.definition.var)
+
+(closure_parameters
+  (identifier) @local.definition.var)
+
+(self_parameter
+  (self) @local.definition.var)
+
+(for_expression
+  pattern: (identifier) @local.definition.var)
+
+; Types
+(struct_item
+  name: (type_identifier) @local.definition.type)
+
+(enum_item
+  name: (type_identifier) @local.definition.type)
+
+; Fields
+(field_declaration
+  name: (field_identifier) @local.definition.field)
+
+(enum_variant
+  name: (identifier) @local.definition.field)
+
+; References
+(identifier) @local.reference
+
+((type_identifier) @local.reference
+  (#set! reference.kind "type"))
+
+((field_identifier) @local.reference
+  (#set! reference.kind "field"))
+
+; Macros
+(macro_definition
+  name: (identifier) @local.definition.macro)
+
+; Module
+(mod_item
+  name: (identifier) @local.definition.namespace)
+
+; Scopes
+[
+  (block)
+  (function_item)
+  (closure_expression)
+  (while_expression)
+  (for_expression)
+  (loop_expression)
+  (if_expression)
+  (match_expression)
+  (match_arm)
+  (struct_item)
+  (enum_item)
+  (impl_item)
+] @local.scope

package/out/scala/folds.scm

@@ -0,0 +1,16 @@
+(call_expression
+  (block) @fold)
+
+[
+  (class_definition)
+  (trait_definition)
+  (object_definition)
+  (function_definition)
+  (val_definition)
+  (import_declaration)
+  (while_expression)
+  (do_while_expression)
+  (for_expression)
+  (try_expression)
+  (match_expression)
+] @fold

package/out/scala/injections.scm

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

package/out/scheme/folds.scm

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

package/out/scheme/injections.scm

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

package/out/scss/folds.scm

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

package/out/scss/indents.scm

@@ -0,0 +1,7 @@
+; inherits: css
+
+[
+  (mixin_statement)
+  (while_statement)
+  (each_statement)
+] @indent.begin

package/out/scss/injections.scm

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

package/out/sql/folds.scm

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