Add syntaxes for Elm, Kotlin, Puppet, TypeScript

closes #215
closes #216
closes #217
closes #218

6 files changed, 3425 insertions, 0 deletions

diff --git a/assets/syntaxes/Elm b/assets/syntaxes/Elm
new file mode 160000
+Subproject dfbb8bdc9a8403092c884d3eb893a270538cfa7
diff --git a/assets/syntaxes/Kotlin b/assets/syntaxes/Kotlin
new file mode 160000
+Subproject aeeed2780b04aea3d293c547c24cae27cafef0c
diff --git a/assets/syntaxes/Kotlin.sublime-syntax b/assets/syntaxes/Kotlin.sublime-syntax
new file mode 100644
index 00000000..eab59192
--- /dev/null
+++ b/assets/syntaxes/Kotlin.sublime-syntax
@@ -0,0 +1,398 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: Kotlin
+file_extensions:
+  - kt
+  - kts
+scope: source.Kotlin
+contexts:
+  main:
+    - include: comments
+    - match: '^\s*(package)\b(?:\s*([^ ;$]+)\s*)?'
+      captures:
+        1: keyword.other.kotlin
+        2: entity.name.package.kotlin
+    - include: imports
+    - include: statements
+  classes:
+    - match: (?<!::)(?=\b(?:companion|class|object|interface)\b)
+      push:
+        - match: '(?=$|\})'
+          pop: true
+        - include: comments
+        - match: \b(companion\s*)?(class|object|interface)\b
+          captures:
+            1: storage.modifier.kotlin
+            2: storage.modifier.kotlin
+          push:
+            - match: '(?=<|\{|\(|:|$)'
+              pop: true
+            - include: comments
+            - match: \w+
+              scope: entity.name.type.class.kotlin
+        - match: <
+          push:
+            - match: ">"
+              pop: true
+            - include: generics
+        - match: \(
+          push:
+            - match: \)
+              pop: true
+            - include: parameters
+        - match: (:)
+          captures:
+            1: keyword.operator.declaration.kotlin
+          push:
+            - match: "(?={|$)"
+              pop: true
+            - match: \w+
+              scope: entity.other.inherited-class.kotlin
+            - match: \(
+              push:
+                - match: \)
+                  pop: true
+                - include: expressions
+        - match: '\{'
+          push:
+            - match: '\}'
+              pop: true
+            - include: statements
+  comments:
+    - match: /\*
+      captures:
+        0: punctuation.definition.comment.kotlin
+      push:
+        - meta_scope: comment.block.kotlin
+        - match: \*/
+          captures:
+            0: punctuation.definition.comment.kotlin
+          pop: true
+    - match: \s*((//).*$\n?)
+      captures:
+        1: comment.line.double-slash.kotlin
+        2: punctuation.definition.comment.kotlin
+  constants:
+    - match: \b(true|false|null|this|super)\b
+      scope: constant.language.kotlin
+    - match: '\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)([LlFf])?\b'
+      scope: constant.numeric.kotlin
+    - match: '\b([A-Z][A-Z0-9_]+)\b'
+      scope: constant.other.kotlin
+  expressions:
+    - match: \(
+      push:
+        - match: \)
+          pop: true
+        - include: expressions
+    - include: types
+    - include: strings
+    - include: constants
+    - include: comments
+    - include: keywords
+  functions:
+    - match: (?=\s*\b(?:fun)\b)
+      push:
+        - match: '(?=$|\})'
+          pop: true
+        - match: \b(fun)\b
+          captures:
+            1: keyword.other.kotlin
+          push:
+            - match: (?=\()
+              pop: true
+            - match: <
+              push:
+                - match: ">"
+                  pop: true
+                - include: generics
+            - match: '([\.<\?>\w]+\.)?(\w+)'
+              captures:
+                2: entity.name.function.kotlin
+        - match: \(
+          push:
+            - match: \)
+              pop: true
+            - include: parameters
+        - match: (:)
+          captures:
+            1: keyword.operator.declaration.kotlin
+          push:
+            - match: "(?={|=|$)"
+              pop: true
+            - include: types
+        - match: '\{'
+          push:
+            - match: '(?=\})'
+              pop: true
+            - include: statements
+        - match: (=)
+          captures:
+            1: keyword.operator.assignment.kotlin
+          push:
+            - match: (?=$)
+              pop: true
+            - include: expressions
+  generics:
+    - match: (:)
+      captures:
+        1: keyword.operator.declaration.kotlin
+      push:
+        - match: (?=,|>)
+          pop: true
+        - include: types
+    - include: keywords
+    - match: \w+
+      scope: storage.type.generic.kotlin
+  getters-and-setters:
+    - match: \b(get)\b\s*\(\s*\)
+      captures:
+        1: entity.name.function.kotlin
+      push:
+        - match: '\}|(?=\bset\b)|$'
+          pop: true
+        - match: (=)
+          captures:
+            1: keyword.operator.assignment.kotlin
+          push:
+            - match: (?=$|\bset\b)
+              pop: true
+            - include: expressions
+        - match: '\{'
+          push:
+            - match: '\}'
+              pop: true
+            - include: expressions
+    - match: \b(set)\b\s*(?=\()
+      captures:
+        1: entity.name.function.kotlin
+      push:
+        - match: '\}|(?=\bget\b)|$'
+          pop: true
+        - match: \(
+          push:
+            - match: \)
+              pop: true
+            - include: parameters
+        - match: (=)
+          captures:
+            1: keyword.operator.assignment.kotlin
+          push:
+            - match: (?=$|\bset\b)
+              pop: true
+            - include: expressions
+        - match: '\{'
+          push:
+            - match: '\}'
+              pop: true
+            - include: expressions
+  imports:
+    - match: '^\s*(import)\s+[^ $]+\s+(as)?'
+      captures:
+        1: keyword.other.kotlin
+        2: keyword.other.kotlin
+  keywords:
+    - match: \b(var|val|public|private|protected|abstract|final|sealed|enum|open|attribute|annotation|override|inline|vararg|in|out|internal|data|tailrec|operator|infix|const|yield|typealias|typeof|reified|suspend)\b
+      scope: storage.modifier.kotlin
+    - match: \b(try|catch|finally|throw)\b
+      scope: keyword.control.catch-exception.kotlin
+    - match: \b(if|else|while|for|do|return|when|where|break|continue)\b
+      scope: keyword.control.kotlin
+    - match: \b(in|is|!in|!is|as|as\?|assert)\b
+      scope: keyword.operator.kotlin
+    - match: (==|!=|===|!==|<=|>=|<|>)
+      scope: keyword.operator.comparison.kotlin
+    - match: (=)
+      scope: keyword.operator.assignment.kotlin
+    - match: (::)
+      scope: keyword.operator.kotlin
+    - match: (:)
+      scope: keyword.operator.declaration.kotlin
+    - match: \b(by)\b
+      scope: keyword.other.by.kotlin
+    - match: (\?\.)
+      scope: keyword.operator.safenav.kotlin
+    - match: (\.)
+      scope: keyword.operator.dot.kotlin
+    - match: (\?:)
+      scope: keyword.operator.elvis.kotlin
+    - match: (\-\-|\+\+)
+      scope: keyword.operator.increment-decrement.kotlin
+    - match: (\+=|\-=|\*=|\/=)
+      scope: keyword.operator.arithmetic.assign.kotlin
+    - match: (\.\.)
+      scope: keyword.operator.range.kotlin
+    - match: (\-|\+|\*|\/|%)
+      scope: keyword.operator.arithmetic.kotlin
+    - match: (!|&&|\|\|)
+      scope: keyword.operator.logical.kotlin
+    - match: (;)
+      scope: punctuation.terminator.kotlin
+  namespaces:
+    - match: \b(namespace)\b
+      scope: keyword.other.kotlin
+    - match: '\{'
+      push:
+        - match: '\}'
+          pop: true
+        - include: statements
+  parameters:
+    - match: (:)
+      captures:
+        1: keyword.operator.declaration.kotlin
+      push:
+        - match: (?=,|\)|=)
+          pop: true
+        - include: types
+    - match: (=)
+      captures:
+        1: keyword.operator.declaration.kotlin
+      push:
+        - match: (?=,|\))
+          pop: true
+        - include: expressions
+    - include: keywords
+    - match: \w+
+      scope: variable.parameter.function.kotlin
+  statements:
+    - include: namespaces
+    - include: typedefs
+    - include: classes
+    - include: functions
+    - include: variables
+    - include: getters-and-setters
+    - include: expressions
+  strings:
+    - match: '"""'
+      captures:
+        0: punctuation.definition.string.begin.kotlin
+      push:
+        - meta_scope: string.quoted.third.kotlin
+        - match: '"""'
+          captures:
+            0: punctuation.definition.string.end.kotlin
+          pop: true
+        - match: '(\$\w+|\$\{[^\}]+\})'
+          scope: variable.parameter.template.kotlin
+        - match: \\.
+          scope: constant.character.escape.kotlin
+    - match: '"'
+      captures:
+        0: punctuation.definition.string.begin.kotlin
+      push:
+        - meta_scope: string.quoted.double.kotlin
+        - match: '"'
+          captures:
+            0: punctuation.definition.string.end.kotlin
+          pop: true
+        - match: '(\$\w+|\$\{[^\}]+\})'
+          scope: variable.parameter.template.kotlin
+        - match: \\.
+          scope: constant.character.escape.kotlin
+    - match: "'"
+      captures:
+        0: punctuation.definition.string.begin.kotlin
+      push:
+        - meta_scope: string.quoted.single.kotlin
+        - match: "'"
+          captures:
+            0: punctuation.definition.string.end.kotlin
+          pop: true
+        - match: \\.
+          scope: constant.character.escape.kotlin
+    - match: "`"
+      captures:
+        0: punctuation.definition.string.begin.kotlin
+      push:
+        - meta_scope: string.quoted.single.kotlin
+        - match: "`"
+          captures:
+            0: punctuation.definition.string.end.kotlin
+          pop: true
+  typedefs:
+    - match: (?=\s*(?:type))
+      push:
+        - match: (?=$)
+          pop: true
+        - match: \b(type)\b
+          scope: keyword.other.kotlin
+        - match: <
+          push:
+            - match: ">"
+              pop: true
+            - include: generics
+        - include: expressions
+  types:
+    - match: \b(Nothing|Any|Unit|String|CharSequence|Int|Boolean|Char|Long|Double|Float|Short|Byte|dynamic)\b
+      scope: storage.type.buildin.kotlin
+    - match: \b(IntArray|BooleanArray|CharArray|LongArray|DoubleArray|FloatArray|ShortArray|ByteArray)\b
+      scope: storage.type.buildin.array.kotlin
+    - match: \b(Array|Collection|List|Map|Set|MutableList|MutableMap|MutableSet|Sequence)<\b
+      captures:
+        1: storage.type.buildin.collection.kotlin
+      push:
+        - match: ">"
+          pop: true
+        - include: types
+        - include: keywords
+    - match: \w+<
+      push:
+        - match: ">"
+          pop: true
+        - include: types
+        - include: keywords
+    - match: '\{'
+      push:
+        - match: '\}'
+          pop: true
+        - include: statements
+    - match: \(
+      push:
+        - match: \)
+          pop: true
+        - include: types
+    - match: (->)
+      scope: keyword.operator.declaration.kotlin
+  variables:
+    - match: (?=\s*\b(?:var|val)\b)
+      push:
+        - match: (?=:|=|(\b(by)\b)|$)
+          pop: true
+        - match: \b(var|val)\b
+          captures:
+            1: keyword.other.kotlin
+          push:
+            - match: (?=:|=|(\b(by)\b)|$)
+              pop: true
+            - match: <
+              push:
+                - match: ">"
+                  pop: true
+                - include: generics
+            - match: '([\.<\?>\w]+\.)?(\w+)'
+              captures:
+                2: entity.name.variable.kotlin
+        - match: (:)
+          captures:
+            1: keyword.operator.declaration.kotlin
+          push:
+            - match: (?==|$)
+              pop: true
+            - include: types
+            - include: getters-and-setters
+        - match: \b(by)\b
+          captures:
+            1: keyword.other.kotlin
+          push:
+            - match: (?=$)
+              pop: true
+            - include: expressions
+        - match: (=)
+          captures:
+            1: keyword.operator.assignment.kotlin
+          push:
+            - match: (?=$)
+              pop: true
+            - include: expressions
+            - include: getters-and-setters
diff --git a/assets/syntaxes/Puppet b/assets/syntaxes/Puppet
new file mode 160000
+Subproject 2a224343d2151b2896b6d9c48343919c06d1e69
diff --git a/assets/syntaxes/TypeScript b/assets/syntaxes/TypeScript
new file mode 160000
+Subproject 19a599ad0e2edfb13c107db4305cf07b82cdc02
diff --git a/assets/syntaxes/TypeScript.sublime-syntax b/assets/syntaxes/TypeScript.sublime-syntax
new file mode 100644
index 00000000..75a6c2a3
--- /dev/null
+++ b/assets/syntaxes/TypeScript.sublime-syntax
@@ -0,0 +1,3027 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: TypeScript
+file_extensions:
+  - ts
+scope: source.ts
+contexts:
+  main:
+    - include: directives
+    - include: statements
+    - match: \A(#!).*(?=$)
+      scope: comment.line.shebang.ts
+      captures:
+        1: punctuation.definition.comment.ts
+  comment:
+    - match: /\*\*(?!/)
+      captures:
+        0: punctuation.definition.comment.ts
+      push:
+        - meta_scope: comment.block.documentation.ts
+        - match: \*/
+          captures:
+            0: punctuation.definition.comment.ts
+          pop: true
+        - include: docblock
+    - match: (/\*)(?:\s*((@)internal)(?=\s|(\*/)))?
+      captures:
+        1: punctuation.definition.comment.ts
+        2: storage.type.internaldeclaration.ts
+        3: punctuation.decorator.internaldeclaration.ts
+      push:
+        - meta_scope: comment.block.ts
+        - match: \*/
+          captures:
+            0: punctuation.definition.comment.ts
+          pop: true
+    - match: '(^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?)'
+      captures:
+        1: punctuation.whitespace.comment.leading.ts
+        2: comment.line.double-slash.ts
+        3: punctuation.definition.comment.ts
+        4: storage.type.internaldeclaration.ts
+        5: punctuation.decorator.internaldeclaration.ts
+      push:
+        - meta_content_scope: comment.line.double-slash.ts
+        - match: (?=^)
+          pop: true
+  access-modifier:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(abstract|public|protected|private|readonly|static)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: storage.modifier.ts
+  after-operator-block-as-object-literal:
+    - match: '(?<!\+\+|--)(?<=[:=(,\[?+!>]|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^yield|[^\._$[:alnum:]]yield|^throw|[^\._$[:alnum:]]throw|^in|[^\._$[:alnum:]]in|^of|[^\._$[:alnum:]]of|^typeof|[^\._$[:alnum:]]typeof|&&|\|\||\*)\s*(\{)'
+      captures:
+        1: punctuation.definition.block.ts
+      push:
+        - meta_scope: meta.objectliteral.ts
+        - match: '\}'
+          captures:
+            0: punctuation.definition.block.ts
+          pop: true
+        - include: object-member
+  array-binding-pattern:
+    - match: '(?:(\.\.\.)\s*)?(\[)'
+      captures:
+        1: keyword.operator.rest.ts
+        2: punctuation.definition.binding-pattern.array.ts
+      push:
+        - match: '\]'
+          captures:
+            0: punctuation.definition.binding-pattern.array.ts
+          pop: true
+        - include: binding-element
+        - include: punctuation-comma
+  array-binding-pattern-const:
+    - match: '(?:(\.\.\.)\s*)?(\[)'
+      captures:
+        1: keyword.operator.rest.ts
+        2: punctuation.definition.binding-pattern.array.ts
+      push:
+        - match: '\]'
+          captures:
+            0: punctuation.definition.binding-pattern.array.ts
+          pop: true
+        - include: binding-element-const
+        - include: punctuation-comma
+  array-literal:
+    - match: '\s*(\[)'
+      captures:
+        1: meta.brace.square.ts
+      push:
+        - meta_scope: meta.array.literal.ts
+        - match: '\]'
+          captures:
+            0: meta.brace.square.ts
+          pop: true
+        - include: expression
+        - include: punctuation-comma
+  arrow-function:
+    - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)\s+)?([_$[:alpha:]][_$[:alnum:]]*)\s*(?==>)'
+      scope: meta.arrow.ts
+      captures:
+        1: storage.modifier.async.ts
+        2: variable.parameter.ts
+    - match: |-
+        (?x) (?:
+          (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)
+        )? ((?<![})!\]])\s*
+          (?=
+            # sure shot arrow functions even if => is on new line
+        (
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?
+          [(]\s*
+          (
+            ([)]\s*:) |                                                                                       # ():
+            ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:)                                                                  # [(]param: | [(]...param:
+          )
+        ) |
+        (
+          [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>]                                                              # < typeparam extends
+        ) |
+        # arrow function possible to detect only with => on same line
+        (
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\(\)]|(\([^\(\)]*\)))*\)))*)?\)   # parameters
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                                                        # return type
+          \s*=>                                                                                               # arrow operator
+        )
+          )
+        )
+      captures:
+        1: storage.modifier.async.ts
+      push:
+        - meta_scope: meta.arrow.ts
+        - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'
+          pop: true
+        - include: comment
+        - include: type-parameters
+        - include: function-parameters
+        - include: arrow-return-type
+    - match: "=>"
+      captures:
+        0: storage.type.function.arrow.ts
+      push:
+        - meta_scope: meta.arrow.ts
+        - match: '(?<=\}|\S)(?<!=>)|((?!\{)(?=\S))'
+          pop: true
+        - include: decl-block
+        - include: expression
+  arrow-return-type:
+    - match: (?<=\))\s*(:)
+      captures:
+        1: keyword.operator.type.annotation.ts
+      push:
+        - meta_scope: meta.return.type.arrow.ts
+        - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'
+          pop: true
+        - include: arrow-return-type-body
+  arrow-return-type-body:
+    - match: '(?<=[:])(?=\s*\{)'
+      push:
+        - match: '(?<=\})'
+          pop: true
+        - include: type-object
+    - include: type-predicate-operator
+    - include: type
+  async-modifier:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(async)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: storage.modifier.async.ts
+  binding-element:
+    - include: comment
+    - include: string
+    - include: object-binding-pattern
+    - include: array-binding-pattern
+    - include: destructuring-variable-rest
+    - include: variable-initializer
+  binding-element-const:
+    - include: comment
+    - include: string
+    - include: object-binding-pattern-const
+    - include: array-binding-pattern-const
+    - include: destructuring-variable-rest-const
+    - include: variable-initializer
+  boolean-literal:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))true(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: constant.language.boolean.true.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))false(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: constant.language.boolean.false.ts
+  brackets:
+    - match: "{"
+      push:
+        - match: '}|(?=\*/)'
+          pop: true
+        - include: brackets
+    - match: '\['
+      push:
+        - match: '\]|(?=\*/)'
+          pop: true
+        - include: brackets
+  cast:
+    - match: '(?:(?<!\+\+|--)(?<=^return|[^\._$[:alnum:]]return|^throw|[^\._$[:alnum:]]throw|^yield|[^\._$[:alnum:]]yield|^await|[^\._$[:alnum:]]await|^default|[^\._$[:alnum:]]default|[=(,:>*?\&\|\^]|[^_$[:alnum:]](?:\+\+|\-\-)|[^\+]\+|[^\-]\-))\s*(<)(?!<?\=)(?!\s*$)'
+      captures:
+        1: meta.brace.angle.ts
+      push:
+        - meta_scope: cast.expr.ts
+        - match: (\>)\s*
+          captures:
+            1: meta.brace.angle.ts
+          pop: true
+        - include: type
+    - match: '(?:(?<=^))\s*(<)(?=[_$[:alpha:]][_$[:alnum:]]*\s*>)'
+      captures:
+        1: meta.brace.angle.ts
+      push:
+        - meta_scope: cast.expr.ts
+        - match: (\>)\s*
+          captures:
+            1: meta.brace.angle.ts
+          pop: true
+        - include: type
+  class-declaration:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?\b(?:(abstract)\s+)?\b(class)\b(?=\s+|/[/*])'
+      captures:
+        1: keyword.control.export.ts
+        2: storage.modifier.ts
+        3: storage.type.class.ts
+      push:
+        - meta_scope: meta.class.ts
+        - match: '(?<=\})'
+          pop: true
+        - include: class-declaration-or-expression-patterns
+  class-declaration-or-expression-patterns:
+    - include: comment
+    - include: class-or-interface-heritage
+    - match: "[_$[:alpha:]][_$[:alnum:]]*"
+      captures:
+        0: entity.name.type.class.ts
+    - include: type-parameters
+    - include: class-or-interface-body
+  class-expression:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(class)\b(?=\s+|[<{]|\/[\/*])'
+      captures:
+        1: storage.type.class.ts
+      push:
+        - meta_scope: meta.class.ts
+        - match: '(?<=\})'
+          pop: true
+        - include: class-declaration-or-expression-patterns
+  class-or-interface-body:
+    - match: '\{'
+      captures:
+        0: punctuation.definition.block.ts
+      push:
+        - match: '\}'
+          captures:
+            0: punctuation.definition.block.ts
+          pop: true
+        - include: comment
+        - include: decorator
+        - include: method-declaration
+        - include: indexer-declaration
+        - include: field-declaration
+        - include: string
+        - include: type-annotation
+        - include: variable-initializer
+        - include: access-modifier
+        - include: property-accessor
+        - include: async-modifier
+        - include: after-operator-block-as-object-literal
+        - include: decl-block
+        - include: expression
+        - include: punctuation-comma
+        - include: punctuation-semicolon
+  class-or-interface-heritage:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(extends|implements)\b)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      captures:
+        1: storage.modifier.ts
+      push:
+        - match: '(?=\{)'
+          pop: true
+        - include: comment
+        - include: class-or-interface-heritage
+        - include: type-parameters
+        - include: expressionWithoutIdentifiers
+        - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)*\s*)'
+          captures:
+            1: entity.name.type.module.ts
+            2: punctuation.accessor.ts
+            3: punctuation.accessor.optional.ts
+        - match: "([_$[:alpha:]][_$[:alnum:]]*)"
+          captures:
+            1: entity.other.inherited-class.ts
+        - include: expressionPunctuations
+  control-statement:
+    - include: switch-statement
+    - include: for-loop
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(catch|finally|throw|try)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: keyword.control.trycatch.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|goto)\s+([_$[:alpha:]][_$[:alnum:]]*)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      captures:
+        1: keyword.control.loop.ts
+        2: entity.name.label.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|do|goto|while)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: keyword.control.loop.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(return)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: keyword.control.flow.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default|switch)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: keyword.control.switch.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(else|if)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: keyword.control.conditional.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(with)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: keyword.control.with.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(package)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: keyword.control.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(debugger)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: keyword.other.debugger.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(declare)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: storage.modifier.ts
+  decl-block:
+    - match: '\{'
+      captures:
+        0: punctuation.definition.block.ts
+      push:
+        - meta_scope: meta.block.ts
+        - match: '\}'
+          captures:
+            0: punctuation.definition.block.ts
+          pop: true
+        - include: statements
+  declaration:
+    - include: decorator
+    - include: var-expr
+    - include: function-declaration
+    - include: class-declaration
+    - include: interface-declaration
+    - include: enum-declaration
+    - include: namespace-declaration
+    - include: type-alias-declaration
+    - include: import-equals-declaration
+    - include: import-declaration
+    - include: export-declaration
+  decorator:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))\@'
+      captures:
+        0: punctuation.decorator.ts
+      push:
+        - meta_scope: meta.decorator.ts
+        - match: (?=\s)
+          pop: true
+        - include: expression
+  destructuring-const:
+    - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{)'
+      push:
+        - meta_scope: meta.object-binding-pattern-variable.ts
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
+          pop: true
+        - include: object-binding-pattern-const
+        - include: type-annotation
+        - include: comment
+    - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[)'
+      push:
+        - meta_scope: meta.array-binding-pattern-variable.ts
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
+          pop: true
+        - include: array-binding-pattern-const
+        - include: type-annotation
+        - include: comment
+  destructuring-parameter:
+    - match: '(?<!=|:)\s*(\{)'
+      captures:
+        1: punctuation.definition.binding-pattern.object.ts
+      push:
+        - meta_scope: meta.parameter.object-binding-pattern.ts
+        - match: '\}'
+          captures:
+            0: punctuation.definition.binding-pattern.object.ts
+          pop: true
+        - include: parameter-object-binding-element
+    - match: '(?<!=|:)\s*(\[)'
+      captures:
+        1: punctuation.definition.binding-pattern.array.ts
+      push:
+        - meta_scope: meta.paramter.array-binding-pattern.ts
+        - match: '\]'
+          captures:
+            0: punctuation.definition.binding-pattern.array.ts
+          pop: true
+        - include: parameter-binding-element
+        - include: punctuation-comma
+  destructuring-parameter-rest:
+    - match: '(?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)'
+      captures:
+        1: keyword.operator.rest.ts
+        2: variable.parameter.ts
+  destructuring-variable:
+    - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{)'
+      push:
+        - meta_scope: meta.object-binding-pattern-variable.ts
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
+          pop: true
+        - include: object-binding-pattern
+        - include: type-annotation
+        - include: comment
+    - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[)'
+      push:
+        - meta_scope: meta.array-binding-pattern-variable.ts
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
+          pop: true
+        - include: array-binding-pattern
+        - include: type-annotation
+        - include: comment
+  destructuring-variable-rest:
+    - match: '(?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)'
+      captures:
+        1: keyword.operator.rest.ts
+        2: meta.definition.variable.ts variable.other.readwrite.ts
+  destructuring-variable-rest-const:
+    - match: '(?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)'
+      captures:
+        1: keyword.operator.rest.ts
+        2: meta.definition.variable.ts variable.other.constant.ts
+  directives:
+    - match: '^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|lib|name)\s*=\s*((\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")))+\s*/>\s*$)'
+      captures:
+        1: punctuation.definition.comment.ts
+      push:
+        - meta_scope: comment.line.triple-slash.directive.ts
+        - match: (?=^)
+          pop: true
+        - match: (<)(reference|amd-dependency|amd-module)
+          captures:
+            1: punctuation.definition.tag.directive.ts
+            2: entity.name.tag.directive.ts
+          push:
+            - meta_scope: meta.tag.ts
+            - match: />
+              captures:
+                0: punctuation.definition.tag.directive.ts
+              pop: true
+            - match: path|types|no-default-lib|lib|name
+              scope: entity.other.attribute-name.directive.ts
+            - match: "="
+              scope: keyword.operator.assignment.ts
+            - include: string
+  docblock:
+    - match: |-
+        (?x)
+        ((@)(?:access|api))
+        \s+
+        (private|protected|public)
+        \b
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: constant.language.access-type.jsdoc
+    - match: |-
+        (?x)
+        ((@)author)
+        \s+
+        (
+          [^@\s<>*/]
+          (?:[^@<>*/]|\*[^/])*
+        )
+        (?:
+          \s*
+          (<)
+          ([^>\s]+)
+          (>)
+        )?
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: entity.name.type.instance.jsdoc
+        4: punctuation.definition.bracket.angle.begin.jsdoc
+        5: constant.other.email.link.underline.jsdoc
+        6: punctuation.definition.bracket.angle.end.jsdoc
+    - match: |-
+        (?x)
+        ((@)borrows) \s+
+        ((?:[^@\s*/]|\*[^/])+)    # <that namepath>
+        \s+ (as) \s+              # as
+        ((?:[^@\s*/]|\*[^/])+)    # <this namepath>
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: entity.name.type.instance.jsdoc
+        4: keyword.operator.control.jsdoc
+        5: entity.name.type.instance.jsdoc
+    - match: ((@)example)\s+
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+      push:
+        - meta_scope: meta.example.jsdoc
+        - match: (?=@|\*/)
+          pop: true
+        - match: ^\s\*\s+
+        - match: \G(<)caption(>)
+          captures:
+            0: entity.name.tag.inline.jsdoc
+            1: punctuation.definition.bracket.angle.begin.jsdoc
+            2: punctuation.definition.bracket.angle.end.jsdoc
+          push:
+            - meta_content_scope: constant.other.description.jsdoc
+            - match: (</)caption(>)|(?=\*/)
+              captures:
+                0: entity.name.tag.inline.jsdoc
+                1: punctuation.definition.bracket.angle.begin.jsdoc
+                2: punctuation.definition.bracket.angle.end.jsdoc
+              pop: true
+        - match: '[^\s@*](?:[^*]|\*[^/])*'
+          captures:
+            0: source.embedded.ts
+    - match: (?x) ((@)kind) \s+ (class|constant|event|external|file|function|member|mixin|module|namespace|typedef) \b
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: constant.language.symbol-type.jsdoc
+    - match: |-
+        (?x)
+        ((@)see)
+        \s+
+        (?:
+          # URL
+          (
+            (?=https?://)
+            (?:[^\s*]|\*[^/])+
+          )
+          |
+          # JSDoc namepath
+          (
+            (?!
+              # Avoid matching bare URIs (also acceptable as links)
+              https?://
+              |
+              # Avoid matching {@inline tags}; we match those below
+              (?:\[[^\[\]]*\])? # Possible description [preceding]{@tag}
+              {@(?:link|linkcode|linkplain|tutorial)\b
+            )
+            # Matched namepath
+            (?:[^@\s*/]|\*[^/])+
+          )
+        )
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: variable.other.link.underline.jsdoc
+        4: entity.name.type.instance.jsdoc
+    - match: |-
+        (?x)
+        ((@)template)
+        \s+
+        # One or more valid identifiers
+        (
+          [A-Za-z_$]         # First character: non-numeric word character
+          [\w$.\[\]]*        # Rest of identifier
+          (?:                # Possible list of additional identifiers
+            \s* , \s*
+            [A-Za-z_$]
+