diff --git a/.gitmodules b/.gitmodules
index e7ce67b..9f29130 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -7,9 +7,6 @@
 [submodule "sublime_syntaxes/LESS-sublime"]
 	path = sublime_syntaxes/LESS-sublime
 	url = https://github.com/danro/LESS-sublime.git
-[submodule "sublime_syntaxes/TypeScript-Sublime-Plugin"]
-	path = sublime_syntaxes/TypeScript-Sublime-Plugin
-	url = https://github.com/Microsoft/TypeScript-Sublime-Plugin.git
 [submodule "sublime_syntaxes/Handlebars"]
 	path = sublime_syntaxes/Handlebars
 	url = https://github.com/daaain/Handlebars.git
@@ -31,3 +28,6 @@
 [submodule "sublime_syntaxes/Sublime-VimL"]
 	path = sublime_syntaxes/Sublime-VimL
 	url = https://github.com/SalGnt/Sublime-VimL.git
+[submodule "sublime_syntaxes/TypeScript-TmLanguage"]
+	path = sublime_syntaxes/TypeScript-TmLanguage
+	url = https://github.com/Microsoft/TypeScript-TmLanguage
diff --git a/docs/content/documentation/content/syntax-highlighting.md b/docs/content/documentation/content/syntax-highlighting.md
index cd8a92f..9160bca 100644
--- a/docs/content/documentation/content/syntax-highlighting.md
+++ b/docs/content/documentation/content/syntax-highlighting.md
@@ -32,7 +32,8 @@ Here is a full list of the supported languages and the short names you can use:
 - Jinja2 -> ["j2", "jinja2"]
 - Julia -> ["jl"]
 - Kotlin -> ["kt", "kts"]
-- LESS -> ["less"]
+- Less -> ["less", "css.less"]
+- Nim -> ["nim", "nims"]
 - ASP -> ["asa"]
 - HTML (ASP) -> ["asp"]
 - ActionScript -> ["as"]
@@ -57,12 +58,12 @@ Here is a full list of the supported languages and the short names you can use:
 - Java Server Page (JSP) -> ["jsp"]
 - Java -> ["java", "bsh"]
 - Java Properties -> ["properties"]
-- JSON -> ["json", "sublime-settings", "sublime-menu", "sublime-keymap", "sublime-mousemap", "sublime-theme", "sublime-build", "sublime-project", "sublime-completions", "sublime-commands", "sublime-macro"]
+- JSON -> ["json", "sublime-settings", "sublime-menu", "sublime-keymap", "sublime-mousemap", "sublime-theme", "sublime-build", "sublime-project", "sublime-completions", "sublime-commands", "sublime-macro", "sublime-color-scheme"]
 - JavaScript -> ["js", "htc"]
 - BibTeX -> ["bib"]
 - LaTeX -> ["tex", "ltx"]
 - TeX -> ["sty", "cls"]
-- Lisp -> ["lisp", "cl", "l", "mud", "el", "scm", "ss", "lsp", "fasl"]
+- Lisp -> ["lisp", "cl", "clisp", "l", "mud", "el", "scm", "ss", "lsp", "fasl"]
 - Lua -> ["lua"]
 - Makefile -> ["make", "GNUmakefile", "makefile", "Makefile", "OCamlMakefile", "mak", "mk"]
 - Markdown -> ["md", "mdown", "markdown", "markdn"]
@@ -89,13 +90,14 @@ Here is a full list of the supported languages and the short names you can use:
 - Rust -> ["rs"]
 - SQL -> ["sql", "ddl", "dml"]
 - Scala -> ["scala", "sbt"]
-- Bourne Again Shell (bash) -> ["sh", "bash", "zsh", "fish", ".bash_aliases", ".bash_functions", ".bash_login", ".bash_logout", ".bash_profile", ".bash_variables", ".bashrc", ".profile", ".textmate_init"]
+- Bourne Again Shell (bash) -> ["sh", "bash", "zsh", "fish", ".bash_aliases", ".bash_completions", ".bash_functions", ".bash_login", ".bash_logout", ".bash_profile", ".bash_variables", ".bashrc", ".profile", ".textmate_init"]
 - HTML (Tcl) -> ["adp"]
 - Tcl -> ["tcl"]
 - Textile -> ["textile"]
 - XML -> ["xml", "xsd", "xslt", "tld", "dtml", "rss", "opml", "svg"]
 - YAML -> ["yaml", "yml", "sublime-syntax"]
-- Generic Config -> ["cfg", "conf", "config", "ini", "pro"]
+- SWI-Prolog -> ["pro"]
+- Generic Config -> ["cfg", "conf", "config", "ini", "pro", "mak", "mk", "Doxyfile", "inputrc", ".inputrc", "dircolors", ".dircolors", "gitmodules", ".gitmodules", "gitignore", ".gitignore", "gitattributes", ".gitattributes"]
 - Linker Script -> ["ld"]
 - TOML -> ["toml", "tml"]
 - TypeScript -> ["ts"]
diff --git a/sublime_syntaxes/Elm.sublime-syntax b/sublime_syntaxes/Elm.sublime-syntax
deleted file mode 100644
index 9e9eb66..0000000
--- a/sublime_syntaxes/Elm.sublime-syntax
+++ /dev/null
@@ -1,200 +0,0 @@
-%YAML 1.2
----
-# http://www.sublimetext.com/docs/3/syntax.html
-name: Elm
-file_extensions:
-  - elm
-scope: source.elm
-contexts:
-  main:
-    - match: "(`)[a-zA-Z_']*?(`)"
-      scope: keyword.operator.function.infix.elm
-      captures:
-        1: punctuation.definition.entity.elm
-        2: punctuation.definition.entity.elm
-    - match: \(\)
-      scope: constant.language.unit.elm
-    - match: ^\b((effect|port)\s+)?(module)\s+
-      captures:
-        1: keyword.other.elm
-        3: keyword.other.elm
-      push:
-        - meta_scope: meta.declaration.module.elm
-        - match: $|;
-          captures:
-            1: keyword.other.elm
-          pop: true
-        - include: module_name
-        - match: '(where)\s*\{'
-          captures:
-            1: keyword.other.elm
-          push:
-            - match: '\}'
-              pop: true
-            - include: type_signature
-        - match: (exposing)
-          scope: keyword.other.elm
-        - include: module_exports
-        - match: (where)
-          scope: keyword.other.elm
-        - match: "[a-z]+"
-          scope: invalid
-    - match: ^\b(import)\s+((open)\s+)?
-      captures:
-        1: keyword.other.elm
-        3: invalid
-      push:
-        - meta_scope: meta.import.elm
-        - match: ($|;)
-          pop: true
-        - match: (as|exposing)
-          scope: keyword.import.elm
-        - include: module_name
-        - include: module_exports
-    - match: '(\[)(glsl)(\|)'
-      captures:
-        1: keyword.other.elm
-        2: support.function.prelude.elm
-        3: keyword.other.elm
-      push:
-        - meta_scope: entity.glsl.elm
-        - match: '(\|\])'
-          captures:
-            1: keyword.other.elm
-          pop: true
-        - include: scope:source.glsl
-    - match: \b(type alias|type|case|of|let|in|as)\s+
-      scope: keyword.other.elm
-    - match: \b(if|then|else)\s+
-      scope: keyword.control.elm
-    - match: '\b([0-9]+\.[0-9]+([eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+)\b'
-      comment: Floats are always decimal
-      scope: constant.numeric.float.elm
-    - match: '\b([0-9]+)\b'
-      scope: constant.numeric.elm
-    - match: '"""'
-      captures:
-        0: punctuation.definition.string.begin.elm
-      push:
-        - meta_scope: string.quoted.double.elm
-        - match: '"""'
-          captures:
-            0: punctuation.definition.string.end.elm
-          pop: true
-        - match: '\\(NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL|[abfnrtv\\''\&])'
-          scope: constant.character.escape.elm
-        - match: '\^[A-Z@\[\]\\\^_]'
-          scope: constant.character.escape.control.elm
-    - match: '"'
-      captures:
-        0: punctuation.definition.string.begin.elm
-      push:
-        - meta_scope: string.quoted.double.elm
-        - match: '"'
-          captures:
-            0: punctuation.definition.string.end.elm
-          pop: true
-        - match: '\\(NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL|[abfnrtv\\\"''\&])'
-          scope: constant.character.escape.elm
-        - match: '\^[A-Z@\[\]\\\^_]'
-          scope: constant.character.escape.control.elm
-    - match: |-
-        (?x)
-        (')
-        (?:
-          [\ -\[\]-~]               # Basic Char
-          | (\\(?:NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE
-            |DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS
-            |US|SP|DEL|[abfnrtv\\\"'\&]))   # Escapes
-          | (\^[A-Z@\[\]\\\^_])           # Control Chars
-        )
-        (')
-      scope: string.quoted.single.elm
-      captures:
-        1: punctuation.definition.string.begin.elm
-        2: constant.character.escape.elm
-        3: punctuation.definition.string.end.elm
-    - match: '^(port\s+)?([a-z_][a-zA-Z0-9_'']*|\([|!%$+\-.,=</>]+\))\s*((:)([:]+)?)'
-      captures:
-        1: keyword.other.port.elm
-        2: entity.name.function.elm
-        4: keyword.other.colon.elm
-        5: invalid
-      push:
-        - meta_scope: meta.function.type-declaration.elm
-        - match: $\n?
-          pop: true
-        - include: type_signature
-    - match: \bport\s+
-      scope: keyword.other.port.elm
-    - match: '\b[A-Z]\w*\b'
-      scope: constant.other.elm
-    - include: comments
-    - match: '^[a-z][A-Za-z0-9_'']*\s+'
-      scope: entity.name.function.elm
-    - include: infix_op
-    - match: '[|!%$?~+:\-.=</>&\\*^]+'
-      scope: keyword.operator.elm
-    - match: '([\[\]\{\},])'
-      scope: constant.language.delimiter.elm
-      captures:
-        1: support.function.delimiter.elm
-    - match: '([\(\)])'
-      scope: keyword.other.parenthesis.elm
-  block_comment:
-    - match: '\{-(?!#)'
-      captures:
-        0: punctuation.definition.comment.elm
-      push:
-        - meta_scope: comment.block.elm
-        - include: block_comment
-        - match: '-\}'
-          captures:
-            0: punctuation.definition.comment.elm
-          pop: true
-  comments:
-    - match: (--).*$\n?
-      scope: comment.line.double-dash.elm
-      captures:
-        1: punctuation.definition.comment.elm
-    - include: block_comment
-  infix_op:
-    - match: '(\([|!%$+:\-.=</>]+\)|\(,+\))'
-      scope: entity.name.function.infix.elm
-  module_exports:
-    - match: \(
-      push:
-        - meta_scope: meta.declaration.exports.elm
-        - match: \)
-          pop: true
-        - match: '\b[a-z][a-zA-Z_''0-9]*'
-          scope: entity.name.function.elm
-        - match: '\b[A-Z][A-Za-z_''0-9]*'
-          scope: storage.type.elm
-        - match: ","
-          scope: punctuation.separator.comma.elm
-        - include: infix_op
-        - match: \(.*?\)
-          comment: So named because I don't know what to call this.
-          scope: meta.other.unknown.elm
-  module_name:
-    - match: "[A-Z][A-Za-z._']*"
-      scope: support.other.module.elm
-  type_signature:
-    - match: '\(\s*([A-Z][A-Za-z]*)\s+([a-z][A-Za-z_'']*)\)\s*(=>)'
-      scope: meta.class-constraint.elm
-      captures:
-        1: entity.other.inherited-class.elm
-        2: variable.other.generic-type.elm
-        3: keyword.other.big-arrow.elm
-    - match: "->"
-      scope: keyword.other.arrow.elm
-    - match: "=>"
-      scope: keyword.other.big-arrow.elm
-    - match: '\b[a-z][a-zA-Z0-9_'']*\b'
-      scope: variable.other.generic-type.elm
-    - match: '\b[A-Z][a-zA-Z0-9_'']*\b'
-      scope: storage.type.elm
-    - match: \(\)
-      scope: support.constant.unit.elm
-    - include: comments
diff --git a/sublime_syntaxes/LESS.sublime-syntax b/sublime_syntaxes/LESS.sublime-syntax
deleted file mode 100644
index 38cfd30..0000000
--- a/sublime_syntaxes/LESS.sublime-syntax
+++ /dev/null
@@ -1,326 +0,0 @@
-%YAML 1.2
----
-# http://www.sublimetext.com/docs/3/syntax.html
-name: LESS
-comment: LESS
-file_extensions:
-  - less
-scope: source.less
-contexts:
-  main:
-    - include: comment-block
-    - include: comment-line
-    - include: less-at-rules
-    - include: less-declarations
-    - include: less-variables
-    - include: less-functions
-    - include: string-double
-    - include: string-single
-    - include: selector
-    - include: rule-list
-    - include: less-operators
-    - include: less-parameters
-    - include: numeric-values
-  color-values:
-    - match: \b(aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)\b
-      comment: http://www.w3.org/TR/CSS21/syndata.html#value-def-color
-      scope: support.constant.color.w3c-standard-color-name.css
-    - match: \b(aliceblue|antiquewhite|aquamarine|azure|beige|bisque|blanchedalmond|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkgrey|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkslategrey|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dimgrey|dodgerblue|firebrick|floralwhite|forestgreen|gainsboro|ghostwhite|gold|goldenrod|greenyellow|grey|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgray|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightslategrey|lightsteelblue|lightyellow|limegreen|linen|magenta|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|oldlace|olivedrab|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|skyblue|slateblue|slategray|slategrey|snow|springgreen|steelblue|tan|thistle|tomato|turquoise|violet|wheat|whitesmoke|yellowgreen)\b
-      comment: "These colours are mostly recognised but will not validate. ref: http://www.w3schools.com/css/css_colornames.asp"
-      scope: support.constant.color.non-standard
-    - match: (hsla?|rgba?)\s*(\()
-      captures:
-        1: support.function.misc.css
-        2: punctuation.section.function.css
-      push:
-        - match: (\))
-          captures:
-            1: punctuation.section.function.css
-          pop: true
-        - match: '(?x)\b(0*((1?[0-9]{1,2})|(2([0-4][0-9]|5[0-5])))\s*,\s*){2}(0*((1?[0-9]{1,2})|(2([0-4][0-9]|5[0-5])))\b)(\s*,\s*((0?\.[0-9]+)|[0-1]))?'
-          scope: constant.other.color.rgb-value.css
-        - match: '\b([0-9]{1,2}|100)\s*%,\s*([0-9]{1,2}|100)\s*%,\s*([0-9]{1,2}|100)\s*%'
-          scope: constant.other.color.rgb-percentage.css
-        - include: numeric-values
-  comment-block:
-    - match: /\*
-      captures:
-        0: punctuation.definition.comment.css
-      push:
-        - meta_scope: comment.block.css
-        - match: \*/
-          captures:
-            0: punctuation.definition.comment.css
-          pop: true
-  comment-line:
-    - match: //
-      captures:
-        0: punctuation.definition.comment.css
-      push:
-        - meta_scope: comment.line.double-slash.less
-        - match: $\n?
-          captures:
-            0: punctuation.definition.comment.css
-          pop: true
-  less-at-rules:
-    - match: ^\s*((@)(?:-(?:webkit|moz|o)-)?(charset|import|namespace|media|page|font-face|keyframes|supports|document)\b)
-      scope: meta.at-rule.css
-      captures:
-        1: keyword.control.at-rule.css
-        2: punctuation.definition.keyword.css
-  less-data-uri:
-    - match: (url)(\()(data:)
-      captures:
-        1: support.function.misc.css
-        2: punctuation.section.function.css
-        3: parameter.less.data-uri comment markup.raw
-      push:
-        - meta_content_scope: parameter.less.data-uri comment markup.raw
-        - match: (\))
-          captures:
-            1: punctuation.section.function.css
-          pop: true
-    - match: (url)(\()("data:)
-      captures:
-        1: support.function.misc.css
-        2: punctuation.section.function.css
-        3: parameter.less.data-uri comment markup.raw
-      push:
-        - meta_content_scope: parameter.less.data-uri comment markup.raw
-        - match: (?<=")(\))
-          captures:
-            1: punctuation.section.function.css
-          pop: true
-    - match: (url)(\()('data:)
-      captures:
-        1: support.function.misc.css
-        2: punctuation.section.function.css
-        3: parameter.less.data-uri comment markup.raw
-      push:
-        - meta_content_scope: parameter.less.data-uri comment markup.raw
-        - match: (?<=\')(\))
-          captures:
-            1: punctuation.section.function.css
-          pop: true
-  less-declarations:
-    - match: '(?>@[a-zA-Z0-9_-][\w-]*+)(?!:)'
-      scope: variable.other.less
-    - match: '@[a-zA-Z0-9_-][\w-]*'
-      scope: variable.declaration.less
-  less-functions:
-    - match: '([%a-zA-Z\-\_\d]*)(?=\()'
-      scope: support.function.less
-    - match: '([\.#](?![0-9])[a-zA-Z0-9_-]+(?=\())'
-      captures:
-        1: entity.other.attribute-name.class.css entity.other.less.mixin
-  less-operators:
-    - match: /|!important|$|%|&|\*|\-\-|\-|\+\+|\+|~|===|==|=|!=|!==|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\|\||\?\:|(?<!\()/=|%=|\+=|\-=|&=|when\b|and\b|not\b
-      scope: keyword.operator.less
-  less-parameters:
-    - match: '\(|(}\s*,)'
-      push:
-        - meta_scope: parameter.less
-        - match: '\)|{'
-          pop: true
-        - include: color-values
-        - include: less-parameters
-        - include: less-functions
-        - include: numeric-values
-        - include: string-double
-        - include: string-single
-        - include: less-variables
-        - match: '(?:\:/)?[\/\.a-zA-Z0-9_\-]*'
-          scope: variable.parameter.misc.css
-        - include: less-operators
-  less-variables:
-    - match: '@[a-zA-Z0-9_-][\w-]*'
-      scope: variable.other.less
-    - match: '@{[a-zA-Z0-9_-][\w-]*}'
-      scope: variable.interpolation.less
-    - match: "`"
-      push:
-        - meta_scope: comment markup.raw
-        - match: "`"
-          pop: true
-    - match: (~)`
-      captures:
-        1: keyword.operator.less
-      push:
-        - meta_scope: comment markup.raw
-        - match: "`"
-          pop: true
-    - match: (~)"
-      captures:
-        1: keyword.operator.less
-      push:
-        - meta_scope: string.quoted.double.css comment markup.raw
-        - match: '"'
-          pop: true
-    - match: (~)'
-      captures:
-        1: keyword.operator.less
-      push:
-        - meta_scope: string.quoted.single.css comment markup.raw
-        - match: "'"
-          pop: true
-  numeric-values:
-    - match: '(#)([0-9a-fA-F]{3}|[0-9a-fA-F]{6})\b'
-      scope: constant.other.color.rgb-value.css
-      captures:
-        1: punctuation.definition.constant.css
-    - match: '(?x)(?:-|\+)?(?:(?:[0-9]+(?:\.[0-9]+)?)|(?:\.[0-9]+))((?:px|pt|ch|cm|mm|in|r?em|ex|pc|deg|g?rad|dpi|dpcm|ms|s)\b|%)?'
-      scope: constant.numeric.css
-      captures:
-        1: keyword.other.unit.css
-  property-names:
-    - match: "(?<![-a-z])(?=[-a-z])"
-      push:
-        - meta_scope: support.type.property-name.css
-        - match: "$|(?![-a-z])"
-          pop: true
-        - match: \b(word)\b
-          scope: support.type.property-name.css
-  property-values:
-    - include: less-variables
-    - include: less-data-uri
-    - include: less-functions
-    - include: less-operators
-    - include: color-values
-    - include: numeric-values
-    - include: less-parameters
-    - match: \b(absolute|all(-scroll)?|always|subpixel-antialiased|antialiased|armenian|auto|avoid|baseline|below|bidi-override|block|bold|bolder|border-box|both|bottom|break-all|break-word|capitalize|center|char|circle|cjk-ideographic|content-box|col-resize|collapse|crosshair|dashed|decimal-leading-zero|decimal|default|disabled|disc|distribute-all-lines|distribute-letter|distribute-space|distribute|dotted|double|e-resize|ellipsis|fixed|geometricPrecision|georgian|groove|hand|hebrew|help|hidden|hiragana-iroha|hiragana|horizontal|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space|inactive|inherit|inline-block|inline|inset|inside|inter-ideograph|inter-word|italic|justify|katakana-iroha|katakana|keep-all|left|lighter|line-edge|line-through|line|list-item|loose|lower-alpha|lower-greek|lower-latin|lower-roman|lowercase|lr-tb|ltr|medium|middle|move|n-resize|ne-resize|newspaper|no-drop|no-repeat|nw-resize|none|normal|not-allowed|nowrap|oblique|optimize(Legibility|Quality|Speed)|outset|outside|overline|pointer|pre(-(wrap|line))?|progress|relative|repeat-x|repeat-y|repeat|right|ridge|row-resize|rtl|s-resize|scroll|se-resize|separate|small-caps|solid|square|static|strict|sub|super|sw-resize|table-caption|table-cell|table-column-group|table-column|table-footer-group|table-header-group|table-row-group|table|tb-rl|text-bottom|text-top|textfield|text|thick|thin|top|transparent|underline|upper-alpha|upper-latin|upper-roman|uppercase|vertical(-(ideographic|text))?|visible(Painted|Fill|Stroke)?|w-resize|wait|whitespace|zero|smaller|larger|((xx?-)?(small|large))|painted|fill|stroke)\b
-      scope: support.constant.property-value.css
-    - include: selector
-    - match: (\b(?i:arial|century|comic|courier|garamond|georgia|helvetica|impact|lucida|symbol|system|tahoma|times|trebuchet|utopia|verdana|webdings|sans-serif|serif|monospace)\b)
-      scope: support.constant.font-name.css
-    - include: string-double
-    - include: string-single
-    - match: (rect)\s*(\()
-      captures:
-        1: support.function.misc.css
-        2: punctuation.section.function.css
-      push:
-        - match: (\))
-          captures:
-            1: punctuation.section.function.css
-          pop: true
-        - include: numeric-values
-    - match: (format|local|url|attr|counter|counters)\s*(\()
-      captures:
-        1: support.function.misc.css
-        2: punctuation.section.function.css
-      push:
-        - match: (\))
-          captures:
-            1: punctuation.section.function.css
-          pop: true
-        - include: string-single
-        - include: string-double
-        - match: '[^''") \t]+'
-          scope: variable.parameter.misc.css
-    - match: \!\s*important
-      scope: keyword.other.important.css
-  rule-list:
-    - include: comment-block
-    - include: comment-line
-    - include: selector
-    - include: property-names
-    - match: (:)\s*
-      captures:
-        1: punctuation.separator.key-value.css
-      push:
-        - meta_scope: meta.property-value.css
-        - match: '\s*(;|(?=[{}]))'
-          captures:
-            1: punctuation.terminator.rule.css
-          pop: true
-        - include: property-values
-  selector:
-    - match: '\b(a|abbr|acronym|address|area|article|aside|audio|b|base|big|blockquote|body|br|button|canvas|caption|cite|code|col|colgroup|datalist|dd|del|details|dfn|dialog|div|dl|dt|em|eventsource|fieldset|figure|figcaption|footer|form|frame|frameset|(h[1-6])|head|header|hgroup|hr|html|i|iframe|img|input|ins|kbd|label|legend|li|link|map|mark|menu|meta|meter|nav|noframes|noscript|object|ol|optgroup|option|output|p|param|pre|progress|q|samp|script|section|select|small|span|strike|strong|style|sub|summary|sup|svg|table|tbody|td|textarea|tfoot|th|thead|time|title|tr|tt|ul|var|video)\b'
-      scope: entity.name.tag.css, keyword.control.html.elements
-    - match: '(\.)-?[a-zA-Z_][a-zA-Z0-9_-]*'
-      scope: entity.other.attribute-name.class.css
-      captures:
-        1: punctuation.definition.entity.css
-    - match: "(#)-?[a-zA-Z_][a-zA-Z0-9_-]*"
-      scope: entity.other.attribute-name.id.css
-      captures:
-        1: punctuation.definition.entity.css
-    - match: \*
-      scope: entity.name.tag.wildcard.css
-    - match: (:+)((first|last|only)-child|(first|last|only)-of-type|empty|root|target|first-letter|first-line|first|left|right|lang)\b
-      scope: entity.other.attribute-name.pseudo-class.css
-      captures:
-        1: punctuation.definition.entity.css
-    - match: (:)(extend)\b
-      scope: entity.other.attribute-name.pseudo-class.less
-      captures:
-        1: punctuation.definition.entity.css
-    - match: (:)(checked|enabled|default|disabled|indeterminate|invalid|optional|required|valid)\b
-      scope: entity.other.attribute-name.pseudo-class.ui-state.css
-      captures:
-        1: punctuation.definition.entity.css
-    - match: ((:)not)(\()
-      captures:
-        1: entity.other.attribute-name.pseudo-class.css
-        2: punctuation.definition.entity.css
-        3: punctuation.section.function.css
-      push:
-        - match: \)
-          captures:
-            0: punctuation.section.function.css
-          pop: true
-        - include: selector
-    - match: ((:)nth-(?:(?:last-)?child|(?:last-)?of-type))(\()
-      captures:
-        1: entity.other.attribute-name.pseudo-class.css
-        2: punctuation.definition.entity.css
-        3: punctuation.section.function.css
-      push:
-        - meta_content_scope: constant.numeric.css
-        - match: (\))
-          captures:
-            1: punctuation.section.function.css
-          pop: true
-    - match: (:+)(?:-(?:webkit|moz|o)-)?(after|before|selection|scrollbar|placeholder|input-placeholder)\b
-      scope: entity.other.attribute-name.pseudo-element.css
-      captures:
-        1: punctuation.definition.entity.css
-    - match: (:+)(?:-(?:webkit|moz|o)-)?(active|hover|link|visited|focus-inner|focus)\b
-      scope: entity.other.attribute-name.pseudo-class.css
-      captures:
-        1: punctuation.definition.entity.css
-    - match: '(?i)(\[)\s*(-?[_a-z\\[[:^ascii:]]][_a-z0-9\-\\[[:^ascii:]]]*)(?:\s*([~|^$*]?=)\s*(?:(-?[_a-z\\[[:^ascii:]]][_a-z0-9\-\\[[:^ascii:]]]*)|((?>([''"])(?:[^\\]|\\.)*?(\6)))))?\s*(\])'
-      scope: meta.attribute-selector.css
-      captures:
-        1: punctuation.definition.entity.css
-        2: entity.other.attribute-name.attribute.css
-        3: punctuation.separator.operator.css
-        4: string.unquoted.attribute-value.css
-        5: string.quoted.double.attribute-value.css
-        6: punctuation.definition.string.begin.css
-        7: punctuation.definition.string.end.css
-  string-double:
-    - match: '"'
-      captures:
-        0: punctuation.definition.string.begin.css
-      push:
-        - meta_scope: string.quoted.double.css
-        - match: '"'
-          captures:
-            0: punctuation.definition.string.end.css
-          pop: true
-        - match: \\.
-          scope: constant.character.escape.css
-  string-single:
-    - match: "'"
-      captures:
-        0: punctuation.definition.string.begin.css
-      push:
-        - meta_scope: string.quoted.single.css
-        - match: "'"
-          captures:
-            0: punctuation.definition.string.end.css
-          pop: true
-        - match: \\.
-          scope: constant.character.escape.css
diff --git a/sublime_syntaxes/Prolog.sublime-syntax b/sublime_syntaxes/Prolog.sublime-syntax
new file mode 100644
index 0000000..06aa619
--- /dev/null
+++ b/sublime_syntaxes/Prolog.sublime-syntax
@@ -0,0 +1,135 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: SWI-Prolog
+comment: This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+file_extensions:
+  - pro
+scope: source.prolog
+contexts:
+  main:
+    - include: comments
+    - match: (?<=:-)\s*
+      push:
+        - meta_scope: meta.clause.body.prolog
+        - match: (\.)
+          captures:
+            1: keyword.control.clause.bodyend.prolog
+          pop: true
+        - include: comments
+        - include: builtin
+        - include: controlandkeywords
+        - include: atom
+        - include: variable
+        - include: constants
+        - match: .
+          scope: meta.clause.body.prolog
+    - match: '^\s*([a-z][a-zA-Z0-9_]*)(\(?)(?=.*:-.*)'
+      captures:
+        1: entity.name.function.clause.prolog
+        2: punctuation.definition.parameters.begin
+      push:
+        - meta_scope: meta.clause.head.prolog
+        - match: ((\)?))\s*(:-)
+          captures:
+            1: punctuation.definition.parameters.end
+            3: keyword.control.clause.bodybegin.prolog
+          pop: true
+        - include: atom
+        - include: variable
+        - include: constants
+    - match: '^\s*([a-z][a-zA-Z0-9_]*)(\(?)(?=.*-->.*)'
+      captures:
+        1: entity.name.function.dcg.prolog
+        2: punctuation.definition.parameters.begin
+      push:
+        - meta_scope: meta.dcg.head.prolog
+        - match: ((\)?))\s*(-->)
+          captures:
+            1: punctuation.definition.parameters.end
+            3: keyword.control.dcg.bodybegin.prolog
+          pop: true
+        - include: atom
+        - include: variable
+        - include: constants
+    - match: (?<=-->)\s*
+      push:
+        - meta_scope: meta.dcg.body.prolog
+        - match: (\.)
+          captures:
+            1: keyword.control.dcg.bodyend.prolog
+          pop: true
+        - include: comments
+        - include: controlandkeywords
+        - include: atom
+        - include: variable
+        - include: constants
+        - match: .
+          scope: meta.dcg.body.prolog
+    - match: '^\s*([a-zA-Z][a-zA-Z0-9_]*)(\(?)(?!.*(:-|-->).*)'
+      captures:
+        1: entity.name.function.fact.prolog
+        2: punctuation.definition.parameters.begin
+      push:
+        - meta_scope: meta.fact.prolog
+        - match: ((\)?))\s*(\.)(?!\d+)
+          captures:
+            1: punctuation.definition.parameters.end
+            3: keyword.control.fact.end.prolog
+          pop: true
+        - include: atom
+        - include: variable
+        - include: constants
+  atom:
+    - match: '(?<![a-zA-Z0-9_])[a-z][a-zA-Z0-9_]*(?!\s*\(|[a-zA-Z0-9_])'
+      scope: constant.other.atom.simple.prolog
+    - match: "'.*?'"
+      scope: constant.other.atom.quoted.prolog
+    - match: '\[\]'
+      scope: constant.other.atom.emptylist.prolog
+  builtin:
+    - match: \b(op|findall|write|nl|writeln|fail|use_module|module)\b
+      scope: keyword.other
+  comments:
+    - match: "%.*"
+      scope: comment.line.percent-sign.prolog
+    - match: /\*
+      captures:
+        0: punctuation.definition.comment.prolog
+      push:
+        - meta_scope: comment.block.prolog
+        - match: \*/
+          captures:
+            0: punctuation.definition.comment.prolog
+          pop: true
+  constants:
+    - match: '(?<![a-zA-Z]|/)(\d+|(\d+\.\d+))'
+      scope: constant.numeric.integer.prolog
+    - match: '".*?"'
+      scope: string.quoted.double.prolog
+  controlandkeywords:
+    - match: (->)
+      captures:
+        1: keyword.control.if.prolog
+      push:
+        - meta_scope: meta.if.prolog
+        - match: (;)
+          captures:
+            1: keyword.control.else.prolog
+          pop: true
+        - include: main
+        - include: builtin
+        - include: comments
+        - include: atom
+        - include: variable
+        - match: .
+          scope: meta.if.body.prolog
+    - match: "!"
+      scope: keyword.control.cut.prolog
+    - match: (\s(is)\s)|=:=|=?\\?=|\\\+|@?>|@?=?<|\+|\*|\-
+      scope: keyword.operator.prolog
+  variable:
+    - match: "(?<![a-zA-Z0-9_])[A-Z][a-zA-Z0-9_]*"
+      scope: variable.parameter.uppercase.prolog
+    - match: (?<!\w)_
+      scope: variable.language.anonymous.prolog
diff --git a/sublime_syntaxes/TypeScript-Sublime-Plugin b/sublime_syntaxes/TypeScript-Sublime-Plugin
deleted file mode 160000
index 79bf8dd..0000000
--- a/sublime_syntaxes/TypeScript-Sublime-Plugin
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 79bf8ddfb8a05a2b104f3937cd91b6f2afbbb943
diff --git a/sublime_syntaxes/TypeScript-TmLanguage b/sublime_syntaxes/TypeScript-TmLanguage
new file mode 160000
index 0000000..c29d12d
--- /dev/null
+++ b/sublime_syntaxes/TypeScript-TmLanguage
@@ -0,0 +1 @@
+Subproject commit c29d12d8aceb1a68af4cb6e466199846f41dd2ed
diff --git a/sublime_syntaxes/TypeScript.sublime-syntax b/sublime_syntaxes/TypeScript.sublime-syntax
index 92338e1..123580a 100644
--- a/sublime_syntaxes/TypeScript.sublime-syntax
+++ b/sublime_syntaxes/TypeScript.sublime-syntax
@@ -24,32 +24,32 @@ contexts:
             0: punctuation.definition.comment.ts
           pop: true
         - include: docblock
-    - match: /\*
+    - match: (/\*)(?:\s*((@)internal)(?=\s|(\*/)))?
       captures:
-        0: punctuation.definition.comment.ts
+        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]+)?(?=//)'
+    - 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:
-        - match: (?=$)
+        - meta_content_scope: comment.line.double-slash.ts
+        - match: (?=^)
           pop: true
-        - match: //
-          captures:
-            0: punctuation.definition.comment.ts
-          push:
-            - meta_scope: comment.line.double-slash.ts
-            - match: (?=$)
-              pop: true
   access-modifier:
-    - match: (?<!\.|\$)\b(abstract|public|protected|private|readonly|static)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(abstract|public|protected|private|readonly|static)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: storage.modifier.ts
-  after-operator-block:
+  after-operator-block-as-object-literal:
     - match: '(?<=[=(,\[?+!]|await|return|yield|throw|in|of|typeof|&&|\|\||\*)\s*(\{)'
       captures:
         1: punctuation.definition.block.ts
@@ -85,42 +85,41 @@ contexts:
         - include: expression
         - include: punctuation-comma
   arrow-function:
-    - match: '(?:(?<!\.|\$)(\basync)\s*)?([_$[:alpha:]][_$[:alnum:]]*)\s*(?==>)'
+    - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)\s+)?([_$[:alpha:]][_$[:alnum:]]*)\s*(?==>)'
       scope: meta.arrow.ts
       captures:
         1: storage.modifier.async.ts
         2: variable.parameter.ts
     - match: |-
         (?x) (?:
-          (?<!\.|\$)(\basync)(?=\s*[<(])
-        ) | ((?<![})\]])\s*
+          (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)
+        )? ((?<![})!\]])\s*
           (?=
             # sure shot arrow functions even if => is on new line
-            (
-              [(]\s*
-              (
-                ([)]\s*:) |                               # ():
-                ([_$[:alpha:]][_$[:alnum:]]*\s*:) |       # [(]param:
-                (\.\.\.)                                  # [(]...
-              )
-            ) |
-            (
-              [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
-            ) |
-            # arrow function possible to detect only with => on same line
-            (
-              (<([^<>]|\<[^<>]+\>)+>\s*)?                 # typeparameters
-              \(([^()]|\([^()]*\))*\)                     # parameteres
-              (\s*:\s*(.)*)?                              # return type
-              \s*=>                                       # arrow operator
-            )
+        (
+          [(]\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*[^()]*)?\))*)?\)                          # parameteres
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+          \s*=>                                                                         # arrow operator
+        )
           )
         )
       captures:
         1: storage.modifier.async.ts
       push:
         - meta_scope: meta.arrow.ts
-        - match: '(?==>|\{)'
+        - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'
           pop: true
         - include: comment
         - include: type-parameters
@@ -131,7 +130,7 @@ contexts:
         0: storage.type.function.arrow.ts
       push:
         - meta_scope: meta.arrow.ts
-        - match: '(?<=\})|((?!\{)(?=\S))'
+        - match: '(?<=\}|\S)(?<!=>)|((?!\{)(?=\S))'
           pop: true
         - include: decl-block
         - include: expression
@@ -141,18 +140,13 @@ contexts:
         1: keyword.operator.type.annotation.ts
       push:
         - meta_scope: meta.return.type.arrow.ts
-        - match: '(?==>|\{)'
+        - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'
           pop: true
-        - match: '(?<=:)\s*(\{)'
-          captures:
-            1: punctuation.definition.block.ts
+        - match: '(?<=[:])(?=\s*\{)'
           push:
-            - meta_scope: meta.object.type.ts
-            - match: '\}'
-              captures:
-                0: punctuation.definition.block.ts
+            - match: '(?<=\})'
               pop: true
-            - include: type-object-members
+            - include: type-object
         - include: type-predicate-operator
         - include: type
   binding-element:
@@ -162,32 +156,70 @@ contexts:
     - include: destructuring-variable-rest
     - include: variable-initializer
   boolean-literal:
-    - match: (?<!\.|\$)\btrue\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))true(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.boolean.true.ts
-    - match: (?<!\.|\$)\bfalse\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))false(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.boolean.false.ts
-  case-clause:
-    - match: (?<!\.|\$)\b(case|default(?=:))\b(?!\$)
+  brackets:
+    - match: "{"
+      push:
+        - match: '}|(?=\*/)'
+          pop: true
+        - include: brackets
+    - match: '\['
+      push:
+        - match: '\]|(?=\*/)'
+          pop: true
+        - include: brackets
+  cast:
+    - match: '(?:(?<=return|throw|yield|await|default|[=(,:>*?\&\|\^]|[^_$[:alnum:]](?:\+\+|\-\-)|[^\+]\+|[^\-]\-))\s*(<)(?!<?\=)'
       captures:
-        1: keyword.control.switch.ts
+        1: meta.brace.angle.ts
       push:
-        - meta_scope: case-clause.expr.ts
-        - match: ":"
+        - meta_scope: cast.expr.ts
+        - match: (\>)\s*
           captures:
-            0: punctuation.definition.section.case-statement.ts
+            1: meta.brace.angle.ts
           pop: true
-        - include: expression
-  cast:
-    - match: '(?:(?<=return|throw|yield|await|default|^|[=(,:>*]))\s*(<)(?!<?\=)'
+        - include: type
+    - match: '(?:(?<=^))\s*(<)(?=[_$[:alpha:]][_$[:alnum:]]*\s*>)'
       captures:
         1: meta.brace.angle.ts
       push:
         - meta_scope: cast.expr.ts
-        - match: \>
+        - match: (\>)\s*
           captures:
-            0: meta.brace.angle.ts
+            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:
@@ -207,67 +239,49 @@ contexts:
         - include: variable-initializer
         - include: access-modifier
         - include: property-accessor
-        - include: after-operator-block
+        - include: after-operator-block-as-object-literal
         - include: decl-block
         - include: expression
         - include: punctuation-comma
         - include: punctuation-semicolon
-  class-or-interface-declaration:
-    - match: '(?<!\.|\$)\b(?:(export)\s+)?\b(?:(abstract)\s+)?\b(?:(class)|(interface))\b(?=\s+|/[/*])'
-      captures:
-        1: keyword.control.export.ts
-        2: storage.modifier.ts
-        3: storage.type.class.ts
-        4: storage.type.interface.ts
-      push:
-        - meta_scope: meta.class.ts
-        - match: '(?<=\})'
-          captures:
-            1: punctuation.definition.block.ts
-          pop: true
-        - 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-or-interface-heritage:
-    - match: (?<!\.|\$)(?:\b(extends|implements)\b)(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(extends|implements)\b)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       captures:
         1: storage.modifier.ts
       push:
         - match: '(?=\{)'
-          captures:
-            1: punctuation.definition.block.ts
           pop: true
         - include: comment
         - include: class-or-interface-heritage
         - include: type-parameters
-        - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(\.)(?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s*\.\s*[_$[:alpha:]][_$[:alnum:]]*)*\s*([,<{]|extends|implements|//|/\*))'
+        - 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
-        - match: '([_$[:alpha:]][_$[:alnum:]]*)(?=\s*([,<{]|extends|implements|//|/\*))'
+            3: punctuation.accessor.optional.ts
+        - match: "([_$[:alpha:]][_$[:alnum:]]*)"
           captures:
             1: entity.other.inherited-class.ts
-        - include: expression
+        - include: expressionPunctuations
   control-statement:
-    - match: (?<!\.|\$)\b(catch|finally|throw|try)\b(?!\$)
+    - include: switch-statement
+    - include: for-loop
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(catch|finally|throw|try)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.trycatch.ts
-    - match: (?<!\.|\$)\b(break|continue|do|goto|while)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|do|goto|while)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.loop.ts
-    - match: (?<!\.|\$)\b(return)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(return)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.flow.ts
-    - match: (?<!\.|\$)\b(case|default|switch)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default|switch)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.switch.ts
-    - match: (?<!\.|\$)\b(else|if)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(else|if)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.conditional.ts
-    - match: (?<!\.|\$)\b(with)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(with)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.with.ts
-    - match: (?<!\.|\$)\b(debugger)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(debugger)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.other.debugger.ts
-    - match: (?<!\.|\$)\b(declare)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(declare)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: storage.modifier.ts
   decl-block:
     - match: '\{'
@@ -284,15 +298,16 @@ contexts:
     - include: decorator
     - include: var-expr
     - include: function-declaration
-    - include: class-or-interface-declaration
-    - include: type-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: (?<!\.|\$)\@
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))\@'
       captures:
         0: punctuation.decorator.ts
       push:
@@ -331,7 +346,7 @@ contexts:
     - match: '(?<!=|:|of|in)\s*(?=\{)'
       push:
         - meta_scope: meta.object-binding-pattern-variable.ts
-        - match: '(?=$|[;,=}]|(\s+(of|in)\s+))'
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
           pop: true
         - include: object-binding-pattern
         - include: type-annotation
@@ -339,7 +354,7 @@ contexts:
     - match: '(?<!=|:|of|in)\s*(?=\[)'
       push:
         - meta_scope: meta.array-binding-pattern-variable.ts
-        - match: '(?=$|[;,=}]|(\s+(of|in)\s+))'
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
           pop: true
         - include: array-binding-pattern
         - include: type-annotation
@@ -350,12 +365,12 @@ contexts:
         1: keyword.operator.rest.ts
         2: meta.definition.variable.ts variable.other.readwrite.ts
   directives:
-    - match: '^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|name)\s*=\s*((\''[^'']*\'')|(\"[^"]*\")))+\s*/>\s*$)'
+    - match: '^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|name)\s*=\s*((\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")))+\s*/>\s*$)'
       captures:
         1: punctuation.definition.comment.ts
       push:
         - meta_scope: comment.line.triple-slash.directive.ts
-        - match: (?=$)
+        - match: (?=^)
           pop: true
         - match: (<)(reference|amd-dependency|amd-module)
           captures:
@@ -374,270 +389,251 @@ contexts:
             - include: string
   docblock:
     - match: |-
-        (?x)(?<!\w)@(
-        abstract|access|alias|arg|argument|async|attribute|augments|author|beta|borrows|bubbes|callback|chainable|class
-        |classdesc|code|config|const|constant|constructor|constructs|copyright|default|defaultvalue|define|deprecated|desc
-        |description|dict|emits|enum|event|example|exports?|extends|extension|extension_for|extensionfor|external|file
-        |fileoverview|final|fires|for|function|global|host|ignore|implements|implicitCast|inherit[Dd]oc|inner|instance
-        |interface|kind|lends|license|listens|main|member|memberof|method|mixex|mixins?|modifies|module|name|namespace
-        |noalias|nocollapse|nocompile|nosideeffects|override|overview|package|param|preserve|private|prop|property
-        |protected|public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary|suppress
-        |template|this|throws|todo|type|typedef|unrestricted|uses|var|variation|version|virtual|writeOnce)\b
-      scope: storage.type.class.jsdoc
+        (?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+
         (
-          \[
-            [^\]]+            # Optional [link text] preceding {@link syntax}
-          \]
-
-          (?!                  # Check to avoid highlighting two sets of link text
-            {
-              @\w+            # Tagname
-              \s+
-              [^\s|}]+        # Namepath/URL
-              [\s|]           # Whitespace or bar delimiting description
-              [^}]*
-            }
-          )
-        )?
-
-        (?:
-          {
-            (
-              @
-              (?: link         # Name of tag
-                | linkcode
-                | linkplain
-                | tutorial
-              )
-            )
-
-            \s+
-
-            ([^\s|}]+)        # Namepath or URL
-
-            (?:                # Optional link text following link target
-              [\s|]           # Bar or space separating target and text
-              [^}]*            # Actual text
-            )?
-          }
+          [^@\s<>*/]
+          (?:[^@<>*/]|\*[^/])*
         )
-      scope: other.meta.jsdoc
+        (?:
+          \s*
+          (<)
+          ([^>\s]+)
+          (>)
+        )?
       captures:
-        0: entity.name.type.instance.jsdoc
-        1: constant.other.description.jsdoc
-        2: storage.type.class.jsdoc
-        3: variable.other.description.jsdoc
+        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)
-
-        (?:(?<=@param)|(?<=@arg)|(?<=@argument)|(?<=@type)|(?<=@property)|(?<=@prop))
-
+        ((@)see)
         \s+
-
-        ({(?:
-          \* |                                       # {*} any type
-          \? |                                       # {?} unknown type
-
-          (?:
-            (?:                                       # Check for a prefix
-              \? |                                   # {?string} nullable type
-              !   |                                   # {!string} non-nullable type
-              \.{3}                                  # {...string} variable number of parameters
-            )?
-
-            (?:
-              (?:
-                function                              # {function(string, number)} function type
-                \s*
-                \(
-                \s*
-                (?:
-                  [a-zA-Z_$][\w$]*
-                  (?:
-                    \s*,\s*
-                    [a-zA-Z_$][\w$]*
-                  )*
-                )?
-                \s*
-                \)
-                (?:                                   # {function(): string} function return type
-                  \s*:\s*
-                  [a-zA-Z_$][\w$]*
-                )?
-              )?
+        (?:
+          # URL
+          (
+            (?=https?://)
+            (?:[^\s*]|\*[^/])+
+          )
+          |
+          # JSDoc namepath
+          (
+            (?!
+              # Avoid matching bare URIs (also acceptable as links)
+              https?://
               |
-              (?:
-                \(                                   # Opening bracket of multiple types with parenthesis {(string|number)}
-                  [a-zA-Z_$]+
-                  (?:
-                    (?:
-                      [\w$]*
-                      (?:\[\])?                     # {(string[]|number)} type application, an array of strings or a number
-                    ) |
-                    \.?<[\w$]+(?:,\s+[\w$]+)*>    # {Array<string>} or {Object<string, number>} type application (optional .)
-                  )
-                  (?:
-                    [\.|~]                           # {Foo.bar} namespaced, {string|number} multiple, {Foo~bar} class-specific callback
-                    [a-zA-Z_$]+
-                    (?:
-                      (?:
-                        [\w$]*
-                        (?:\[\])?                   # {(string|number[])} type application, a string or an array of numbers
-                      ) |
-                      \.?<[\w$]+(?:,\s+[\w$]+)*>  # {Array<string>} or {Object<string, number>} type application (optional .)
-                    )
-                  )*
-                \) |
-                [a-zA-Z_$]+
-                (?:
-                  (?:
-                    [\w$]*
-                    (?:\[\])?                       # {(string|number[])} type application, a string or an array of numbers
-                  ) |
-                  \.?<[\w$]+(?:,\s+[\w$]+)*>      # {Array<string>} or {Object<string, number>} type application (optional .)
-                )
-                (?:
-                  [\.|~]                             # {Foo.bar} namespaced, {string|number} multiple, {Foo~bar} class-specific callback
-                  [a-zA-Z_$]+
-                  (?:
-                    [\w$]* |
-                    \.?<[\w$]+(?:,\s+[\w$]+)*>    # {Array<string>} or {Object<string, number>} type application (optional .)
-                  )
-                )*
-              )
+              # Avoid matching {@inline tags}; we match those below
+              (?:\[[^\[\]]*\])? # Possible description [preceding]{@tag}
+              {@(?:link|linkcode|linkplain|tutorial)\b
             )
-                                                      # Check for suffix
-            (?:\[\])?                               # {string[]} type application, an array of strings
-            =?                                        # {string=} optional parameter
+            # 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
         (
-          \[                                         # [foo] optional parameter
-            \s*
-            (?:
-              [a-zA-Z_$][\w$]*
-              (?:
-                (?:\[\])?                           # Foo[].bar properties within an array
-                \.                                   # Foo.Bar namespaced parameter
-                [a-zA-Z_$][\w$]*
-              )*
-              (?:
-                \s*
-                =                                     # [foo=bar] Default parameter value
-                \s*
-                [\w$\s]*
-              )?
-            )
-            \s*
-          \] |
-          (?:
-            [a-zA-Z_$][\w$]*
-            (?:
-              (?:\[\])?                             # Foo[].bar properties within an array
-              \.                                     # Foo.Bar namespaced parameter
-              [a-zA-Z_$][\w$]*
-            )*
-          )?
+          [A-Za-z_$]         # First character: non-numeric word character
+          [\w$.\[\]]*        # Rest of identifier
+          (?:                # Possible list of additional identifiers
+            \s* , \s*
+            [A-Za-z_$]
+            [\w$.\[\]]*
+          )*
         )
-
-        \s+
-
-        (?:-\s+)?                                     # optional hyphen before the description
-
-        ((?:(?!\*\/).)*)                             # The type description
-      captures:
-        0: other.meta.jsdoc
-        1: entity.name.type.instance.jsdoc
-        2: variable.other.jsdoc
-        3: other.description.jsdoc
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: variable.other.jsdoc
     - match: |-
         (?x)
-
-        ({(?:
-          \* |                                       # {*} any type
-          \? |                                       # {?} unknown type
-
-          (?:
-            (?:                                       # Check for a prefix
-              \? |                                   # {?string} nullable type
-              !   |                                   # {!string} non-nullable type
-              \.{3}                                  # {...string} variable number of parameters
-            )?
-
+        (
+          (@)
+          (?:arg|argument|const|constant|member|namespace|param|var)
+        )
+        \s+
+        (
+          [A-Za-z_$]
+          [\w$.\[\]]*
+        )
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: variable.other.jsdoc
+    - match: '((@)typedef)\s+(?={)'
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+      push:
+        - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'
+          pop: true
+        - include: jsdoctype
+        - match: '(?:[^@\s*/]|\*[^/])+'
+          scope: entity.name.type.instance.jsdoc
+    - match: '((@)(?:arg|argument|const|constant|member|namespace|param|prop|property|var))\s+(?={)'
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+      push:
+        - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'
+          pop: true
+        - include: jsdoctype
+        - match: '([A-Za-z_$][\w$.\[\]]*)'
+          scope: variable.other.jsdoc
+        - match: |-
+            (?x)
+            (\[)\s*
+            [\w$]+
             (?:
-              (?:
-                function                              # {function(string, number)} function type
-                \s*
-                \(
-                \s*
-                (?:
-                  [a-zA-Z_$][\w$]*
-                  (?:
-                    \s*,\s*
-                    [a-zA-Z_$][\w$]*
-                  )*
-                )?
-                \s*
-                \)
-                (?:                                   # {function(): string} function return type
-                  \s*:\s*
-                  [a-zA-Z_$][\w$]*
-                )?
-              )?
-              |
-              (?:
-                \(                                   # Opening bracket of multiple types with parenthesis {(string|number)}
-                  [a-zA-Z_$]+
-                  (?:
-                    [\w$]* |
-                    \.?<[\w$]+(?:,\s+[\w$]+)*>    # {Array<string>} or {Object<string, number>} type application (optional .)
-                  )
-                  (?:
-                    [\.|~]                           # {Foo.bar} namespaced, {string|number} multiple, {Foo~bar} class-specific callback
-                    [a-zA-Z_$]+
-                    (?:
-                      [\w$]* |
-                      \.?<[\w$]+(?:,\s+[\w$]+)*>  # {Array<string>} or {Object<string, number>} type application (optional .)
-                    )
-                  )*
-                \) |
-                [a-zA-Z_$]+
-                (?:
-                  [\w$]* |
-                  \.?<[\w$]+(?:,\s+[\w$]+)*>      # {Array<string>} or {Object<string, number>} type application (optional .)
-                )
-                (?:
-                  [\.|~]                             # {Foo.bar} namespaced, {string|number} multiple, {Foo~bar} class-specific callback
-                  [a-zA-Z_$]+
-                  (?:
-                    [\w$]* |
-                    \.?<[\w$]+(?:,\s+[\w$]+)*>    # {Array<string>} or {Object<string, number>} type application (optional .)
-                  )
+              (?:\[\])?                                        # Foo[ ].bar properties within an array
+              \.                                                # Foo.Bar namespaced parameter
+              [\w$]+
+            )*
+            (?:
+              \s*
+              (=)                                                # [foo=bar] Default parameter value
+              \s*
+              (
+                # The inner regexes are to stop the match early at */ and to not stop at escaped quotes
+                (?>
+                  "(?:(?:\*(?!/))|(?:\\(?!"))|[^*\\])*?" |                      # [foo="bar"] Double-quoted
+                  '(?:(?:\*(?!/))|(?:\\(?!'))|[^*\\])*?' |                      # [foo='bar'] Single-quoted
+                  \[ (?:(?:\*(?!/))|[^*])*? \] |                                # [foo=[1,2]] Array literal
+                  (?:(?:\*(?!/))|\s(?!\s*\])|\[.*?(?:\]|(?=\*/))|[^*\s\[\]])*   # Everything else
                 )*
               )
-            )
-                                                      # Check for suffix
-            (?:\[\])?                               # {string[]} type application, an array of strings
-            =?                                        # {string=} optional parameter
-          )
-        )})
-
+            )?
+            \s*(?:(\])((?:[^*\s]|\*[^\s/])+)?|(?=\*/))
+          scope: variable.other.jsdoc
+          captures:
+            1: punctuation.definition.optional-value.begin.bracket.square.jsdoc
+            2: keyword.operator.assignment.jsdoc
+            3: source.embedded.ts
+            4: punctuation.definition.optional-value.end.bracket.square.jsdoc
+            5: invalid.illegal.syntax.jsdoc
+    - match: |-
+        (?x)
+        (
+          (@)
+          (?:define|enum|exception|export|extends|lends|implements|modifies
+          |namespace|private|protected|returns?|suppress|this|throws|type
+          |yields?)
+        )
+        \s+(?={)
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+      push:
+        - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'
+          pop: true
+        - include: jsdoctype
+    - match: |-
+        (?x)
+        (
+          (@)
+          (?:alias|augments|callback|constructs|emits|event|fires|exports?
+          |extends|external|function|func|host|lends|listens|interface|memberof!?
+          |method|module|mixes|mixin|name|requires|see|this|typedef|uses)
+        )
         \s+
-
-        (?:-\s+)?                                    # optional hyphen before the description
-
-        ((?:(?!\*\/).)*)                            # The type description
-      captures:
-        0: other.meta.jsdoc
-        1: entity.name.type.instance.jsdoc
-        2: other.description.jsdoc
+        (
+          (?:
+            [^{}@\s*] | \*[^/]
+          )+
+        )
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: entity.name.type.instance.jsdoc
+    - match: '((@)(?:default(?:value)?|license|version))\s+(([''''"]))'
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: variable.other.jsdoc
+        4: punctuation.definition.string.begin.jsdoc
+      push:
+        - meta_content_scope: variable.other.jsdoc
+        - match: (\3)|(?=$|\*/)
+          captures:
+            0: variable.other.jsdoc
+            1: punctuation.definition.string.end.jsdoc
+          pop: true
+    - match: '((@)(?:default(?:value)?|license|tutorial|variation|version))\s+([^\s*]+)'
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: variable.other.jsdoc
+    - match: '(?x) (@) (?:abstract|access|alias|api|arg|argument|async|attribute|augments|author|beta|borrows|bubbles |callback|chainable|class|classdesc|code|config|const|constant|constructor|constructs|copyright |default|defaultvalue|define|deprecated|desc|description|dict|emits|enum|event|example|exception |exports?|extends|extension(?:_?for)?|external|externs|file|fileoverview|final|fires|for|func |function|generator|global|hideconstructor|host|ignore|implements|implicitCast|inherit[Dd]oc |inner|instance|interface|internal|kind|lends|license|listens|main|member|memberof!?|method |mixes|mixins?|modifies|module|name|namespace|noalias|nocollapse|nocompile|nosideeffects |override|overview|package|param|polymer(?:Behavior)?|preserve|private|prop|property|protected |public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary |suppress|template|this|throws|todo|tutorial|type|typedef|unrestricted|uses|var|variation |version|virtual|writeOnce|yields?) \b'
+      scope: storage.type.class.jsdoc
+      captures:
+        1: punctuation.definition.block.tag.jsdoc
+    - include: inline-tags
   enum-declaration:
-    - match: '(?<!\.|\$)(?:(\bexport)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*)'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*)'
       captures:
         1: keyword.control.export.ts
         2: storage.modifier.ts
@@ -665,7 +661,7 @@ contexts:
                   pop: true
                 - include: comment
                 - include: variable-initializer
-            - match: '(?=((\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\])))'
+            - match: '(?=((\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\])))'
               push:
                 - match: '(?=,|\}|$)'
                   pop: true
@@ -675,75 +671,59 @@ contexts:
                 - include: variable-initializer
             - include: punctuation-comma
   export-declaration:
-    - match: '(?<!\.|\$)\b(export)\s+(as)\s+(namespace)\s+([_$[:alpha:]][_$[:alnum:]]*)'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)\s+(as)\s+(namespace)\s+([_$[:alpha:]][_$[:alnum:]]*)'
       captures:
         1: keyword.control.export.ts
         2: keyword.control.as.ts
         3: storage.type.namespace.ts
         4: entity.name.type.module.ts
-    - match: (?<!\.|\$)\b(export)(?:(?:\s*(=))|(?:\s+(default)(?=\s+)))
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:(?:\s*(=))|(?:\s+(default)(?=\s+)))'
       captures:
         1: keyword.control.export.ts
         2: keyword.operator.assignment.ts
         3: keyword.control.default.ts
       push:
         - meta_scope: meta.export.default.ts
-        - match: (?=;|\bexport\b|\bfunction\b|\bclass\b|\binterface\b|\blet\b|\bvar\b|\bconst\b|\bimport\b|\benum\b|\bnamespace\b|\bmodule\b|\btype\b|\babstract\b|\bdeclare\b|\basync\b|$)
+        - match: (?=;|$|\babstract\b|\basync\b|\bclass\b|\bconst\b|\bdeclare\b|\benum\b|\bexport\b|\bfunction\b|\bimport\b|\binterface\b|\blet\b|\bmodule\b|\bnamespace\b|\btype\b|\bvar\b)
           pop: true
         - include: expression
-    - match: (?<!\.|\$)\b(export)(?!(\s*:)|(\$))\b
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?!\s*:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       captures:
         0: keyword.control.export.ts
       push:
         - meta_scope: meta.export.ts
-        - match: (?=;|\bexport\b|\bfunction\b|\bclass\b|\binterface\b|\blet\b|\bvar\b|\bconst\b|\bimport\b|\benum\b|\bnamespace\b|\bmodule\b|\btype\b|\babstract\b|\bdeclare\b|\basync\b|$)
+        - match: (?=;|$|\babstract\b|\basync\b|\bclass\b|\bconst\b|\bdeclare\b|\benum\b|\bexport\b|\bfunction\b|\bimport\b|\binterface\b|\blet\b|\bmodule\b|\bnamespace\b|\btype\b|\bvar\b)
           pop: true
         - include: import-export-declaration
   expression:
-    - include: string
-    - include: regex
-    - include: template
-    - include: comment
-    - include: function-expression
-    - include: class-or-interface-declaration
-    - include: arrow-function
-    - include: cast
-    - include: ternary-expression
-    - include: new-expr
-    - include: object-literal
-    - include: expression-operators
-    - include: function-call
-    - include: literal
-    - include: support-objects
+    - include: expressionWithoutIdentifiers
     - include: identifiers
-    - include: paren-expression
-    - include: punctuation-comma
-    - include: punctuation-accessor
+    - include: expressionPunctuations
   expression-operators:
-    - match: (?<!\.|\$)\b(await)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(await)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.flow.ts
-    - match: (?<!\.|\$)\b(yield)\b(?!\$)(?:\s*(\*))?
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(yield)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?:\s*(\*))?'
       captures:
         1: keyword.control.flow.ts
         2: keyword.generator.asterisk.ts
-    - match: (?<!\.|\$)\bdelete\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))delete(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.delete.ts
-    - match: (?<!\.|\$)\bin\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))in(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.in.ts
-    - match: (?<!\.|\$)\bof\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))of(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.of.ts
-    - match: (?<!\.|\$)\binstanceof\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.instanceof.ts
-    - match: (?<!\.|\$)\bnew\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.new.ts
     - include: typeof-operator
-    - match: (?<!\.|\$)\bvoid\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))void(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.void.ts
-    - match: (?<!\.|\$)\bas\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'
       captures:
-        0: keyword.control.as.ts
+        1: keyword.control.as.ts
       push:
-        - match: '(?=$|[;,:})\]])'
+        - match: '(?=$|^|[;,:})\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+))'
           pop: true
         - include: type
     - match: \.\.\.
@@ -773,18 +753,38 @@ contexts:
     - match: '(?<=[_$[:alnum:])])\s*(/)(?![/*])'
       captures:
         1: keyword.operator.arithmetic.ts
+  expressionPunctuations:
+    - include: punctuation-comma
+    - include: punctuation-accessor
+  expressionWithoutIdentifiers:
+    - include: string
+    - include: regex
+    - include: template
+    - include: comment
+    - include: function-expression
+    - include: class-expression
+    - include: arrow-function
+    - include: cast
+    - include: ternary-expression
+    - include: new-expr
+    - include: object-literal
+    - include: expression-operators
+    - include: function-call
+    - include: literal
+    - include: support-objects
+    - include: paren-expression
   field-declaration:
-    - match: '(?<!\()(?:(?<!\.|\$)\b(readonly)\s+)?(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))'
+    - match: '(?<!\()(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s+)?(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))'
       captures:
         1: storage.modifier.ts
       push:
         - meta_scope: meta.field.declaration.ts
-        - match: '(?=\}|;|,|$)|(?<=\})'
+        - match: '(?=\}|;|,|$|(^(?!(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))))|(?<=\})'
           pop: true
         - include: variable-initializer
-        - match: '(?=((?:[_$[:alpha:]][_$[:alnum:]]*)|(?:\''[^'']*\'')|(?:\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))'
+        - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))'
           push:
-            - match: '(?=[};,=]|$)|(?<=\})'
+            - match: '(?=[};,=]|$|(^(?!(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))))|(?<=\})'
               pop: true
             - include: type-annotation
             - include: string
@@ -792,34 +792,53 @@ contexts:
             - include: comment
             - match: |-
                 (?x)([_$[:alpha:]][_$[:alnum:]]*)(?=(\?\s*)?\s*
-                  (=\s*(
-                    (async\s+) |
-                    (function\s*[(<]) |
+                # function assignment |
+                (=\s*(
+                  ((async\s+)?(
+                    (function\s*[(<*]) |
                     (function\s+) |
-                    ([_$[:alpha:]][_$[:alnum:]]*\s*=>) |
-                    ([(]\s*(([)]\s*:)|([_$[:alpha:]][_$[:alnum:]]*\s*:)|(\.\.\.) )) |
-                    ([<]\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s*[^=>])|(\s*[,]))) |
-                    ((<([^<>]|\<[^<>]+\>)+>\s*)?\(([^()]|\([^()]*\))*\)(\s*:\s*(.)*)?\s*=>))
-                  ) |
-                  (:\s*(
-                    (<) |
-                    ([(]\s*(
-                      ([)]) |
-                      (\.\.\.) |
-                      ([_$[:alnum:]]+\s*(
-                        ([:,?=])|
-                        ([)]\s*=>)
-                      ))
-                    )))
+                    ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
+                  )) |
+                  ((async\s*)?(
+                    # sure shot arrow functions even if => is on new line
+                (
+                  [(]\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*[^()]*)?\))*)?\)                          # parameteres
+                  (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+                  \s*=>                                                                         # arrow operator
                 )
+                  ))
+                )) |
+                # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
+                (:\s*(
+                  (<) |
+                  ([(]\s*(
+                    ([)]) |
+                    (\.\.\.) |
+                    ([_$[:alnum:]]+\s*(
+                      ([:,?=])|
+                      ([)]\s*=>)
+                    ))
+                  ))
+                )))
               scope: meta.definition.property.ts entity.name.function.ts
             - match: "[_$[:alpha:]][_$[:alnum:]]*"
               scope: meta.definition.property.ts variable.object.property.ts
             - match: \?
               scope: keyword.operator.optional.ts
   for-loop:
-    - match: (?<!\.|\$)\b(for)(?:\s+(await))?\s*(\()
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(for)(?:\s+(await))?\s*(\()'
       captures:
         1: keyword.control.loop.ts
         2: keyword.control.loop.ts
@@ -832,18 +851,33 @@ contexts:
         - include: var-expr
         - include: expression
         - include: punctuation-semicolon
+  function-body:
+    - include: comment
+    - include: type-parameters
+    - include: function-parameters
+    - include: return-type
+    - include: decl-block
   function-call:
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\.\s*)*|(\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)\s*(<([^<>]|\<[^<>]+\>)+>\s*)?\()'
+    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)\s*(\?\.\s*)?(<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\))|\<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\)))*\>)*>\s*)?\()'
       push:
-        - match: '(?<=\))(?!(([_$[:alpha:]][_$[:alnum:]]*\s*\.\s*)*|(\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)\s*(<([^<>]|\<[^<>]+\>)+>\s*)?\()'
+        - match: '(?<=\))(?!(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)\s*(\?\.\s*)?(<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\))|\<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\)))*\>)*>\s*)?\()'
           pop: true
-        - include: literal
-        - include: support-objects
-        - include: object-identifiers
-        - include: punctuation-accessor
-        - match: "([_$[:alpha:]][_$[:alnum:]]*)"
-          scope: entity.name.function.ts
+        - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))'
+          push:
+            - meta_scope: meta.function-call.ts
+            - match: '(?=\s*(\?\.\s*)?(<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\))|\<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\)))*\>)*>\s*)?\()'
+              pop: true
+            - include: literal
+            - include: support-objects
+            - include: object-identifiers
+            - include: punctuation-accessor
+            - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*[\(]\s*[\"\''\`]))'
+              scope: keyword.operator.expression.import.ts
+            - match: "([_$[:alpha:]][_$[:alnum:]]*)"
+              scope: entity.name.function.ts
         - include: comment
+        - match: \?\.
+          scope: meta.function-call.ts punctuation.accessor.optional.ts
         - match: \<
           captures:
             0: punctuation.definition.typeparameters.begin.ts
@@ -857,7 +891,7 @@ contexts:
             - include: punctuation-comma
         - include: paren-expression
   function-declaration:
-    - match: '(?<!\.|\$)\b(?:(export)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'
       captures:
         1: keyword.control.export.ts
         2: storage.modifier.async.ts
@@ -866,15 +900,11 @@ contexts:
         5: meta.definition.function.ts entity.name.function.ts
       push:
         - meta_scope: meta.function.ts
-        - match: '(?=$|;)|(?<=\})'
+        - match: '(?=$|^|;)|(?<=\})'
           pop: true
-        - include: comment
-        - include: type-parameters
-        - include: function-parameters
-        - include: return-type
-        - include: decl-block
+        - include: function-body
   function-expression:
-    - match: '(?<!\.|\$)\b(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'
       captures:
         1: storage.modifier.async.ts
         2: storage.type.function.ts
@@ -884,11 +914,7 @@ contexts:
         - meta_scope: meta.function.expression.ts
         - match: '(?<=\})'
           pop: true
-        - include: comment
-        - include: type-parameters
-        - include: function-parameters
-        - include: return-type
-        - include: decl-block
+        - include: function-body
   function-parameters:
     - match: \(
       captures:
@@ -910,39 +936,63 @@ contexts:
   identifiers:
     - include: object-identifiers
     - match: |-
-        (?x)(?:(\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)(?=\s*=\s*(
-        (async\s+)|(function\s*[(<])|(function\s+)|
-        ([_$[:alpha:]][_$[:alnum:]]*\s*=>)|
-        ([(]\s*(([)]\s*:)|([_$[:alpha:]][_$[:alnum:]]*\s*:)|(\.\.\.) )) |
-        ([<]\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s*[^=>])|(\s*[,]))) |
-        ((<([^<>]|\<[^<>]+\>)+>\s*)?\(([^()]|\([^()]*\))*\)(\s*:\s*(.)*)?\s*=>)))
+        (?x)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*)?([_$[:alpha:]][_$[:alnum:]]*)(?=\s*=\s*(
+          ((async\s+)?(
+            (function\s*[(<*]) |
+            (function\s+) |
+            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
+          )) |
+          ((async\s*)?(
+            # sure shot arrow functions even if => is on new line
+        (
+          [(]\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*[^()]*)?\))*)?\)                          # parameteres
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+          \s*=>                                                                         # arrow operator
+        )
+          ))
+        ))
       captures:
         1: punctuation.accessor.ts
-        2: entity.name.function.ts
-    - match: '(\.)\s*([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])'
+        2: punctuation.accessor.optional.ts
+        3: entity.name.function.ts
+    - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])'
       captures:
         1: punctuation.accessor.ts
-        2: variable.other.constant.property.ts
-    - match: '(\.)\s*([_$[:alpha:]][_$[:alnum:]]*)'
+        2: punctuation.accessor.optional.ts
+        3: variable.other.constant.property.ts
+    - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*([_$[:alpha:]][_$[:alnum:]]*)'
       captures:
         1: punctuation.accessor.ts
-        2: variable.other.property.ts
+        2: punctuation.accessor.optional.ts
+        3: variable.other.property.ts
     - match: "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])"
       scope: variable.other.constant.ts
     - match: "[_$[:alpha:]][_$[:alnum:]]*"
       scope: variable.other.readwrite.ts
   import-declaration:
-    - match: (?<!\.|\$)(?:(\bexport)\s+)?\b(import)(?!(\s*:)|(\$))\b
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)(?!\s*[:\(])(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       captures:
         1: keyword.control.export.ts
         2: keyword.control.import.ts
       push:
         - meta_scope: meta.import.ts
-        - match: (?=;|$)
+        - match: (?=;|$|^)
           pop: true
         - include: import-export-declaration
   import-equals-declaration:
-    - match: '(?<!\.|\$)(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\()'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\()'
       captures:
         1: keyword.control.export.ts
         2: keyword.control.import.ts
@@ -958,7 +1008,7 @@ contexts:
           pop: true
         - include: comment
         - include: string
-    - match: '(?<!\.|\$)(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b)'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b)'
       captures:
         1: keyword.control.export.ts
         2: keyword.control.import.ts
@@ -966,13 +1016,14 @@ contexts:
         4: keyword.operator.assignment.ts
       push:
         - meta_scope: meta.import-equals.internal.ts
-        - match: (?=;|$)
+        - match: (?=;|$|^)
           pop: true
         - include: comment
-        - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(\.)'
+        - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))'
           captures:
             1: entity.name.type.module.ts
             2: punctuation.accessor.ts
+            3: punctuation.accessor.optional.ts
         - match: "([_$[:alpha:]][_$[:alnum:]]*)"
           scope: variable.other.readwrite.ts
   import-export-block:
@@ -988,17 +1039,13 @@ contexts:
         - include: import-export-clause
   import-export-clause:
     - include: comment
-    - match: |-
-        (?x) (?: \b(default)\b | (\*) | ([_$[:alpha:]][_$[:alnum:]]*)) \s+
-        (as) \s+ (?: (\b default \b | \*) | ([_$[:alpha:]][_$[:alnum:]]*))
-      comment: (default|*|name) as alias
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bdefault)|(\*)|(\b[_$[:alpha:]][_$[:alnum:]]*))\s+(as)\s+(\b[_$[:alpha:]][_$[:alnum:]]*)'
       captures:
         1: keyword.control.default.ts
         2: constant.language.import-export-all.ts
         3: variable.other.readwrite.ts
         4: keyword.control.as.ts
-        5: invalid.illegal.ts
-        6: variable.other.readwrite.alias.ts
+        5: variable.other.readwrite.alias.ts
     - include: punctuation-comma
     - match: \*
       scope: constant.language.import-export-all.ts
@@ -1014,7 +1061,7 @@ contexts:
       scope: keyword.control.from.ts
     - include: import-export-clause
   indexer-declaration:
-    - match: '(?:(?<!\.|\$)\b(readonly)\s*)?(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:)'
+    - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s*)?(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:)'
       captures:
         1: storage.modifier.ts
         2: meta.brace.square.ts
@@ -1028,7 +1075,7 @@ contexts:
           pop: true
         - include: type-annotation
   indexer-mapped-type-declaration:
-    - match: '(?:(?<!\.|\$)\b(readonly)\s*)?(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s+(in)\s+'
+    - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s*)?(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s+(in)\s+'
       captures:
         1: storage.modifier.ts
         2: meta.brace.square.ts
@@ -1042,6 +1089,63 @@ contexts:
             2: keyword.operator.optional.ts
           pop: true
         - include: type
+  inline-tags:
+    - match: '(\[)[^\]]+(\])(?={@(?:link|linkcode|linkplain|tutorial))'
+      scope: constant.other.description.jsdoc
+      captures:
+        1: punctuation.definition.bracket.square.begin.jsdoc
+        2: punctuation.definition.bracket.square.end.jsdoc
+    - match: '({)((@)(?:link(?:code|plain)?|tutorial))\s*'
+      captures:
+        1: punctuation.definition.bracket.curly.begin.jsdoc
+        2: storage.type.class.jsdoc
+        3: punctuation.definition.inline.tag.jsdoc
+      push:
+        - meta_scope: entity.name.type.instance.jsdoc
+        - match: '}|(?=\*/)'
+          captures:
+            0: punctuation.definition.bracket.curly.end.jsdoc
+          pop: true
+        - match: '\G((?=https?://)(?:[^|}\s*]|\*[/])+)(\|)?'
+          captures:
+            1: variable.other.link.underline.jsdoc
+            2: punctuation.separator.pipe.jsdoc
+        - match: '\G((?:[^{}@\s|*]|\*[^/])+)(\|)?'
+          captures:
+            1: variable.other.description.jsdoc
+            2: punctuation.separator.pipe.jsdoc
+  interface-declaration:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?\b(?:(abstract)\s+)?\b(interface)\b(?=\s+|/[/*])'
+      captures:
+        1: keyword.control.export.ts
+        2: storage.modifier.ts
+        3: storage.type.interface.ts
+      push:
+        - meta_scope: meta.interface.ts
+        - match: '(?<=\})'
+          pop: true
+        - include: comment
+        - include: class-or-interface-heritage
+        - match: "[_$[:alpha:]][_$[:alnum:]]*"
+          captures:
+            0: entity.name.type.interface.ts
+        - include: type-parameters
+        - include: class-or-interface-body
+  jsdoctype:
+    - match: '\G{(?:[^}*]|\*[^/}])+$'
+      scope: invalid.illegal.type.jsdoc
+    - match: '\G({)'
+      captures:
+        0: entity.name.type.instance.jsdoc
+        1: punctuation.definition.bracket.curly.begin.jsdoc
+      push:
+        - meta_content_scope: entity.name.type.instance.jsdoc
+        - match: '((}))\s*|(?=\*/)'
+          captures:
+            1: entity.name.type.instance.jsdoc
+            2: punctuation.definition.bracket.curly.end.jsdoc
+          pop: true
+        - include: brackets
   literal:
     - include: numeric-literal
     - include: boolean-literal
@@ -1052,27 +1156,35 @@ contexts:
     - include: this-literal
     - include: super-literal
   method-declaration:
-    - match: '(?<!\.|\$)(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(?:\b(?:(new)|(constructor))\b(?!\$|:))|(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))?\s*[\(\<]))'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])'
       captures:
         1: storage.modifier.ts
         2: storage.modifier.ts
         3: storage.modifier.async.ts
         4: storage.type.property.ts
-        5: keyword.operator.new.ts
-        6: storage.type.ts
-        7: keyword.generator.asterisk.ts
+        5: keyword.generator.asterisk.ts
       push:
         - meta_scope: meta.method.declaration.ts
         - match: '(?=\}|;|,|$)|(?<=\})'
           pop: true
         - include: method-declaration-name
-        - include: comment
-        - include: type-parameters
-        - include: function-parameters
-        - include: return-type
-        - include: decl-block
+        - include: function-body
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:(?:\b(?:(new)|(constructor))\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))?\s*[\(\<]))'
+      captures:
+        1: storage.modifier.ts
+        2: storage.modifier.ts
+        3: storage.modifier.async.ts
+        4: keyword.operator.new.ts
+        5: storage.type.ts
+        6: keyword.generator.asterisk.ts
+      push:
+        - meta_scope: meta.method.declaration.ts
+        - match: '(?=\}|;|,|$)|(?<=\})'
+          pop: true
+        - include: method-declaration-name
+        - include: function-body
   method-declaration-name:
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??)\s*[\(\<])'
+    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??)\s*[\(\<])'
       push:
         - match: (?=\(|\<)
           pop: true
@@ -1083,32 +1195,33 @@ contexts:
         - match: \?
           scope: keyword.operator.optional.ts
   namespace-declaration:
-    - match: '(?<!\.|\$)(?:(\bexport)\s+)?\b(namespace|module)\s+(?=[_$[:alpha:]"''`])'
+    - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(namespace|module)\s+(?=[_$[:alpha:]"''`]))'
       captures:
         1: keyword.control.export.ts
         2: storage.type.namespace.ts
       push:
         - meta_scope: meta.namespace.declaration.ts
-        - match: '(?=$|\{)'
+        - match: '(?<=\})|(?=;|\babstract\b|\basync\b|\bclass\b|\bconst\b|\bdeclare\b|\benum\b|\bexport\b|\bfunction\b|\bimport\b|\binterface\b|\blet\b|\bmodule\b|\bnamespace\b|\btype\b|\bvar\b)'
           pop: true
         - include: comment
         - include: string
         - match: "([_$[:alpha:]][_$[:alnum:]]*)"
           scope: entity.name.type.module.ts
         - include: punctuation-accessor
+        - include: decl-block
   new-expr:
-    - match: (?<!\.|\$)\b(new)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       captures:
         1: keyword.operator.new.ts
       push:
         - meta_scope: new.expr.ts
-        - match: '(?<=\))|(?=[;),}]|$|((?<!\.|\$)\bnew\b(?!\$)))'
+        - match: '(?<=\))|(?=[;),}\]]|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'
           pop: true
         - include: paren-expression
-        - include: class-or-interface-declaration
+        - include: class-declaration
         - include: type
   null-literal:
-    - match: (?<!\.|\$)\bnull\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))null(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.null.ts
   numeric-literal:
     - match: '\b(?<!\$)0(x|X)[0-9a-fA-F]+\b(?!\$)'
@@ -1123,7 +1236,7 @@ contexts:
           (?:\b[0-9]+(\.)[0-9]+[eE][+-]?[0-9]+\b)| # 1.1E+3
           (?:\b[0-9]+(\.)[eE][+-]?[0-9]+\b)|       # 1.E+3
           (?:\B(\.)[0-9]+[eE][+-]?[0-9]+\b)|       # .1E+3
-          (?:\b[0-9]+[eE][+-]?[0-9]+\b)|            # 1E+3
+          (?:\b[0-9]+[eE][+-]?[0-9]+\b)|           # 1E+3
           (?:\b[0-9]+(\.)[0-9]+\b)|                # 1.1
           (?:\b[0-9]+(\.)\B)|                      # 1.
           (?:\B(\.)[0-9]+\b)|                      # .1
@@ -1138,13 +1251,13 @@ contexts:
         5: meta.delimiter.decimal.period.ts
         6: meta.delimiter.decimal.period.ts
   numericConstant-literal:
-    - match: (?<!\.|\$)\bNaN\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))NaN(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.nan.ts
-    - match: (?<!\.|\$)\bInfinity\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Infinity(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.infinity.ts
   object-binding-element:
     - include: comment
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
+    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
       push:
         - match: '(?=,|\})'
           pop: true
@@ -1155,7 +1268,7 @@ contexts:
     - include: variable-initializer
     - include: punctuation-comma
   object-binding-element-propertyName:
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
+    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
       push:
         - match: (:)
           captures:
@@ -1177,22 +1290,23 @@ contexts:
           pop: true
         - include: object-binding-element
   object-identifiers:
-    - match: '([_$[:alpha:]][_$[:alnum:]]*)(?=\s*\.\s*prototype\b(?!\$))'
+    - match: '([_$[:alpha:]][_$[:alnum:]]*)(?=\s*\??\.\s*prototype\b(?!\$))'
       scope: support.class.ts
     - match: |-
-        (?x)(\.)\s*(?:
+        (?x)(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?:
           ([[:upper:]][_$[:digit:][:upper:]]*) |
           ([_$[:alpha:]][_$[:alnum:]]*)
-        )(?=\s*\.\s*[_$[:alpha:]][_$[:alnum:]]*)
+        )(?=\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)
       captures:
         1: punctuation.accessor.ts
-        2: variable.other.constant.object.property.ts
-        3: variable.other.object.property.ts
+        2: punctuation.accessor.optional.ts
+        3: variable.other.constant.object.property.ts
+        4: variable.other.object.property.ts
     - match: |-
         (?x)(?:
           ([[:upper:]][_$[:digit:][:upper:]]*) |
           ([_$[:alpha:]][_$[:alnum:]]*)
-        )(?=\s*\.\s*[_$[:alpha:]][_$[:alnum:]]*)
+        )(?=\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)
       captures:
         1: variable.other.constant.object.ts
         2: variable.other.object.ts
@@ -1208,7 +1322,7 @@ contexts:
           pop: true
         - include: object-member
   object-literal-method-declaration:
-    - match: '(?<!\.|\$)(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))?\s*[\(\<])'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])'
       captures:
         1: storage.modifier.async.ts
         2: storage.type.property.ts
@@ -1218,77 +1332,98 @@ contexts:
         - match: '(?=\}|;|,)|(?<=\})'
           pop: true
         - include: method-declaration-name
-        - include: comment
-        - include: type-parameters
-        - include: function-parameters
-        - include: return-type
-        - include: object-literal-method-overload-declaration
-        - include: decl-block
-  object-literal-method-overload-declaration:
-    - match: '(?<!\.|\$)(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))?\s*[\(\<])'
-      captures:
-        1: storage.modifier.async.ts
-        2: storage.type.property.ts
-        3: keyword.generator.asterisk.ts
-      push:
-        - match: (?=\(|\<)
-          pop: true
-        - include: method-declaration-name
+        - include: function-body
+        - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])'
+          captures:
+            1: storage.modifier.async.ts
+            2: storage.type.property.ts
+            3: keyword.generator.asterisk.ts
+          push:
+            - match: (?=\(|\<)
+              pop: true
+            - include: method-declaration-name
   object-member:
     - include: comment
     - include: object-literal-method-declaration
-    - match: '(?=(?:(?:\''[^'']*\'')|(?:\"[^"]*\")|(?:\[([^\[\]]|\[[^\[\]]*\])+\]))\s*:)'
+    - match: '(?=\[)'
       push:
-        - meta_scope: meta.object.member.ts
-        - match: '(?=,|\})'
+        - meta_scope: meta.object.member.ts meta.object-literal.key.ts
+        - match: (?=:)
           pop: true
-        - match: '(?=(?:(?:\''[^'']*\'')|(?:\"[^"]*\")|(?:\[([^\[\]]|\[[^\[\]]*\])+\]))\s*:)'
-          push:
-            - meta_scope: meta.object-literal.key.ts
-            - match: ":"
-              captures:
-                0: punctuation.separator.key-value.ts
-              pop: true
-            - include: string
-            - include: array-literal
-        - include: expression
+        - include: array-literal
+    - match: '(?=[\''\"])'
+      push:
+        - meta_scope: meta.object.member.ts meta.object-literal.key.ts
+        - match: (?=:)
+          pop: true
+        - include: string
+    - match: '(?![_$[:alpha:]])([[:digit:]]+)\s*(?=:)'
+      scope: meta.object.member.ts
+      captures:
+        0: meta.object-literal.key.ts
+        1: constant.numeric.decimal.ts
     - match: |-
-        (?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\s*(:)(?=\s*(
-        (async\s+)|(function\s*[(<])|(function\s+)|
-        ([_$[:alpha:]][_$[:alnum:]]*\s*=>)|
-        ([(]\s*(([)]\s*:)|([_$[:alpha:]][_$[:alnum:]]*\s*:)|(\.\.\.) )) |
-        ([<]\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s*[^=>])|(\s*[,]))) |
-        ((<([^<>]|\<[^<>]+\>)+>\s*)?\(([^()]|\([^()]*\))*\)(\s*:\s*(.)*)?\s*=>))))
+        (?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:\s*(
+          ((async\s+)?(
+            (function\s*[(<*]) |
+            (function\s+) |
+            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
+          )) |
+          ((async\s*)?(
+            # sure shot arrow functions even if => is on new line
+        (
+          [(]\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*[^()]*)?\))*)?\)                          # parameteres
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+          \s*=>                                                                         # arrow operator
+        )
+          ))
+        )))
+      scope: meta.object.member.ts
       captures:
         0: meta.object-literal.key.ts
         1: entity.name.function.ts
-        2: punctuation.separator.key-value.ts
+    - match: '(?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=:)'
+      scope: meta.object.member.ts
+      captures:
+        0: meta.object-literal.key.ts
+    - match: \.\.\.
+      captures:
+        0: keyword.operator.spread.ts
       push:
         - meta_scope: meta.object.member.ts
         - match: '(?=,|\})'
           pop: true
         - include: expression
-    - match: '(?:[_$[:alpha:]][_$[:alnum:]]*)\s*(:)'
+    - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$)'
+      scope: meta.object.member.ts
       captures:
-        0: meta.object-literal.key.ts
-        1: punctuation.separator.key-value.ts
+        1: variable.other.readwrite.ts
+    - match: '(?=[_$[:alpha:]][_$[:alnum:]]*\s*=)'
       push:
         - meta_scope: meta.object.member.ts
-        - match: '(?=,|\})'
+        - match: '(?=,|\}|$)'
           pop: true
         - include: expression
-    - match: \.\.\.
+    - match: ":"
       captures:
-        0: keyword.operator.spread.ts
+        0: meta.object-literal.key.ts punctuation.separator.key-value.ts
       push:
         - meta_scope: meta.object.member.ts
         - match: '(?=,|\})'
           pop: true
         - include: expression
-    - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$)'
-      scope: meta.object.member.ts
-      captures:
-        1: variable.other.readwrite.ts
     - include: punctuation-comma
   parameter-array-binding-pattern:
     - match: '(?:(\.\.\.)\s*)?(\[)'
@@ -1313,42 +1448,63 @@ contexts:
       captures:
         1: storage.modifier.ts
     - match: |-
-        (?x)(?:\s*\b(public|private|protected|readonly)\s+)?(\.\.\.)?\s*(?<!=|:)([_$[:alpha:]][_$[:alnum:]]*)\s*(\??)(?=\s*
-          (=\s*(
-            (async\s+) |
-            (function\s*[(<]) |
+        (?x)(?:\s*\b(public|private|protected|readonly)\s+)?(\.\.\.)?\s*(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*
+        # function assignment |
+        (=\s*(
+          ((async\s+)?(
+            (function\s*[(<*]) |
             (function\s+) |
-            ([_$[:alpha:]][_$[:alnum:]]*\s*=>) |
-            ([(]\s*(([)]\s*:)|([_$[:alpha:]][_$[:alnum:]]*\s*:)|(\.\.\.) )) |
-            ([<]\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s*[^=>])|(\s*[,]))) |
-            ((<([^<>]|\<[^<>]+\>)+>\s*)?\(([^()]|\([^()]*\))*\)(\s*:\s*(.)*)?\s*=>))
-          ) |
-          (:\s*(
-            (<) |
-            ([(]\s*(
-              ([)]) |
-              (\.\.\.) |
-              ([_$[:alnum:]]+\s*(
-                ([:,?=])|
-                ([)]\s*=>)
-              ))
-            )))
+            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
+          )) |
+          ((async\s*)?(
+            # sure shot arrow functions even if => is on new line
+        (
+          [(]\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*[^()]*)?\))*)?\)                          # parameteres
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+          \s*=>                                                                         # arrow operator
         )
+          ))
+        )) |
+        # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
+        (:\s*(
+          (<) |
+          ([(]\s*(
+            ([)]) |
+            (\.\.\.) |
+            ([_$[:alnum:]]+\s*(
+              ([:,?=])|
+              ([)]\s*=>)
+            ))
+          ))
+        )))
       captures:
         1: storage.modifier.ts
         2: keyword.operator.rest.ts
-        3: entity.name.function.ts
-        4: keyword.operator.optional.ts
-    - match: '(?:\s*\b(public|private|protected|readonly)\s+)?(\.\.\.)?\s*(?<!=|:)([_$[:alpha:]][_$[:alnum:]]*)\s*(\??)'
+        3: entity.name.function.ts variable.language.this.ts
+        4: entity.name.function.ts
+        5: keyword.operator.optional.ts
+    - match: '(?x)(?:\s*\b(public|private|protected|readonly)\s+)?(\.\.\.)?\s*(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)'
       captures:
         1: storage.modifier.ts
         2: keyword.operator.rest.ts
-        3: variable.parameter.ts
-        4: keyword.operator.optional.ts
+        3: variable.parameter.ts variable.language.this.ts
+        4: variable.parameter.ts
+        5: keyword.operator.optional.ts
   parameter-object-binding-element:
     - include: comment
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
+    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
       push:
         - match: '(?=,|\})'
           pop: true
@@ -1381,11 +1537,13 @@ contexts:
         - include: expression
         - include: punctuation-comma
   property-accessor:
-    - match: (?<!\.|\$)\b(get|set)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(get|set)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: storage.type.property.ts
   punctuation-accessor:
-    - match: \.
-      scope: punctuation.accessor.ts
+    - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))'
+      captures:
+        1: punctuation.accessor.ts
+        2: punctuation.accessor.optional.ts
   punctuation-comma:
     - match: ","
       scope: punctuation.separator.comma.ts
@@ -1417,7 +1575,7 @@ contexts:
           pop: true
         - include: string-character-escape
   regex:
-    - match: '(?<=[=(:,\[?+!]|return|case|=>|&&|\|\||\*\/)\s*(/)(?![/*])(?=(?:[^/\\\[]|\\.|\[([^\]\\]|\\.)+\])+/(?![/*])[gimy]*(?!\s*[a-zA-Z0-9_$]))'
+    - match: '(?<=[=(:,\[?+!]|return|case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/(?![\/*])[gimuy]*(?!\s*[a-zA-Z0-9_$]))'
       captures:
         1: punctuation.definition.string.begin.ts
       push:
@@ -1428,7 +1586,7 @@ contexts:
             2: keyword.other.ts
           pop: true
         - include: regexp
-    - match: '(?<![_$[:alnum:]])/(?![/*])(?=(?:[^/\\\[]|\\.|\[([^\]\\]|\\.)+\])+/(?![/*])[gimy]*(?!\s*[a-zA-Z0-9_$]))'
+    - match: '(?<![_$[:alnum:])])\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/(?![\/*])[gimuy]*(?!\s*[a-zA-Z0-9_$]))'
       captures:
         0: punctuation.definition.string.begin.ts
       push:
@@ -1442,7 +1600,7 @@ contexts:
   regex-character-class:
     - match: '\\[wWsSdDtrnvf]|\.'
       scope: constant.other.character-class.regexp
-    - match: '\\([0-7]{3}|x\h\h|u\h\h\h\h)'
+    - match: '\\([0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4})'
       scope: constant.character.numeric.regexp
     - match: '\\c[A-Z]'
       scope: constant.character.control.regexp
@@ -1473,7 +1631,7 @@ contexts:
     - match: \((\?:)?
       captures:
         0: punctuation.definition.group.regexp
-        1: punctuation.definition.group.capture.regexp
+        1: punctuation.definition.group.no-capture.regexp
       push:
         - meta_scope: meta.group.regexp
         - match: \)
@@ -1491,7 +1649,7 @@ contexts:
           captures:
             1: punctuation.definition.character-class.regexp
           pop: true
-        - match: '(?:.|(\\(?:[0-7]{3}|x\h\h|u\h\h\h\h))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x\h\h|u\h\h\h\h))|(\\c[A-Z])|(\\.))'
+        - match: '(?:.|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))'
           scope: constant.other.character-class.range.regexp
           captures:
             1: constant.character.numeric.regexp
@@ -1503,64 +1661,67 @@ contexts:
         - include: regex-character-class
     - include: regex-character-class
   return-type:
+    - match: (?<=\))\s*(:)(?=\s*\S)
+      captures:
+        1: keyword.operator.type.annotation.ts
+      push:
+        - meta_scope: meta.return.type.ts
+        - match: "(?<![:|&])(?=$|^|[{};,]|//)"
+          pop: true
+        - include: return-type-core
     - match: (?<=\))\s*(:)
       captures:
         1: keyword.operator.type.annotation.ts
       push:
         - meta_scope: meta.return.type.ts
-        - match: "(?<!:)((?=$)|(?=[{};,]|//))"
+        - match: '(?<![:|&])((?=[{};,]|//|^\s*$)|((?<=\S)(?=\s*$)))'
           pop: true
-        - include: comment
-        - match: '(?<=:)\s*(\{)'
-          captures:
-            1: punctuation.definition.block.ts
-          push:
-            - meta_scope: meta.object.type.ts
-            - match: '\}'
-              captures:
-                0: punctuation.definition.block.ts
-              pop: true
-            - include: type-object-members
-        - include: type-predicate-operator
-        - include: type
+        - include: return-type-core
+  return-type-core:
+    - include: comment
+    - match: '(?<=[:|&])(?=\s*\{)'
+      push:
+        - match: '(?<=\})'
+          pop: true
+        - include: type-object
+    - include: type-predicate-operator
+    - include: type
   statements:
     - include: string
     - include: template
     - include: comment
     - include: declaration
-    - include: switch-statement
-    - include: for-loop
-    - include: after-operator-block
-    - include: decl-block
     - include: control-statement
+    - include: after-operator-block-as-object-literal
+    - include: decl-block
     - include: expression
     - include: punctuation-semicolon
   string:
     - include: qstring-single
     - include: qstring-double
   string-character-escape:
-    - match: '\\(x\h{2}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)'
+    - match: '\\(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)'
       scope: constant.character.escape.ts
   super-literal:
-    - match: (?<!\.|\$)\bsuper\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))super\b(?!\$)'
       scope: variable.language.super.ts
   support-objects:
-    - match: (?<!\.|\$)\b(arguments)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(arguments)\b(?!\$)'
       scope: variable.language.arguments.ts
     - match: |-
-        (?x)(?<!\.|\$)\b(Array|ArrayBuffer|Atomics|Boolean|DataView|Date|Float32Array|Float64Array|Function|Generator
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Array|ArrayBuffer|Atomics|Boolean|DataView|Date|Float32Array|Float64Array|Function|Generator
         |GeneratorFunction|Int8Array|Int16Array|Int32Array|Intl|Map|Number|Object|Promise|Proxy
         |Reflect|RegExp|Set|SharedArrayBuffer|SIMD|String|Symbol|TypedArray
         |Uint8Array|Uint16Array|Uint32Array|Uint8ClampedArray|WeakMap|WeakSet)\b(?!\$)
       scope: support.class.builtin.ts
-    - match: (?<!\.|\$)\b((Eval|Internal|Range|Reference|Syntax|Type|URI)?Error)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))((Eval|Internal|Range|Reference|Syntax|Type|URI)?Error)\b(?!\$)'
       scope: support.class.error.ts
     - match: |-
-        (?x)(?<!\.|\$)\b(clear(Interval|Timeout)|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(clear(Interval|Timeout)|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|
         isFinite|isNaN|parseFloat|parseInt|require|set(Interval|Timeout)|super|unescape|uneval)(?=\s*\()
       scope: support.function.ts
     - match: |-
-        (?x)(?<!\.|\$)\b(Math)(?:\s*(\.)\s*(?:
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Math)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?:
         (abs|acos|acosh|asin|asinh|atan|atan2|atanh|cbrt|ceil|clz32|cos|cosh|exp|
         expm1|floor|fround|hypot|imul|log|log10|log1p|log2|max|min|pow|random|
         round|sign|sin|sinh|sqrt|tan|tanh|trunc)
@@ -1569,32 +1730,36 @@ contexts:
       captures:
         1: support.constant.math.ts
         2: punctuation.accessor.ts
-        3: support.function.math.ts
-        4: support.constant.property.math.ts
+        3: punctuation.accessor.optional.ts
+        4: support.function.math.ts
+        5: support.constant.property.math.ts
     - match: |-
-        (?x)(?<!\.|\$)\b(console)(?:\s*(\.)\s*(
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(console)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(
         assert|clear|count|debug|dir|error|group|groupCollapsed|groupEnd|info|log
         |profile|profileEnd|table|time|timeEnd|timeStamp|trace|warn))?\b(?!\$)
       captures:
         1: support.class.console.ts
         2: punctuation.accessor.ts
-        3: support.function.console.ts
-    - match: (?<!\.|\$)\b(JSON)(?:\s*(\.)\s*(parse|stringify))?\b(?!\$)
+        3: punctuation.accessor.optional.ts
+        4: support.function.console.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(JSON)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(parse|stringify))?\b(?!\$)'
       captures:
         1: support.constant.json.ts
         2: punctuation.accessor.ts
-        3: support.function.json.ts
+        3: punctuation.accessor.optional.ts
+        4: support.function.json.ts
     - match: |-
-        (?x) (\.) \s* (?:
+        (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:
         (constructor|length|prototype|__proto__)
         |
         (EPSILON|MAX_SAFE_INTEGER|MAX_VALUE|MIN_SAFE_INTEGER|MIN_VALUE|NEGATIVE_INFINITY|POSITIVE_INFINITY))\b(?!\$)
       captures:
         1: punctuation.accessor.ts
-        2: support.variable.property.ts
-        3: support.constant.ts
+        2: punctuation.accessor.optional.ts
+        3: support.variable.property.ts
+        4: support.constant.ts
     - match: |-
-        (?x) (?<!\.|\$) \b (?:
+        (?x) (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.)) \b (?:
         (document|event|navigator|performance|screen|window)
         |
         (AnalyserNode|ArrayBufferView|Attr|AudioBuffer|AudioBufferSourceNode|AudioContext|AudioDestinationNode|AudioListener
@@ -1660,7 +1825,7 @@ contexts:
         1: support.variable.dom.ts
         2: support.class.dom.ts
     - match: |-
-        (?x) (\.) \s* (?:
+        (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:
         (ATTRIBUTE_NODE|CDATA_SECTION_NODE|COMMENT_NODE|DOCUMENT_FRAGMENT_NODE|DOCUMENT_NODE|DOCUMENT_TYPE_NODE
         |DOMSTRING_SIZE_ERR|ELEMENT_NODE|ENTITY_NODE|ENTITY_REFERENCE_NODE|HIERARCHY_REQUEST_ERR|INDEX_SIZE_ERR
         |INUSE_ATTRIBUTE_ERR|INVALID_CHARACTER_ERR|NO_DATA_ALLOWED_ERR|NO_MODIFICATION_ALLOWED_ERR|NOT_FOUND_ERR
@@ -1691,17 +1856,18 @@ contexts:
         |siblingBelow|size|source|specified|standby|start|status|statusbar|statusText|style|styleSheets|suffixes|summary
         |systemId|systemLanguage|tagName|tags|target|tBodies|text|textAlign|textDecoration|textIndent|textTransform|tFoot|tHead
         |title|toolbar|top|type|undefined|uniqueID|updateInterval|URL|URLUnencoded|useMap|userAgent|userLanguage|userProfile
-        |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<([^<>]|\<[^<>]+\>)+>\s*)?\()
+        |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))([^=<>]|=[^<])*\>)*>\s*)?\()
       captures:
         1: punctuation.accessor.ts
-        2: support.constant.dom.ts
-        3: support.variable.property.dom.ts
+        2: punctuation.accessor.optional.ts
+        3: support.constant.dom.ts
+        4: support.variable.property.dom.ts
     - match: |-
-        (?x)(?<!\.|\$)\b(Buffer|EventEmitter|Server|Pipe|Socket|REPLServer|ReadStream|WriteStream|Stream
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Buffer|EventEmitter|Server|Pipe|Socket|REPLServer|ReadStream|WriteStream|Stream
         |Inflate|Deflate|InflateRaw|DeflateRaw|GZip|GUnzip|Unzip|Zip)\b(?!\$)
       scope: support.class.node.ts
     - match: |-
-        (?x)(?<!\.|\$)\b(process)(?:(\.)(?:
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(process)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?:
           (arch|argv|config|connected|env|execArgv|execPath|exitCode|mainModule|pid|platform|release|stderr|stdin|stdout|title|version|versions)
           |
           (abort|chdir|cwd|disconnect|exit|[sg]ete?[gu]id|send|[sg]etgroups|initgroups|kill|memoryUsage|nextTick|umask|uptime|hrtime)
@@ -1709,18 +1875,20 @@ contexts:
       captures:
         1: support.variable.object.process.ts
         2: punctuation.accessor.ts
-        3: support.variable.property.process.ts
-        4: support.function.process.ts
-    - match: (?<!\.|\$)\b(?:(exports)|(module)(?:(\.)(exports|id|filename|loaded|parent|children))?)\b(?!\$)
+        3: punctuation.accessor.optional.ts
+        4: support.variable.property.process.ts
+        5: support.function.process.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(exports)|(module)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(exports|id|filename|loaded|parent|children))?)\b(?!\$)'
       captures:
         1: support.type.object.module.ts
         2: support.type.object.module.ts
         3: punctuation.accessor.ts
-        4: support.type.object.module.ts
-    - match: (?<!\.|\$)\b(global|GLOBAL|root|__dirname|__filename)\b(?!\$)
+        4: punctuation.accessor.optional.ts
+        5: support.type.object.module.ts
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(global|GLOBAL|root|__dirname|__filename)\b(?!\$)'
       scope: support.variable.object.node.ts
     - match: |-
-        (?x) (\.) \s*
+        (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s*
         (?:
          (on(?:Rowsinserted|Rowsdelete|Rowenter|Rowexit|Resize|Resizestart|Resizeend|Reset|
            Readystatechange|Mouseout|Mouseover|Mousedown|Mouseup|Mousemove|
@@ -1797,41 +1965,47 @@ contexts:
         )(?=\s*\()
       captures:
         1: punctuation.accessor.ts
-        2: support.function.event-handler.ts
-        3: support.function.ts
-        4: support.function.dom.ts
-  switch-block:
-    - match: '\{'
-      captures:
-        0: punctuation.definition.block.ts
-      push:
-        - meta_scope: switch-block.expr.ts
-        - match: '(?=\})'
-          pop: true
-        - include: case-clause
-        - include: statements
-  switch-expression:
-    - match: (?<!\.|\$)\b(switch)\s*(\()
-      captures:
-        1: keyword.control.switch.ts
-        2: meta.brace.round.ts
-      push:
-        - meta_scope: switch-expression.expr.ts
-        - match: \)
-          captures:
-            0: meta.brace.round.ts
-          pop: true
-        - include: expression
+        2: punctuation.accessor.optional.ts
+        3: support.function.event-handler.ts
+        4: support.function.ts
+        5: support.function.dom.ts
   switch-statement:
-    - match: (?<!\.|\$)(?=\bswitch\s*\()
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bswitch\s*\()'
       push:
         - meta_scope: switch-statement.expr.ts
         - match: '\}'
           captures:
             0: punctuation.definition.block.ts
           pop: true
-        - include: switch-expression
-        - include: switch-block
+        - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(switch)\s*(\()'
+          captures:
+            1: keyword.control.switch.ts
+            2: meta.brace.round.ts
+          push:
+            - meta_scope: switch-expression.expr.ts
+            - match: \)
+              captures:
+                0: meta.brace.round.ts
+              pop: true
+            - include: expression
+        - match: '\{'
+          captures:
+            0: punctuation.definition.block.ts
+          push:
+            - meta_scope: switch-block.expr.ts
+            - match: '(?=\})'
+              pop: true
+            - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default(?=:))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+              captures:
+                1: keyword.control.switch.ts
+              push:
+                - meta_scope: case-clause.expr.ts
+                - match: ":"
+                  captures:
+                    0: punctuation.definition.section.case-statement.ts
+                  pop: true
+                - include: expression
+            - include: statements
   template:
     - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"
       captures:
@@ -1851,15 +2025,16 @@ contexts:
         0: punctuation.definition.template-expression.begin.ts
       push:
         - meta_scope: meta.template.expression.ts
+        - meta_content_scope: meta.embedded.line.ts
         - match: '\}'
           captures:
             0: punctuation.definition.template-expression.end.ts
           pop: true
         - include: expression
   ternary-expression:
-    - match: (\?)
+    - match: '(?!\?\.\s*[^[:digit:]])(\?)'
       captures:
-        0: keyword.operator.ternary.ts
+        1: keyword.operator.ternary.ts
       push:
         - match: (:)
           captures:
@@ -1867,7 +2042,7 @@ contexts:
           pop: true
         - include: expression
   this-literal:
-    - match: (?<!\.|\$)\bthis\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))this\b(?!\$)'
       scope: variable.language.this.ts
   type:
     - include: comment
@@ -1883,28 +2058,15 @@ contexts:
     - include: type-paren-or-function-parameters
     - include: type-function-return-type
     - include: type-name
-  type-annotation:
-    - match: ":"
-      captures:
-        0: keyword.operator.type.annotation.ts
-      push:
-        - meta_scope: meta.type.annotation.ts
-        - match: '(?=$|[,);\}\]]|//)|(?==[^>])|(?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)'
-          pop: true
-        - include: comment
-        - include: type
-  type-builtin-literals:
-    - match: (?<!\.|\$)\b(this|true|false|undefined|null|object)\b(?!\$)
-      scope: support.type.builtin.ts
-  type-declaration:
-    - match: '(?<!\.|\$)(?:(\bexport)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s*'
+  type-alias-declaration:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s*'
       captures:
         1: keyword.control.export.ts
         2: storage.type.type.ts
-        3: entity.name.type.ts
+        3: entity.name.type.alias.ts
       push:
         - meta_scope: meta.type.declaration.ts
-        - match: '(?=[};]|\bvar\b|\blet\b|\bconst\b|\btype\b|\bfunction\b|\bclass\b|\binterface\b|\bnamespace\b|\bmodule\b|\bimport\b|\benum\b|\bdeclare\b|\bexport\b|\babstract\b|\basync\b)'
+        - match: '(?=[};]|\babstract\b|\basync\b|\bclass\b|\bconst\b|\bdeclare\b|\benum\b|\bexport\b|\bfunction\b|\bimport\b|\binterface\b|\blet\b|\bmodule\b|\bnamespace\b|\btype\b|\bvar\b)'
           pop: true
         - include: comment
         - include: type-parameters
@@ -1912,12 +2074,32 @@ contexts:
         - match: (=)\s*
           captures:
             1: keyword.operator.assignment.ts
+  type-annotation:
+    - match: (:)(?=\s*\S)
+      captures:
+        1: keyword.operator.type.annotation.ts
+      push:
+        - meta_scope: meta.type.annotation.ts
+        - match: '(?<![:|&])((?=$|^|[,);\}\]]|//)|(?==[^>])|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))'
+          pop: true
+        - include: type
+    - match: (:)
+      captures:
+        1: keyword.operator.type.annotation.ts
+      push:
+        - meta_scope: meta.type.annotation.ts
+        - match: '(?<![:|&])((?=[,);\}\]]|//)|(?==[^>])|(?=^\s*$)|((?<=\S)(?=\s*$))|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))'
+          pop: true
+        - include: type
+  type-builtin-literals:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(this|true|false|undefined|null|object)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: support.type.builtin.ts
   type-fn-type-parameters:
-    - match: (?<!\.|\$)\b(new)\b(?=\s*\<)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b(?=\s*\<)'
       scope: meta.type.constructor.ts
       captures:
         1: keyword.control.new.ts
-    - match: (?<!\.|\$)\b(new)\b\s*(?=\()
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b\s*(?=\()'
       captures:
         1: keyword.control.new.ts
       push:
@@ -1944,31 +2126,37 @@ contexts:
           pop: true
         - include: function-parameters
   type-function-return-type:
+    - match: (=>)(?=\s*\S)
+      captures:
+        1: storage.type.function.arrow.ts
+      push:
+        - meta_scope: meta.type.function.return.ts
+        - match: '(?<!=>)(?<![|&])(?=[,\]\)\{\}=;>]|//|$)'
+          pop: true
+        - include: type-function-return-type-core
     - match: "=>"
       captures:
         0: storage.type.function.arrow.ts
       push:
         - meta_scope: meta.type.function.return.ts
-        - match: '(?<!=>)(?=[,\]\)\{\}=;>]|//|$)'
+        - match: '(?<!=>)(?<![|&])((?=[,\]\)\{\}=;>]|//|^\s*$)|((?<=\S)(?=\s*$)))'
           pop: true
-        - include: comment
-        - match: '(?<==>)\s*(\{)'
-          captures:
-            1: punctuation.definition.block.ts
-          push:
-            - meta_scope: meta.object.type.ts
-            - match: '\}'
-              captures:
-                0: punctuation.definition.block.ts
-              pop: true
-            - include: type-object-members
-        - include: type-predicate-operator
-        - include: type
+        - include: type-function-return-type-core
+  type-function-return-type-core:
+    - include: comment
+    - match: '(?<==>)(?=\s*\{)'
+      push:
+        - match: '(?<=\})'
+          pop: true
+        - include: type-object
+    - include: type-predicate-operator
+    - include: type
   type-name:
-    - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(\.)'
+    - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))'
       captures:
         1: entity.name.type.module.ts
         2: punctuation.accessor.ts
+        3: punctuation.accessor.optional.ts
     - match: "[_$[:alpha:]][_$[:alnum:]]*"
       scope: entity.name.type.ts
   type-object:
@@ -1981,29 +2169,38 @@ contexts:
           captures:
             0: punctuation.definition.block.ts
           pop: true
-        - include: type-object-members
-  type-object-members:
-    - include: comment
-    - include: method-declaration
-    - include: indexer-declaration
-    - include: indexer-mapped-type-declaration
-    - include: field-declaration
-    - include: type-annotation
-    - match: \.\.\.
-      captures:
-        0: keyword.operator.spread.ts
-      push:
-        - match: '(?=\}|;|,|$)|(?<=\})'
-          pop: true
+        - include: comment
+        - include: method-declaration
+        - include: indexer-declaration
+        - include: indexer-mapped-type-declaration
+        - include: field-declaration
+        - include: type-annotation
+        - match: \.\.\.
+          captures:
+            0: keyword.operator.spread.ts
+          push:
+            - match: '(?=\}|;|,|$)|(?<=\})'
+              pop: true
+            - include: type
+        - include: punctuation-comma
+        - include: punctuation-semicolon
         - include: type
-    - include: punctuation-comma
-    - include: punctuation-semicolon
-    - include: type
   type-operators:
     - include: typeof-operator
+    - match: '([&|])(?=\s*\{)'
+      captures:
+        0: keyword.operator.type.ts
+      push:
+        - match: '(?<=\})'
+          pop: true
+        - include: type-object
     - match: "[&|]"
-      scope: keyword.operator.type.ts
-    - match: (?<!\.|\$)\bkeyof\b(?!\$)
+      captures:
+        0: keyword.operator.type.ts
+      push:
+        - match: (?=\S)
+          pop: true
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))keyof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.keyof.ts
   type-parameters:
     - match: (<)
@@ -2011,12 +2208,12 @@ contexts:
         1: punctuation.definition.typeparameters.begin.ts
       push:
         - meta_scope: meta.type.parameters.ts
-        - match: (?=$)|(>)
+        - match: (>)
           captures:
             1: punctuation.definition.typeparameters.end.ts
           pop: true
         - include: comment
-        - match: (?<!\.|\$)\b(extends)\b(?!\$)
+        - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(extends)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
           scope: storage.modifier.ts
         - match: \=(?!>)
           scope: keyword.operator.assignment.ts
@@ -2035,10 +2232,10 @@ contexts:
         - include: type
         - include: function-parameters
   type-predicate-operator:
-    - match: (?<!\.|\$)\bis\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))is(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.is.ts
   type-primitive:
-    - match: (?<!\.|\$)\b(string|number|boolean|symbol|any|void|never)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(string|number|boolean|symbol|any|void|never)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: support.type.primitive.ts
   type-tuple:
     - match: '\['
@@ -2053,54 +2250,83 @@ contexts:
         - include: type
         - include: punctuation-comma
   typeof-operator:
-    - match: (?<!\.|\$)\btypeof\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))typeof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.typeof.ts
   undefined-literal:
-    - match: (?<!\.|\$)\bundefined\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))undefined(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.undefined.ts
   var-expr:
-    - match: (?<!\.|\$)(?:(\bexport)\s+)?\b(var|let|const(?!\s+enum\b))\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(var|let|const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       captures:
         1: keyword.control.export.ts
         2: storage.type.ts
       push:
         - meta_scope: meta.var.expr.ts
-        - match: '(?=$|;|}|(\s+(of|in)\s+))'
+        - match: '(?=$|^|;|}|(\s+(of|in)\s+))'
           pop: true
         - include: destructuring-variable
         - include: var-single-variable
         - include: variable-initializer
         - include: comment
+        - match: (,)\s*(?!\S)
+          captures:
+            1: punctuation.separator.comma.ts
+          push:
+            - match: '(?<!,)((?==|;|}|(\s+(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$))'
+              pop: true
+            - include: comment
+            - include: destructuring-variable
+            - include: var-single-variable
+            - include: punctuation-comma
         - include: punctuation-comma
   var-single-variable:
     - match: |-
         (?x)([_$[:alpha:]][_$[:alnum:]]*)(?=\s*
-          (=\s*(
-            (async\s+) |
-            (function\s*[(<]) |
+        # function assignment |
+        (=\s*(
+          ((async\s+)?(
+            (function\s*[(<*]) |
             (function\s+) |
-            ([_$[:alpha:]][_$[:alnum:]]*\s*=>) |
-            ([(]\s*(([)]\s*:)|([_$[:alpha:]][_$[:alnum:]]*\s*:)|(\.\.\.) )) |
-            ([<]\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s*[^=>])|(\s*[,]))) |
-            ((<([^<>]|\<[^<>]+\>)+>\s*)?\(([^()]|\([^()]*\))*\)(\s*:\s*(.)*)?\s*=>))
-          ) |
-          (:\s*(
-            (<) |
-            ([(]\s*(
-              ([)]) |
-              (\.\.\.) |
-              ([_$[:alnum:]]+\s*(
-                ([:,?=])|
-                ([)]\s*=>)
-              ))
-            )))
+            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
+          )) |
+          ((async\s*)?(
+            # sure shot arrow functions even if => is on new line
+        (
+          [(]\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*[^()]*)?\))*)?\)                          # parameteres
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+          \s*=>                                                                         # arrow operator
         )
+          ))
+        )) |
+        # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
+        (:\s*(
+          (<) |
+          ([(]\s*(
+            ([)]) |
+            (\.\.\.) |
+            ([_$[:alnum:]]+\s*(
+              ([:,?=])|
+              ([)]\s*=>)
+            ))
+          ))
+        )))
       captures:
         1: meta.definition.variable.ts entity.name.function.ts
       push:
         - meta_scope: meta.var-single-variable.expr.ts
-        - match: '(?=$|[;,=}]|(\s+(of|in)\s+))'
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
           pop: true
         - include: var-single-variable-type-annotation
     - match: "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])"
@@ -2108,7 +2334,7 @@ contexts:
         1: meta.definition.variable.ts variable.other.constant.ts
       push:
         - meta_scope: meta.var-single-variable.expr.ts
-        - match: '(?=$|[;,=}]|(\s+(of|in)\s+))'
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
           pop: true
         - include: var-single-variable-type-annotation
     - match: "([_$[:alpha:]][_$[:alnum:]]*)"
@@ -2116,7 +2342,7 @@ contexts:
         1: meta.definition.variable.ts variable.other.readwrite.ts
       push:
         - meta_scope: meta.var-single-variable.expr.ts
-        - match: '(?=$|[;,=}]|(\s+(of|in)\s+))'
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
           pop: true
         - include: var-single-variable-type-annotation
   var-single-variable-type-annotation:
@@ -2128,13 +2354,13 @@ contexts:
       captures:
         1: keyword.operator.assignment.ts
       push:
-        - match: '(?=$|[,);}\]])'
+        - match: '(?=$|^|[,);}\]])'
           pop: true
         - include: expression
     - match: (?<!=|!)(=)(?!=)
       captures:
         1: keyword.operator.assignment.ts
       push:
-        - match: '(?=[,);}\]])|(?=^\s*$)'
+        - match: '(?=[,);}\]])|(?=^\s*$)|(?<=\S)(?<!=)(?=\s*$)'
           pop: true
         - include: expression
diff --git a/sublime_syntaxes/TypeScriptReact.sublime-syntax b/sublime_syntaxes/TypeScriptReact.sublime-syntax
index e3366b4..3a33ed7 100644
--- a/sublime_syntaxes/TypeScriptReact.sublime-syntax
+++ b/sublime_syntaxes/TypeScriptReact.sublime-syntax
@@ -24,32 +24,32 @@ contexts:
             0: punctuation.definition.comment.tsx
           pop: true
         - include: docblock
-    - match: /\*
+    - match: (/\*)(?:\s*((@)internal)(?=\s|(\*/)))?
       captures:
-        0: punctuation.definition.comment.tsx
+        1: punctuation.definition.comment.tsx
+        2: storage.type.internaldeclaration.tsx
+        3: punctuation.decorator.internaldeclaration.tsx
       push:
         - meta_scope: comment.block.tsx
         - match: \*/
           captures:
             0: punctuation.definition.comment.tsx
           pop: true
-    - match: '(^[ \t]+)?(?=//)'
+    - match: '(^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?)'
       captures:
         1: punctuation.whitespace.comment.leading.tsx
+        2: comment.line.double-slash.tsx
+        3: punctuation.definition.comment.tsx
+        4: storage.type.internaldeclaration.tsx
+        5: punctuation.decorator.internaldeclaration.tsx
       push:
-        - match: (?=$)
+        - meta_content_scope: comment.line.double-slash.tsx
+        - match: (?=^)
           pop: true
-        - match: //
-          captures:
-            0: punctuation.definition.comment.tsx
-          push:
-            - meta_scope: comment.line.double-slash.tsx
-            - match: (?=$)
-              pop: true
   access-modifier:
-    - match: (?<!\.|\$)\b(abstract|public|protected|private|readonly|static)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(abstract|public|protected|private|readonly|static)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: storage.modifier.tsx
-  after-operator-block:
+  after-operator-block-as-object-literal:
     - match: '(?<=[=(,\[?+!]|await|return|yield|throw|in|of|typeof|&&|\|\||\*)\s*(\{)'
       captures:
         1: punctuation.definition.block.tsx
@@ -85,42 +85,41 @@ contexts:
         - include: expression
         - include: punctuation-comma
   arrow-function:
-    - match: '(?:(?<!\.|\$)(\basync)\s*)?([_$[:alpha:]][_$[:alnum:]]*)\s*(?==>)'
+    - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)\s+)?([_$[:alpha:]][_$[:alnum:]]*)\s*(?==>)'
       scope: meta.arrow.tsx
       captures:
         1: storage.modifier.async.tsx
         2: variable.parameter.tsx
     - match: |-
         (?x) (?:
-          (?<!\.|\$)(\basync)(?=\s*[<(])
-        ) | ((?<![})\]])\s*
+          (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)
+        )? ((?<![})!\]])\s*
           (?=
             # sure shot arrow functions even if => is on new line
-            (
-              [(]\s*
-              (
-                ([)]\s*:) |                               # ():
-                ([_$[:alpha:]][_$[:alnum:]]*\s*:) |       # [(]param:
-                (\.\.\.)                                  # [(]...
-              )
-            ) |
-            (
-              [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
-            ) |
-            # arrow function possible to detect only with => on same line
-            (
-              (<([^<>]|\<[^<>]+\>)+>\s*)?                 # typeparameters
-              \(([^()]|\([^()]*\))*\)                     # parameteres
-              (\s*:\s*(.)*)?                              # return type
-              \s*=>                                       # arrow operator
-            )
+        (
+          [(]\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*[^()]*)?\))*)?\)                          # parameteres
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+          \s*=>                                                                         # arrow operator
+        )
           )
         )
       captures:
         1: storage.modifier.async.tsx
       push:
         - meta_scope: meta.arrow.tsx
-        - match: '(?==>|\{)'
+        - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'
           pop: true
         - include: comment
         - include: type-parameters
@@ -131,7 +130,7 @@ contexts:
         0: storage.type.function.arrow.tsx
       push:
         - meta_scope: meta.arrow.tsx
-        - match: '(?<=\})|((?!\{)(?=\S))'
+        - match: '(?<=\}|\S)(?<!=>)|((?!\{)(?=\S))'
           pop: true
         - include: decl-block
         - include: expression
@@ -141,18 +140,13 @@ contexts:
         1: keyword.operator.type.annotation.tsx
       push:
         - meta_scope: meta.return.type.arrow.tsx
-        - match: '(?==>|\{)'
+        - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'
           pop: true
-        - match: '(?<=:)\s*(\{)'
-          captures:
-            1: punctuation.definition.block.tsx
+        - match: '(?<=[:])(?=\s*\{)'
           push:
-            - meta_scope: meta.object.type.tsx
-            - match: '\}'
-              captures:
-                0: punctuation.definition.block.tsx
+            - match: '(?<=\})'
               pop: true
-            - include: type-object-members
+            - include: type-object
         - include: type-predicate-operator
         - include: type
   binding-element:
@@ -162,23 +156,51 @@ contexts:
     - include: destructuring-variable-rest
     - include: variable-initializer
   boolean-literal:
-    - match: (?<!\.|\$)\btrue\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))true(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.boolean.true.tsx
-    - match: (?<!\.|\$)\bfalse\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))false(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.boolean.false.tsx
-  case-clause:
-    - match: (?<!\.|\$)\b(case|default(?=:))\b(?!\$)
-      captures:
-        1: keyword.control.switch.tsx
+  brackets:
+    - match: "{"
       push:
-        - meta_scope: case-clause.expr.tsx
-        - match: ":"
-          captures:
-            0: punctuation.definition.section.case-statement.tsx
+        - match: '}|(?=\*/)'
           pop: true
-        - include: expression
+        - include: brackets
+    - match: '\['
+      push:
+        - match: '\]|(?=\*/)'
+          pop: true
+        - include: brackets
   cast:
     - include: jsx
+  class-declaration:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?\b(?:(abstract)\s+)?\b(class)\b(?=\s+|/[/*])'
+      captures:
+        1: keyword.control.export.tsx
+        2: storage.modifier.tsx
+        3: storage.type.class.tsx
+      push:
+        - meta_scope: meta.class.tsx
+        - 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.tsx
+    - include: type-parameters
+    - include: class-or-interface-body
+  class-expression:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(class)\b(?=\s+|[<{]|/[/*])'
+      captures:
+        1: storage.type.class.tsx
+      push:
+        - meta_scope: meta.class.tsx
+        - match: '(?<=\})'
+          pop: true
+        - include: class-declaration-or-expression-patterns
   class-or-interface-body:
     - match: '\{'
       captures:
@@ -198,67 +220,49 @@ contexts:
         - include: variable-initializer
         - include: access-modifier
         - include: property-accessor
-        - include: after-operator-block
+        - include: after-operator-block-as-object-literal
         - include: decl-block
         - include: expression
         - include: punctuation-comma
         - include: punctuation-semicolon
-  class-or-interface-declaration:
-    - match: '(?<!\.|\$)\b(?:(export)\s+)?\b(?:(abstract)\s+)?\b(?:(class)|(interface))\b(?=\s+|/[/*])'
-      captures:
-        1: keyword.control.export.tsx
-        2: storage.modifier.tsx
-        3: storage.type.class.tsx
-        4: storage.type.interface.tsx
-      push:
-        - meta_scope: meta.class.tsx
-        - match: '(?<=\})'
-          captures:
-            1: punctuation.definition.block.tsx
-          pop: true
-        - include: comment
-        - include: class-or-interface-heritage
-        - match: "[_$[:alpha:]][_$[:alnum:]]*"
-          captures:
-            0: entity.name.type.class.tsx
-        - include: type-parameters
-        - include: class-or-interface-body
   class-or-interface-heritage:
-    - match: (?<!\.|\$)(?:\b(extends|implements)\b)(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(extends|implements)\b)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       captures:
         1: storage.modifier.tsx
       push:
         - match: '(?=\{)'
-          captures:
-            1: punctuation.definition.block.tsx
           pop: true
         - include: comment
         - include: class-or-interface-heritage
         - include: type-parameters
-        - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(\.)(?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s*\.\s*[_$[:alpha:]][_$[:alnum:]]*)*\s*([,<{]|extends|implements|//|/\*))'
+        - include: expressionWithoutIdentifiers
+        - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)*\s*)'
           captures:
             1: entity.name.type.module.tsx
             2: punctuation.accessor.tsx
-        - match: '([_$[:alpha:]][_$[:alnum:]]*)(?=\s*([,<{]|extends|implements|//|/\*))'
+            3: punctuation.accessor.optional.tsx
+        - match: "([_$[:alpha:]][_$[:alnum:]]*)"
           captures:
             1: entity.other.inherited-class.tsx
-        - include: expression
+        - include: expressionPunctuations
   control-statement:
-    - match: (?<!\.|\$)\b(catch|finally|throw|try)\b(?!\$)
+    - include: switch-statement
+    - include: for-loop
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(catch|finally|throw|try)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.trycatch.tsx
-    - match: (?<!\.|\$)\b(break|continue|do|goto|while)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|do|goto|while)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.loop.tsx
-    - match: (?<!\.|\$)\b(return)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(return)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.flow.tsx
-    - match: (?<!\.|\$)\b(case|default|switch)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default|switch)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.switch.tsx
-    - match: (?<!\.|\$)\b(else|if)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(else|if)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.conditional.tsx
-    - match: (?<!\.|\$)\b(with)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(with)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.with.tsx
-    - match: (?<!\.|\$)\b(debugger)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(debugger)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.other.debugger.tsx
-    - match: (?<!\.|\$)\b(declare)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(declare)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: storage.modifier.tsx
   decl-block:
     - match: '\{'
@@ -275,15 +279,16 @@ contexts:
     - include: decorator
     - include: var-expr
     - include: function-declaration
-    - include: class-or-interface-declaration
-    - include: type-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: (?<!\.|\$)\@
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))\@'
       captures:
         0: punctuation.decorator.tsx
       push:
@@ -322,7 +327,7 @@ contexts:
     - match: '(?<!=|:|of|in)\s*(?=\{)'
       push:
         - meta_scope: meta.object-binding-pattern-variable.tsx
-        - match: '(?=$|[;,=}]|(\s+(of|in)\s+))'
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
           pop: true
         - include: object-binding-pattern
         - include: type-annotation
@@ -330,7 +335,7 @@ contexts:
     - match: '(?<!=|:|of|in)\s*(?=\[)'
       push:
         - meta_scope: meta.array-binding-pattern-variable.tsx
-        - match: '(?=$|[;,=}]|(\s+(of|in)\s+))'
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
           pop: true
         - include: array-binding-pattern
         - include: type-annotation
@@ -341,12 +346,12 @@ contexts:
         1: keyword.operator.rest.tsx
         2: meta.definition.variable.tsx variable.other.readwrite.tsx
   directives:
-    - match: '^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|name)\s*=\s*((\''[^'']*\'')|(\"[^"]*\")))+\s*/>\s*$)'
+    - match: '^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|name)\s*=\s*((\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")))+\s*/>\s*$)'
       captures:
         1: punctuation.definition.comment.tsx
       push:
         - meta_scope: comment.line.triple-slash.directive.tsx
-        - match: (?=$)
+        - match: (?=^)
           pop: true
         - match: (<)(reference|amd-dependency|amd-module)
           captures:
@@ -365,270 +370,251 @@ contexts:
             - include: string
   docblock:
     - match: |-
-        (?x)(?<!\w)@(
-        abstract|access|alias|arg|argument|async|attribute|augments|author|beta|borrows|bubbes|callback|chainable|class
-        |classdesc|code|config|const|constant|constructor|constructs|copyright|default|defaultvalue|define|deprecated|desc
-        |description|dict|emits|enum|event|example|exports?|extends|extension|extension_for|extensionfor|external|file
-        |fileoverview|final|fires|for|function|global|host|ignore|implements|implicitCast|inherit[Dd]oc|inner|instance
-        |interface|kind|lends|license|listens|main|member|memberof|method|mixex|mixins?|modifies|module|name|namespace
-        |noalias|nocollapse|nocompile|nosideeffects|override|overview|package|param|preserve|private|prop|property
-        |protected|public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary|suppress
-        |template|this|throws|todo|type|typedef|unrestricted|uses|var|variation|version|virtual|writeOnce)\b
-      scope: storage.type.class.jsdoc
+        (?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+
         (
-          \[
-            [^\]]+            # Optional [link text] preceding {@link syntax}
-          \]
-
-          (?!                  # Check to avoid highlighting two sets of link text
-            {
-              @\w+            # Tagname
-              \s+
-              [^\s|}]+        # Namepath/URL
-              [\s|]           # Whitespace or bar delimiting description
-              [^}]*
-            }
-          )
-        )?
-
-        (?:
-          {
-            (
-              @
-              (?: link         # Name of tag
-                | linkcode
-                | linkplain
-                | tutorial
-              )
-            )
-
-            \s+
-
-            ([^\s|}]+)        # Namepath or URL
-
-            (?:                # Optional link text following link target
-              [\s|]           # Bar or space separating target and text
-              [^}]*            # Actual text
-            )?
-          }
+          [^@\s<>*/]
+          (?:[^@<>*/]|\*[^/])*
         )
-      scope: other.meta.jsdoc
+        (?:
+          \s*
+          (<)
+          ([^>\s]+)
+          (>)
+        )?
       captures:
-        0: entity.name.type.instance.jsdoc
-        1: constant.other.description.jsdoc
-        2: storage.type.class.jsdoc
-        3: variable.other.description.jsdoc
+        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)
-
-        (?:(?<=@param)|(?<=@arg)|(?<=@argument)|(?<=@type)|(?<=@property)|(?<=@prop))
-
+        ((@)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.tsx
+    - 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+
-
-        ({(?:
-          \* |                                       # {*} any type
-          \? |                                       # {?} unknown type
-
-          (?:
-            (?:                                       # Check for a prefix
-              \? |                                   # {?string} nullable type
-              !   |                                   # {!string} non-nullable type
-              \.{3}                                  # {...string} variable number of parameters
-            )?
-
-            (?:
-              (?:
-                function                              # {function(string, number)} function type
-                \s*
-                \(
-                \s*
-                (?:
-                  [a-zA-Z_$][\w$]*
-                  (?:
-                    \s*,\s*
-                    [a-zA-Z_$][\w$]*
-                  )*
-                )?
-                \s*
-                \)
-                (?:                                   # {function(): string} function return type
-                  \s*:\s*
-                  [a-zA-Z_$][\w$]*
-                )?
-              )?
+        (?:
+          # URL
+          (
+            (?=https?://)
+            (?:[^\s*]|\*[^/])+
+          )
+          |
+          # JSDoc namepath
+          (
+            (?!
+              # Avoid matching bare URIs (also acceptable as links)
+              https?://
               |
-              (?:
-                \(                                   # Opening bracket of multiple types with parenthesis {(string|number)}
-                  [a-zA-Z_$]+
-                  (?:
-                    (?:
-                      [\w$]*
-                      (?:\[\])?                     # {(string[]|number)} type application, an array of strings or a number
-                    ) |
-                    \.?<[\w$]+(?:,\s+[\w$]+)*>    # {Array<string>} or {Object<string, number>} type application (optional .)
-                  )
-                  (?:
-                    [\.|~]                           # {Foo.bar} namespaced, {string|number} multiple, {Foo~bar} class-specific callback
-                    [a-zA-Z_$]+
-                    (?:
-                      (?:
-                        [\w$]*
-                        (?:\[\])?                   # {(string|number[])} type application, a string or an array of numbers
-                      ) |
-                      \.?<[\w$]+(?:,\s+[\w$]+)*>  # {Array<string>} or {Object<string, number>} type application (optional .)
-                    )
-                  )*
-                \) |
-                [a-zA-Z_$]+
-                (?:
-                  (?:
-                    [\w$]*
-                    (?:\[\])?                       # {(string|number[])} type application, a string or an array of numbers
-                  ) |
-                  \.?<[\w$]+(?:,\s+[\w$]+)*>      # {Array<string>} or {Object<string, number>} type application (optional .)
-                )
-                (?:
-                  [\.|~]                             # {Foo.bar} namespaced, {string|number} multiple, {Foo~bar} class-specific callback
-                  [a-zA-Z_$]+
-                  (?:
-                    [\w$]* |
-                    \.?<[\w$]+(?:,\s+[\w$]+)*>    # {Array<string>} or {Object<string, number>} type application (optional .)
-                  )
-                )*
-              )
+              # Avoid matching {@inline tags}; we match those below
+              (?:\[[^\[\]]*\])? # Possible description [preceding]{@tag}
+              {@(?:link|linkcode|linkplain|tutorial)\b
             )
-                                                      # Check for suffix
-            (?:\[\])?                               # {string[]} type application, an array of strings
-            =?                                        # {string=} optional parameter
+            # 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
         (
-          \[                                         # [foo] optional parameter
-            \s*
-            (?:
-              [a-zA-Z_$][\w$]*
-              (?:
-                (?:\[\])?                           # Foo[].bar properties within an array
-                \.                                   # Foo.Bar namespaced parameter
-                [a-zA-Z_$][\w$]*
-              )*
-              (?:
-                \s*
-                =                                     # [foo=bar] Default parameter value
-                \s*
-                [\w$\s]*
-              )?
-            )
-            \s*
-          \] |
-          (?:
-            [a-zA-Z_$][\w$]*
-            (?:
-              (?:\[\])?                             # Foo[].bar properties within an array
-              \.                                     # Foo.Bar namespaced parameter
-              [a-zA-Z_$][\w$]*
-            )*
-          )?
+          [A-Za-z_$]         # First character: non-numeric word character
+          [\w$.\[\]]*        # Rest of identifier
+          (?:                # Possible list of additional identifiers
+            \s* , \s*
+            [A-Za-z_$]
+            [\w$.\[\]]*
+          )*
         )
-
-        \s+
-
-        (?:-\s+)?                                     # optional hyphen before the description
-
-        ((?:(?!\*\/).)*)                             # The type description
-      captures:
-        0: other.meta.jsdoc
-        1: entity.name.type.instance.jsdoc
-        2: variable.other.jsdoc
-        3: other.description.jsdoc
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: variable.other.jsdoc
     - match: |-
         (?x)
-
-        ({(?:
-          \* |                                       # {*} any type
-          \? |                                       # {?} unknown type
-
-          (?:
-            (?:                                       # Check for a prefix
-              \? |                                   # {?string} nullable type
-              !   |                                   # {!string} non-nullable type
-              \.{3}                                  # {...string} variable number of parameters
-            )?
-
+        (
+          (@)
+          (?:arg|argument|const|constant|member|namespace|param|var)
+        )
+        \s+
+        (
+          [A-Za-z_$]
+          [\w$.\[\]]*
+        )
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: variable.other.jsdoc
+    - match: '((@)typedef)\s+(?={)'
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+      push:
+        - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'
+          pop: true
+        - include: jsdoctype
+        - match: '(?:[^@\s*/]|\*[^/])+'
+          scope: entity.name.type.instance.jsdoc
+    - match: '((@)(?:arg|argument|const|constant|member|namespace|param|prop|property|var))\s+(?={)'
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+      push:
+        - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'
+          pop: true
+        - include: jsdoctype
+        - match: '([A-Za-z_$][\w$.\[\]]*)'
+          scope: variable.other.jsdoc
+        - match: |-
+            (?x)
+            (\[)\s*
+            [\w$]+
             (?:
-              (?:
-                function                              # {function(string, number)} function type
-                \s*
-                \(
-                \s*
-                (?:
-                  [a-zA-Z_$][\w$]*
-                  (?:
-                    \s*,\s*
-                    [a-zA-Z_$][\w$]*
-                  )*
-                )?
-                \s*
-                \)
-                (?:                                   # {function(): string} function return type
-                  \s*:\s*
-                  [a-zA-Z_$][\w$]*
-                )?
-              )?
-              |
-              (?:
-                \(                                   # Opening bracket of multiple types with parenthesis {(string|number)}
-                  [a-zA-Z_$]+
-                  (?:
-                    [\w$]* |
-                    \.?<[\w$]+(?:,\s+[\w$]+)*>    # {Array<string>} or {Object<string, number>} type application (optional .)
-                  )
-                  (?:
-                    [\.|~]                           # {Foo.bar} namespaced, {string|number} multiple, {Foo~bar} class-specific callback
-                    [a-zA-Z_$]+
-                    (?:
-                      [\w$]* |
-                      \.?<[\w$]+(?:,\s+[\w$]+)*>  # {Array<string>} or {Object<string, number>} type application (optional .)
-                    )
-                  )*
-                \) |
-                [a-zA-Z_$]+
-                (?:
-                  [\w$]* |
-                  \.?<[\w$]+(?:,\s+[\w$]+)*>      # {Array<string>} or {Object<string, number>} type application (optional .)
-                )
-                (?:
-                  [\.|~]                             # {Foo.bar} namespaced, {string|number} multiple, {Foo~bar} class-specific callback
-                  [a-zA-Z_$]+
-                  (?:
-                    [\w$]* |
-                    \.?<[\w$]+(?:,\s+[\w$]+)*>    # {Array<string>} or {Object<string, number>} type application (optional .)
-                  )
+              (?:\[\])?                                        # Foo[ ].bar properties within an array
+              \.                                                # Foo.Bar namespaced parameter
+              [\w$]+
+            )*
+            (?:
+              \s*
+              (=)                                                # [foo=bar] Default parameter value
+              \s*
+              (
+                # The inner regexes are to stop the match early at */ and to not stop at escaped quotes
+                (?>
+                  "(?:(?:\*(?!/))|(?:\\(?!"))|[^*\\])*?" |                      # [foo="bar"] Double-quoted
+                  '(?:(?:\*(?!/))|(?:\\(?!'))|[^*\\])*?' |                      # [foo='bar'] Single-quoted
+                  \[ (?:(?:\*(?!/))|[^*])*? \] |                                # [foo=[1,2]] Array literal
+                  (?:(?:\*(?!/))|\s(?!\s*\])|\[.*?(?:\]|(?=\*/))|[^*\s\[\]])*   # Everything else
                 )*
               )
-            )
-                                                      # Check for suffix
-            (?:\[\])?                               # {string[]} type application, an array of strings
-            =?                                        # {string=} optional parameter
-          )
-        )})
-
+            )?
+            \s*(?:(\])((?:[^*\s]|\*[^\s/])+)?|(?=\*/))
+          scope: variable.other.jsdoc
+          captures:
+            1: punctuation.definition.optional-value.begin.bracket.square.jsdoc
+            2: keyword.operator.assignment.jsdoc
+            3: source.embedded.tsx
+            4: punctuation.definition.optional-value.end.bracket.square.jsdoc
+            5: invalid.illegal.syntax.jsdoc
+    - match: |-
+        (?x)
+        (
+          (@)
+          (?:define|enum|exception|export|extends|lends|implements|modifies
+          |namespace|private|protected|returns?|suppress|this|throws|type
+          |yields?)
+        )
+        \s+(?={)
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+      push:
+        - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'
+          pop: true
+        - include: jsdoctype
+    - match: |-
+        (?x)
+        (
+          (@)
+          (?:alias|augments|callback|constructs|emits|event|fires|exports?
+          |extends|external|function|func|host|lends|listens|interface|memberof!?
+          |method|module|mixes|mixin|name|requires|see|this|typedef|uses)
+        )
         \s+
-
-        (?:-\s+)?                                    # optional hyphen before the description
-
-        ((?:(?!\*\/).)*)                            # The type description
-      captures:
-        0: other.meta.jsdoc
-        1: entity.name.type.instance.jsdoc
-        2: other.description.jsdoc
+        (
+          (?:
+            [^{}@\s*] | \*[^/]
+          )+
+        )
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: entity.name.type.instance.jsdoc
+    - match: '((@)(?:default(?:value)?|license|version))\s+(([''''"]))'
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: variable.other.jsdoc
+        4: punctuation.definition.string.begin.jsdoc
+      push:
+        - meta_content_scope: variable.other.jsdoc
+        - match: (\3)|(?=$|\*/)
+          captures:
+            0: variable.other.jsdoc
+            1: punctuation.definition.string.end.jsdoc
+          pop: true
+    - match: '((@)(?:default(?:value)?|license|tutorial|variation|version))\s+([^\s*]+)'
+      captures:
+        1: storage.type.class.jsdoc
+        2: punctuation.definition.block.tag.jsdoc
+        3: variable.other.jsdoc
+    - match: '(?x) (@) (?:abstract|access|alias|api|arg|argument|async|attribute|augments|author|beta|borrows|bubbles |callback|chainable|class|classdesc|code|config|const|constant|constructor|constructs|copyright |default|defaultvalue|define|deprecated|desc|description|dict|emits|enum|event|example|exception |exports?|extends|extension(?:_?for)?|external|externs|file|fileoverview|final|fires|for|func |function|generator|global|hideconstructor|host|ignore|implements|implicitCast|inherit[Dd]oc |inner|instance|interface|internal|kind|lends|license|listens|main|member|memberof!?|method |mixes|mixins?|modifies|module|name|namespace|noalias|nocollapse|nocompile|nosideeffects |override|overview|package|param|polymer(?:Behavior)?|preserve|private|prop|property|protected |public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary |suppress|template|this|throws|todo|tutorial|type|typedef|unrestricted|uses|var|variation |version|virtual|writeOnce|yields?) \b'
+      scope: storage.type.class.jsdoc
+      captures:
+        1: punctuation.definition.block.tag.jsdoc
+    - include: inline-tags
   enum-declaration:
-    - match: '(?<!\.|\$)(?:(\bexport)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*)'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*)'
       captures:
         1: keyword.control.export.tsx
         2: storage.modifier.tsx
@@ -656,7 +642,7 @@ contexts:
                   pop: true
                 - include: comment
                 - include: variable-initializer
-            - match: '(?=((\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\])))'
+            - match: '(?=((\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\])))'
               push:
                 - match: '(?=,|\}|$)'
                   pop: true
@@ -666,76 +652,59 @@ contexts:
                 - include: variable-initializer
             - include: punctuation-comma
   export-declaration:
-    - match: '(?<!\.|\$)\b(export)\s+(as)\s+(namespace)\s+([_$[:alpha:]][_$[:alnum:]]*)'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)\s+(as)\s+(namespace)\s+([_$[:alpha:]][_$[:alnum:]]*)'
       captures:
         1: keyword.control.export.tsx
         2: keyword.control.as.tsx
         3: storage.type.namespace.tsx
         4: entity.name.type.module.tsx
-    - match: (?<!\.|\$)\b(export)(?:(?:\s*(=))|(?:\s+(default)(?=\s+)))
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:(?:\s*(=))|(?:\s+(default)(?=\s+)))'
       captures:
         1: keyword.control.export.tsx
         2: keyword.operator.assignment.tsx
         3: keyword.control.default.tsx
       push:
         - meta_scope: meta.export.default.tsx
-        - match: (?=;|\bexport\b|\bfunction\b|\bclass\b|\binterface\b|\blet\b|\bvar\b|\bconst\b|\bimport\b|\benum\b|\bnamespace\b|\bmodule\b|\btype\b|\babstract\b|\bdeclare\b|\basync\b|$)
+        - match: (?=;|$|\babstract\b|\basync\b|\bclass\b|\bconst\b|\bdeclare\b|\benum\b|\bexport\b|\bfunction\b|\bimport\b|\binterface\b|\blet\b|\bmodule\b|\bnamespace\b|\btype\b|\bvar\b)
           pop: true
         - include: expression
-    - match: (?<!\.|\$)\b(export)(?!(\s*:)|(\$))\b
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?!\s*:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       captures:
         0: keyword.control.export.tsx
       push:
         - meta_scope: meta.export.tsx
-        - match: (?=;|\bexport\b|\bfunction\b|\bclass\b|\binterface\b|\blet\b|\bvar\b|\bconst\b|\bimport\b|\benum\b|\bnamespace\b|\bmodule\b|\btype\b|\babstract\b|\bdeclare\b|\basync\b|$)
+        - match: (?=;|$|\babstract\b|\basync\b|\bclass\b|\bconst\b|\bdeclare\b|\benum\b|\bexport\b|\bfunction\b|\bimport\b|\binterface\b|\blet\b|\bmodule\b|\bnamespace\b|\btype\b|\bvar\b)
           pop: true
         - include: import-export-declaration
   expression:
-    - include: jsx
-    - include: string
-    - include: regex
-    - include: template
-    - include: comment
-    - include: function-expression
-    - include: class-or-interface-declaration
-    - include: arrow-function
-    - include: cast
-    - include: ternary-expression
-    - include: new-expr
-    - include: object-literal
-    - include: expression-operators
-    - include: function-call
-    - include: literal
-    - include: support-objects
+    - include: expressionWithoutIdentifiers
     - include: identifiers
-    - include: paren-expression
-    - include: punctuation-comma
-    - include: punctuation-accessor
+    - include: expressionPunctuations
   expression-operators:
-    - match: (?<!\.|\$)\b(await)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(await)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.control.flow.tsx
-    - match: (?<!\.|\$)\b(yield)\b(?!\$)(?:\s*(\*))?
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(yield)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?:\s*(\*))?'
       captures:
         1: keyword.control.flow.tsx
         2: keyword.generator.asterisk.tsx
-    - match: (?<!\.|\$)\bdelete\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))delete(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.delete.tsx
-    - match: (?<!\.|\$)\bin\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))in(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.in.tsx
-    - match: (?<!\.|\$)\bof\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))of(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.of.tsx
-    - match: (?<!\.|\$)\binstanceof\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.instanceof.tsx
-    - match: (?<!\.|\$)\bnew\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.new.tsx
     - include: typeof-operator
-    - match: (?<!\.|\$)\bvoid\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))void(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.void.tsx
-    - match: (?<!\.|\$)\bas\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'
       captures:
-        0: keyword.control.as.tsx
+        1: keyword.control.as.tsx
       push:
-        - match: '(?=$|[;,:})\]])'
+        - match: '(?=$|^|[;,:})\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+))'
           pop: true
         - include: type
     - match: \.\.\.
@@ -765,18 +734,39 @@ contexts:
     - match: '(?<=[_$[:alnum:])])\s*(/)(?![/*])'
       captures:
         1: keyword.operator.arithmetic.tsx
+  expressionPunctuations:
+    - include: punctuation-comma
+    - include: punctuation-accessor
+  expressionWithoutIdentifiers:
+    - include: jsx
+    - include: string
+    - include: regex
+    - include: template
+    - include: comment
+    - include: function-expression
+    - include: class-expression
+    - include: arrow-function
+    - include: cast
+    - include: ternary-expression
+    - include: new-expr
+    - include: object-literal
+    - include: expression-operators
+    - include: function-call
+    - include: literal
+    - include: support-objects
+    - include: paren-expression
   field-declaration:
-    - match: '(?<!\()(?:(?<!\.|\$)\b(readonly)\s+)?(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))'
+    - match: '(?<!\()(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s+)?(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))'
       captures:
         1: storage.modifier.tsx
       push:
         - meta_scope: meta.field.declaration.tsx
-        - match: '(?=\}|;|,|$)|(?<=\})'
+        - match: '(?=\}|;|,|$|(^(?!(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))))|(?<=\})'
           pop: true
         - include: variable-initializer
-        - match: '(?=((?:[_$[:alpha:]][_$[:alnum:]]*)|(?:\''[^'']*\'')|(?:\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))'
+        - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))'
           push:
-            - match: '(?=[};,=]|$)|(?<=\})'
+            - match: '(?=[};,=]|$|(^(?!(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))))|(?<=\})'
               pop: true
             - include: type-annotation
             - include: string
@@ -784,34 +774,53 @@ contexts:
             - include: comment
             - match: |-
                 (?x)([_$[:alpha:]][_$[:alnum:]]*)(?=(\?\s*)?\s*
-                  (=\s*(
-                    (async\s+) |
-                    (function\s*[(<]) |
+                # function assignment |
+                (=\s*(
+                  ((async\s+)?(
+                    (function\s*[(<*]) |
                     (function\s+) |
-                    ([_$[:alpha:]][_$[:alnum:]]*\s*=>) |
-                    ([(]\s*(([)]\s*:)|([_$[:alpha:]][_$[:alnum:]]*\s*:)|(\.\.\.) )) |
-                    ([<]\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s*[^=>])|(\s*[,]))) |
-                    ((<([^<>]|\<[^<>]+\>)+>\s*)?\(([^()]|\([^()]*\))*\)(\s*:\s*(.)*)?\s*=>))
-                  ) |
-                  (:\s*(
-                    (<) |
-                    ([(]\s*(
-                      ([)]) |
-                      (\.\.\.) |
-                      ([_$[:alnum:]]+\s*(
-                        ([:,?=])|
-                        ([)]\s*=>)
-                      ))
-                    )))
+                    ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
+                  )) |
+                  ((async\s*)?(
+                    # sure shot arrow functions even if => is on new line
+                (
+                  [(]\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*[^()]*)?\))*)?\)                          # parameteres
+                  (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+                  \s*=>                                                                         # arrow operator
                 )
+                  ))
+                )) |
+                # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
+                (:\s*(
+                  (<) |
+                  ([(]\s*(
+                    ([)]) |
+                    (\.\.\.) |
+                    ([_$[:alnum:]]+\s*(
+                      ([:,?=])|
+                      ([)]\s*=>)
+                    ))
+                  ))
+                )))
               scope: meta.definition.property.tsx entity.name.function.tsx
             - match: "[_$[:alpha:]][_$[:alnum:]]*"
               scope: meta.definition.property.tsx variable.object.property.tsx
             - match: \?
               scope: keyword.operator.optional.tsx
   for-loop:
-    - match: (?<!\.|\$)\b(for)(?:\s+(await))?\s*(\()
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(for)(?:\s+(await))?\s*(\()'
       captures:
         1: keyword.control.loop.tsx
         2: keyword.control.loop.tsx
@@ -824,18 +833,33 @@ contexts:
         - include: var-expr
         - include: expression
         - include: punctuation-semicolon
+  function-body:
+    - include: comment
+    - include: type-parameters
+    - include: function-parameters
+    - include: return-type
+    - include: decl-block
   function-call:
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\.\s*)*|(\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)\s*(<([^<>]|\<[^<>]+\>)+>\s*)?\()'
+    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)\s*(\?\.\s*)?(<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\))|\<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\)))*\>)*>\s*)?\()'
       push:
-        - match: '(?<=\))(?!(([_$[:alpha:]][_$[:alnum:]]*\s*\.\s*)*|(\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)\s*(<([^<>]|\<[^<>]+\>)+>\s*)?\()'
+        - match: '(?<=\))(?!(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)\s*(\?\.\s*)?(<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\))|\<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\)))*\>)*>\s*)?\()'
           pop: true
-        - include: literal
-        - include: support-objects
-        - include: object-identifiers
-        - include: punctuation-accessor
-        - match: "([_$[:alpha:]][_$[:alnum:]]*)"
-          scope: entity.name.function.tsx
+        - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))'
+          push:
+            - meta_scope: meta.function-call.tsx
+            - match: '(?=\s*(\?\.\s*)?(<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\))|\<\s*(([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))([^<>\(]|(\([^\(\)]*\)))*\>)*>\s*)?\()'
+              pop: true
+            - include: literal
+            - include: support-objects
+            - include: object-identifiers
+            - include: punctuation-accessor
+            - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*[\(]\s*[\"\''\`]))'
+              scope: keyword.operator.expression.import.tsx
+            - match: "([_$[:alpha:]][_$[:alnum:]]*)"
+              scope: entity.name.function.tsx
         - include: comment
+        - match: \?\.
+          scope: meta.function-call.tsx punctuation.accessor.optional.tsx
         - match: \<
           captures:
             0: punctuation.definition.typeparameters.begin.tsx
@@ -849,7 +873,7 @@ contexts:
             - include: punctuation-comma
         - include: paren-expression
   function-declaration:
-    - match: '(?<!\.|\$)\b(?:(export)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'
       captures:
         1: keyword.control.export.tsx
         2: storage.modifier.async.tsx
@@ -858,15 +882,11 @@ contexts:
         5: meta.definition.function.tsx entity.name.function.tsx
       push:
         - meta_scope: meta.function.tsx
-        - match: '(?=$|;)|(?<=\})'
+        - match: '(?=$|^|;)|(?<=\})'
           pop: true
-        - include: comment
-        - include: type-parameters
-        - include: function-parameters
-        - include: return-type
-        - include: decl-block
+        - include: function-body
   function-expression:
-    - match: '(?<!\.|\$)\b(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'
       captures:
         1: storage.modifier.async.tsx
         2: storage.type.function.tsx
@@ -876,11 +896,7 @@ contexts:
         - meta_scope: meta.function.expression.tsx
         - match: '(?<=\})'
           pop: true
-        - include: comment
-        - include: type-parameters
-        - include: function-parameters
-        - include: return-type
-        - include: decl-block
+        - include: function-body
   function-parameters:
     - match: \(
       captures:
@@ -902,39 +918,63 @@ contexts:
   identifiers:
     - include: object-identifiers
     - match: |-
-        (?x)(?:(\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)(?=\s*=\s*(
-        (async\s+)|(function\s*[(<])|(function\s+)|
-        ([_$[:alpha:]][_$[:alnum:]]*\s*=>)|
-        ([(]\s*(([)]\s*:)|([_$[:alpha:]][_$[:alnum:]]*\s*:)|(\.\.\.) )) |
-        ([<]\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s*[^=>])|(\s*[,]))) |
-        ((<([^<>]|\<[^<>]+\>)+>\s*)?\(([^()]|\([^()]*\))*\)(\s*:\s*(.)*)?\s*=>)))
+        (?x)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*)?([_$[:alpha:]][_$[:alnum:]]*)(?=\s*=\s*(
+          ((async\s+)?(
+            (function\s*[(<*]) |
+            (function\s+) |
+            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
+          )) |
+          ((async\s*)?(
+            # sure shot arrow functions even if => is on new line
+        (
+          [(]\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*[^()]*)?\))*)?\)                          # parameteres
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+          \s*=>                                                                         # arrow operator
+        )
+          ))
+        ))
       captures:
         1: punctuation.accessor.tsx
-        2: entity.name.function.tsx
-    - match: '(\.)\s*([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])'
+        2: punctuation.accessor.optional.tsx
+        3: entity.name.function.tsx
+    - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])'
       captures:
         1: punctuation.accessor.tsx
-        2: variable.other.constant.property.tsx
-    - match: '(\.)\s*([_$[:alpha:]][_$[:alnum:]]*)'
+        2: punctuation.accessor.optional.tsx
+        3: variable.other.constant.property.tsx
+    - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*([_$[:alpha:]][_$[:alnum:]]*)'
       captures:
         1: punctuation.accessor.tsx
-        2: variable.other.property.tsx
+        2: punctuation.accessor.optional.tsx
+        3: variable.other.property.tsx
     - match: "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])"
       scope: variable.other.constant.tsx
     - match: "[_$[:alpha:]][_$[:alnum:]]*"
       scope: variable.other.readwrite.tsx
   import-declaration:
-    - match: (?<!\.|\$)(?:(\bexport)\s+)?\b(import)(?!(\s*:)|(\$))\b
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)(?!\s*[:\(])(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       captures:
         1: keyword.control.export.tsx
         2: keyword.control.import.tsx
       push:
         - meta_scope: meta.import.tsx
-        - match: (?=;|$)
+        - match: (?=;|$|^)
           pop: true
         - include: import-export-declaration
   import-equals-declaration:
-    - match: '(?<!\.|\$)(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\()'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\()'
       captures:
         1: keyword.control.export.tsx
         2: keyword.control.import.tsx
@@ -950,7 +990,7 @@ contexts:
           pop: true
         - include: comment
         - include: string
-    - match: '(?<!\.|\$)(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b)'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b)'
       captures:
         1: keyword.control.export.tsx
         2: keyword.control.import.tsx
@@ -958,13 +998,14 @@ contexts:
         4: keyword.operator.assignment.tsx
       push:
         - meta_scope: meta.import-equals.internal.tsx
-        - match: (?=;|$)
+        - match: (?=;|$|^)
           pop: true
         - include: comment
-        - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(\.)'
+        - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))'
           captures:
             1: entity.name.type.module.tsx
             2: punctuation.accessor.tsx
+            3: punctuation.accessor.optional.tsx
         - match: "([_$[:alpha:]][_$[:alnum:]]*)"
           scope: variable.other.readwrite.tsx
   import-export-block:
@@ -980,17 +1021,13 @@ contexts:
         - include: import-export-clause
   import-export-clause:
     - include: comment
-    - match: |-
-        (?x) (?: \b(default)\b | (\*) | ([_$[:alpha:]][_$[:alnum:]]*)) \s+
-        (as) \s+ (?: (\b default \b | \*) | ([_$[:alpha:]][_$[:alnum:]]*))
-      comment: (default|*|name) as alias
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bdefault)|(\*)|(\b[_$[:alpha:]][_$[:alnum:]]*))\s+(as)\s+(\b[_$[:alpha:]][_$[:alnum:]]*)'
       captures:
         1: keyword.control.default.tsx
         2: constant.language.import-export-all.tsx
         3: variable.other.readwrite.tsx
         4: keyword.control.as.tsx
-        5: invalid.illegal.tsx
-        6: variable.other.readwrite.alias.tsx
+        5: variable.other.readwrite.alias.tsx
     - include: punctuation-comma
     - match: \*
       scope: constant.language.import-export-all.tsx
@@ -1006,7 +1043,7 @@ contexts:
       scope: keyword.control.from.tsx
     - include: import-export-clause
   indexer-declaration:
-    - match: '(?:(?<!\.|\$)\b(readonly)\s*)?(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:)'
+    - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s*)?(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:)'
       captures:
         1: storage.modifier.tsx
         2: meta.brace.square.tsx
@@ -1020,7 +1057,7 @@ contexts:
           pop: true
         - include: type-annotation
   indexer-mapped-type-declaration:
-    - match: '(?:(?<!\.|\$)\b(readonly)\s*)?(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s+(in)\s+'
+    - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s*)?(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s+(in)\s+'
       captures:
         1: storage.modifier.tsx
         2: meta.brace.square.tsx
@@ -1034,10 +1071,66 @@ contexts:
             2: keyword.operator.optional.tsx
           pop: true
         - include: type
+  inline-tags:
+    - match: '(\[)[^\]]+(\])(?={@(?:link|linkcode|linkplain|tutorial))'
+      scope: constant.other.description.jsdoc
+      captures:
+        1: punctuation.definition.bracket.square.begin.jsdoc
+        2: punctuation.definition.bracket.square.end.jsdoc
+    - match: '({)((@)(?:link(?:code|plain)?|tutorial))\s*'
+      captures:
+        1: punctuation.definition.bracket.curly.begin.jsdoc
+        2: storage.type.class.jsdoc
+        3: punctuation.definition.inline.tag.jsdoc
+      push:
+        - meta_scope: entity.name.type.instance.jsdoc
+        - match: '}|(?=\*/)'
+          captures:
+            0: punctuation.definition.bracket.curly.end.jsdoc
+          pop: true
+        - match: '\G((?=https?://)(?:[^|}\s*]|\*[/])+)(\|)?'
+          captures:
+            1: variable.other.link.underline.jsdoc
+            2: punctuation.separator.pipe.jsdoc
+        - match: '\G((?:[^{}@\s|*]|\*[^/])+)(\|)?'
+          captures:
+            1: variable.other.description.jsdoc
+            2: punctuation.separator.pipe.jsdoc
+  interface-declaration:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?\b(?:(abstract)\s+)?\b(interface)\b(?=\s+|/[/*])'
+      captures:
+        1: keyword.control.export.tsx
+        2: storage.modifier.tsx
+        3: storage.type.interface.tsx
+      push:
+        - meta_scope: meta.interface.tsx
+        - match: '(?<=\})'
+          pop: true
+        - include: comment
+        - include: class-or-interface-heritage
+        - match: "[_$[:alpha:]][_$[:alnum:]]*"
+          captures:
+            0: entity.name.type.interface.tsx
+        - include: type-parameters
+        - include: class-or-interface-body
+  jsdoctype:
+    - match: '\G{(?:[^}*]|\*[^/}])+$'
+      scope: invalid.illegal.type.jsdoc
+    - match: '\G({)'
+      captures:
+        0: entity.name.type.instance.jsdoc
+        1: punctuation.definition.bracket.curly.begin.jsdoc
+      push:
+        - meta_content_scope: entity.name.type.instance.jsdoc
+        - match: '((}))\s*|(?=\*/)'
+          captures:
+            1: entity.name.type.instance.jsdoc
+            2: punctuation.definition.bracket.curly.end.jsdoc
+          pop: true
+        - include: brackets
   jsx:
-    - include: jsx-tag-without-attributes
+    - include: jsx-tag-without-attributes-in-expression
     - include: jsx-tag-in-expression
-    - include: jsx-tag-invalid
   jsx-child-tag:
     - match: |-
         (?x)
@@ -1045,19 +1138,19 @@ contexts:
         ([_$a-zA-Z][-$\w.]*(?<!\.|-))
         (?=\s+(?!\?)|/?>))
       push:
-        - match: '(/>)|(?:(</)\s*([_$a-zA-Z][-$\w.]*(?<!\.|-))\s*(>))'
+        - match: '(/>)|(?:(</)\s*((?:[a-z][a-z0-9]*|([_$a-zA-Z][-$\w.]*))(?<!\.|-))\s*(>))'
           captures:
             0: meta.tag.tsx
             1: punctuation.definition.tag.end.tsx
             2: punctuation.definition.tag.begin.tsx
             3: entity.name.tag.tsx
-            4: punctuation.definition.tag.end.tsx
+            4: support.class.component.tsx
+            5: punctuation.definition.tag.end.tsx
           pop: true
         - include: jsx-tag
   jsx-children:
     - include: jsx-tag-without-attributes
     - include: jsx-child-tag
-    - include: jsx-tag-invalid
     - include: jsx-evaluated-code
     - include: jsx-entities
   jsx-entities:
@@ -1114,12 +1207,14 @@ contexts:
         - match: |-
             (?x)
             (<)\s*
-            ([_$a-zA-Z][-$\w.]*(?<!\.|-))
+            ((?:[a-z][a-z0-9]*|([_$a-zA-Z][-$\w.]*))(?<!\.|-))
             (?=\s+(?!\?)|/?>)
           captures:
             1: punctuation.definition.tag.begin.tsx
             2: entity.name.tag.tsx
+            3: support.class.component.tsx
           push:
+            - meta_content_scope: meta.tag.attributes.tsx
             - match: "(?=[/]?>)"
               pop: true
             - include: comment
@@ -1157,40 +1252,48 @@ contexts:
     - match: |-
         (?x)
         (?<=[({\[,?=>:*]|&&|\|\||\?|\Wreturn|^return|\Wdefault|^)\s*
-        (?!(<)\s*([_$a-zA-Z][-$\w.]*(?<!\.|-))\s*(>)) #look ahead is not start of tag without attributes
         (?!<\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s+[^=>])|,)) # look ahead is not type parameter of arrow
         (?=(<)\s*
         ([_$a-zA-Z][-$\w.]*(?<!\.|-))
         (?=\s+(?!\?)|/?>))
       push:
-        - match: '(/>)|(?:(</)\s*([_$a-zA-Z][-$\w.]*(?<!\.|-))\s*(>))'
+        - match: '(/>)|(?:(</)\s*((?:[a-z][a-z0-9]*|([_$a-zA-Z][-$\w.]*))(?<!\.|-))\s*(>))'
           captures:
             0: meta.tag.tsx
             1: punctuation.definition.tag.end.tsx
             2: punctuation.definition.tag.begin.tsx
             3: entity.name.tag.tsx
-            4: punctuation.definition.tag.end.tsx
+            4: support.class.component.tsx
+            5: punctuation.definition.tag.end.tsx
           pop: true
         - include: jsx-tag
-  jsx-tag-invalid:
-    - match: <\s*>
-      scope: invalid.illegal.tag.incomplete.tsx
   jsx-tag-without-attributes:
-    - match: '(<)\s*([_$a-zA-Z][-$\w.]*(?<!\.|-))\s*(>)'
+    - match: '(<)\s*((?:[a-z][a-z0-9]*|([_$a-zA-Z][-$\w.]*))(?<!\.|-))?\s*(>)'
       captures:
         1: punctuation.definition.tag.begin.tsx
         2: entity.name.tag.tsx
-        3: punctuation.definition.tag.end.tsx
+        3: support.class.component.tsx
+        4: punctuation.definition.tag.end.tsx
       push:
         - meta_scope: meta.tag.without-attributes.tsx
         - meta_content_scope: meta.jsx.children.tsx
-        - match: '(</)\s*([_$a-zA-Z][-$\w.]*(?<!\.|-))\s*(>)'
+        - match: '(</)\s*((?:[a-z][a-z0-9]*|([_$a-zA-Z][-$\w.]*))(?<!\.|-))?\s*(>)'
           captures:
             1: punctuation.definition.tag.begin.tsx
             2: entity.name.tag.tsx
-            3: punctuation.definition.tag.end.tsx
+            3: support.class.component.tsx
+            4: punctuation.definition.tag.end.tsx
           pop: true
         - include: jsx-children
+  jsx-tag-without-attributes-in-expression:
+    - match: |-
+        (?x)
+        (?<=[({\[,?=>:*]|&&|\|\||\?|\Wreturn|^return|\Wdefault|^)\s*
+        (?=(<)\s*((?:[a-z][a-z0-9]*|([_$a-zA-Z][-$\w.]*))(?<!\.|-))?\s*(>))
+      push:
+        - match: '(?!\s*(<)\s*((?:[a-z][a-z0-9]*|([_$a-zA-Z][-$\w.]*))(?<!\.|-))?\s*(>))'
+          pop: true
+        - include: jsx-tag-without-attributes
   literal:
     - include: numeric-literal
     - include: boolean-literal
@@ -1201,27 +1304,35 @@ contexts:
     - include: this-literal
     - include: super-literal
   method-declaration:
-    - match: '(?<!\.|\$)(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(?:\b(?:(new)|(constructor))\b(?!\$|:))|(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))?\s*[\(\<]))'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])'
       captures:
         1: storage.modifier.tsx
         2: storage.modifier.tsx
         3: storage.modifier.async.tsx
         4: storage.type.property.tsx
-        5: keyword.operator.new.tsx
-        6: storage.type.tsx
-        7: keyword.generator.asterisk.tsx
+        5: keyword.generator.asterisk.tsx
       push:
         - meta_scope: meta.method.declaration.tsx
         - match: '(?=\}|;|,|$)|(?<=\})'
           pop: true
         - include: method-declaration-name
-        - include: comment
-        - include: type-parameters
-        - include: function-parameters
-        - include: return-type
-        - include: decl-block
+        - include: function-body
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:(?:\b(?:(new)|(constructor))\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))?\s*[\(\<]))'
+      captures:
+        1: storage.modifier.tsx
+        2: storage.modifier.tsx
+        3: storage.modifier.async.tsx
+        4: keyword.operator.new.tsx
+        5: storage.type.tsx
+        6: keyword.generator.asterisk.tsx
+      push:
+        - meta_scope: meta.method.declaration.tsx
+        - match: '(?=\}|;|,|$)|(?<=\})'
+          pop: true
+        - include: method-declaration-name
+        - include: function-body
   method-declaration-name:
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??)\s*[\(\<])'
+    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??)\s*[\(\<])'
       push:
         - match: (?=\(|\<)
           pop: true
@@ -1232,32 +1343,33 @@ contexts:
         - match: \?
           scope: keyword.operator.optional.tsx
   namespace-declaration:
-    - match: '(?<!\.|\$)(?:(\bexport)\s+)?\b(namespace|module)\s+(?=[_$[:alpha:]"''`])'
+    - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(namespace|module)\s+(?=[_$[:alpha:]"''`]))'
       captures:
         1: keyword.control.export.tsx
         2: storage.type.namespace.tsx
       push:
         - meta_scope: meta.namespace.declaration.tsx
-        - match: '(?=$|\{)'
+        - match: '(?<=\})|(?=;|\babstract\b|\basync\b|\bclass\b|\bconst\b|\bdeclare\b|\benum\b|\bexport\b|\bfunction\b|\bimport\b|\binterface\b|\blet\b|\bmodule\b|\bnamespace\b|\btype\b|\bvar\b)'
           pop: true
         - include: comment
         - include: string
         - match: "([_$[:alpha:]][_$[:alnum:]]*)"
           scope: entity.name.type.module.tsx
         - include: punctuation-accessor
+        - include: decl-block
   new-expr:
-    - match: (?<!\.|\$)\b(new)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       captures:
         1: keyword.operator.new.tsx
       push:
         - meta_scope: new.expr.tsx
-        - match: '(?<=\))|(?=[;),}]|$|((?<!\.|\$)\bnew\b(?!\$)))'
+        - match: '(?<=\))|(?=[;),}\]]|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'
           pop: true
         - include: paren-expression
-        - include: class-or-interface-declaration
+        - include: class-declaration
         - include: type
   null-literal:
-    - match: (?<!\.|\$)\bnull\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))null(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.null.tsx
   numeric-literal:
     - match: '\b(?<!\$)0(x|X)[0-9a-fA-F]+\b(?!\$)'
@@ -1272,7 +1384,7 @@ contexts:
           (?:\b[0-9]+(\.)[0-9]+[eE][+-]?[0-9]+\b)| # 1.1E+3
           (?:\b[0-9]+(\.)[eE][+-]?[0-9]+\b)|       # 1.E+3
           (?:\B(\.)[0-9]+[eE][+-]?[0-9]+\b)|       # .1E+3
-          (?:\b[0-9]+[eE][+-]?[0-9]+\b)|            # 1E+3
+          (?:\b[0-9]+[eE][+-]?[0-9]+\b)|           # 1E+3
           (?:\b[0-9]+(\.)[0-9]+\b)|                # 1.1
           (?:\b[0-9]+(\.)\B)|                      # 1.
           (?:\B(\.)[0-9]+\b)|                      # .1
@@ -1287,13 +1399,13 @@ contexts:
         5: meta.delimiter.decimal.period.tsx
         6: meta.delimiter.decimal.period.tsx
   numericConstant-literal:
-    - match: (?<!\.|\$)\bNaN\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))NaN(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.nan.tsx
-    - match: (?<!\.|\$)\bInfinity\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Infinity(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.infinity.tsx
   object-binding-element:
     - include: comment
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
+    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
       push:
         - match: '(?=,|\})'
           pop: true
@@ -1304,7 +1416,7 @@ contexts:
     - include: variable-initializer
     - include: punctuation-comma
   object-binding-element-propertyName:
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
+    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
       push:
         - match: (:)
           captures:
@@ -1326,22 +1438,23 @@ contexts:
           pop: true
         - include: object-binding-element
   object-identifiers:
-    - match: '([_$[:alpha:]][_$[:alnum:]]*)(?=\s*\.\s*prototype\b(?!\$))'
+    - match: '([_$[:alpha:]][_$[:alnum:]]*)(?=\s*\??\.\s*prototype\b(?!\$))'
       scope: support.class.tsx
     - match: |-
-        (?x)(\.)\s*(?:
+        (?x)(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?:
           ([[:upper:]][_$[:digit:][:upper:]]*) |
           ([_$[:alpha:]][_$[:alnum:]]*)
-        )(?=\s*\.\s*[_$[:alpha:]][_$[:alnum:]]*)
+        )(?=\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)
       captures:
         1: punctuation.accessor.tsx
-        2: variable.other.constant.object.property.tsx
-        3: variable.other.object.property.tsx
+        2: punctuation.accessor.optional.tsx
+        3: variable.other.constant.object.property.tsx
+        4: variable.other.object.property.tsx
     - match: |-
         (?x)(?:
           ([[:upper:]][_$[:digit:][:upper:]]*) |
           ([_$[:alpha:]][_$[:alnum:]]*)
-        )(?=\s*\.\s*[_$[:alpha:]][_$[:alnum:]]*)
+        )(?=\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)
       captures:
         1: variable.other.constant.object.tsx
         2: variable.other.object.tsx
@@ -1357,7 +1470,7 @@ contexts:
           pop: true
         - include: object-member
   object-literal-method-declaration:
-    - match: '(?<!\.|\$)(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))?\s*[\(\<])'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])'
       captures:
         1: storage.modifier.async.tsx
         2: storage.type.property.tsx
@@ -1367,77 +1480,98 @@ contexts:
         - match: '(?=\}|;|,)|(?<=\})'
           pop: true
         - include: method-declaration-name
-        - include: comment
-        - include: type-parameters
-        - include: function-parameters
-        - include: return-type
-        - include: object-literal-method-overload-declaration
-        - include: decl-block
-  object-literal-method-overload-declaration:
-    - match: '(?<!\.|\$)(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))?\s*[\(\<])'
-      captures:
-        1: storage.modifier.async.tsx
-        2: storage.type.property.tsx
-        3: keyword.generator.asterisk.tsx
-      push:
-        - match: (?=\(|\<)
-          pop: true
-        - include: method-declaration-name
+        - include: function-body
+        - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=((([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])'
+          captures:
+            1: storage.modifier.async.tsx
+            2: storage.type.property.tsx
+            3: keyword.generator.asterisk.tsx
+          push:
+            - match: (?=\(|\<)
+              pop: true
+            - include: method-declaration-name
   object-member:
     - include: comment
     - include: object-literal-method-declaration
-    - match: '(?=(?:(?:\''[^'']*\'')|(?:\"[^"]*\")|(?:\[([^\[\]]|\[[^\[\]]*\])+\]))\s*:)'
+    - match: '(?=\[)'
       push:
-        - meta_scope: meta.object.member.tsx
-        - match: '(?=,|\})'
+        - meta_scope: meta.object.member.tsx meta.object-literal.key.tsx
+        - match: (?=:)
           pop: true
-        - match: '(?=(?:(?:\''[^'']*\'')|(?:\"[^"]*\")|(?:\[([^\[\]]|\[[^\[\]]*\])+\]))\s*:)'
-          push:
-            - meta_scope: meta.object-literal.key.tsx
-            - match: ":"
-              captures:
-                0: punctuation.separator.key-value.tsx
-              pop: true
-            - include: string
-            - include: array-literal
-        - include: expression
+        - include: array-literal
+    - match: '(?=[\''\"])'
+      push:
+        - meta_scope: meta.object.member.tsx meta.object-literal.key.tsx
+        - match: (?=:)
+          pop: true
+        - include: string
+    - match: '(?![_$[:alpha:]])([[:digit:]]+)\s*(?=:)'
+      scope: meta.object.member.tsx
+      captures:
+        0: meta.object-literal.key.tsx
+        1: constant.numeric.decimal.tsx
     - match: |-
-        (?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\s*(:)(?=\s*(
-        (async\s+)|(function\s*[(<])|(function\s+)|
-        ([_$[:alpha:]][_$[:alnum:]]*\s*=>)|
-        ([(]\s*(([)]\s*:)|([_$[:alpha:]][_$[:alnum:]]*\s*:)|(\.\.\.) )) |
-        ([<]\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s*[^=>])|(\s*[,]))) |
-        ((<([^<>]|\<[^<>]+\>)+>\s*)?\(([^()]|\([^()]*\))*\)(\s*:\s*(.)*)?\s*=>))))
+        (?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:\s*(
+          ((async\s+)?(
+            (function\s*[(<*]) |
+            (function\s+) |
+            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
+          )) |
+          ((async\s*)?(
+            # sure shot arrow functions even if => is on new line
+        (
+          [(]\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*[^()]*)?\))*)?\)                          # parameteres
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+          \s*=>                                                                         # arrow operator
+        )
+          ))
+        )))
+      scope: meta.object.member.tsx
       captures:
         0: meta.object-literal.key.tsx
         1: entity.name.function.tsx
-        2: punctuation.separator.key-value.tsx
+    - match: '(?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=:)'
+      scope: meta.object.member.tsx
+      captures:
+        0: meta.object-literal.key.tsx
+    - match: \.\.\.
+      captures:
+        0: keyword.operator.spread.tsx
       push:
         - meta_scope: meta.object.member.tsx
         - match: '(?=,|\})'
           pop: true
         - include: expression
-    - match: '(?:[_$[:alpha:]][_$[:alnum:]]*)\s*(:)'
+    - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$)'
+      scope: meta.object.member.tsx
       captures:
-        0: meta.object-literal.key.tsx
-        1: punctuation.separator.key-value.tsx
+        1: variable.other.readwrite.tsx
+    - match: '(?=[_$[:alpha:]][_$[:alnum:]]*\s*=)'
       push:
         - meta_scope: meta.object.member.tsx
-        - match: '(?=,|\})'
+        - match: '(?=,|\}|$)'
           pop: true
         - include: expression
-    - match: \.\.\.
+    - match: ":"
       captures:
-        0: keyword.operator.spread.tsx
+        0: meta.object-literal.key.tsx punctuation.separator.key-value.tsx
       push:
         - meta_scope: meta.object.member.tsx
         - match: '(?=,|\})'
           pop: true
         - include: expression
-    - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$)'
-      scope: meta.object.member.tsx
-      captures:
-        1: variable.other.readwrite.tsx
     - include: punctuation-comma
   parameter-array-binding-pattern:
     - match: '(?:(\.\.\.)\s*)?(\[)'
@@ -1462,42 +1596,63 @@ contexts:
       captures:
         1: storage.modifier.tsx
     - match: |-
-        (?x)(?:\s*\b(public|private|protected|readonly)\s+)?(\.\.\.)?\s*(?<!=|:)([_$[:alpha:]][_$[:alnum:]]*)\s*(\??)(?=\s*
-          (=\s*(
-            (async\s+) |
-            (function\s*[(<]) |
+        (?x)(?:\s*\b(public|private|protected|readonly)\s+)?(\.\.\.)?\s*(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*
+        # function assignment |
+        (=\s*(
+          ((async\s+)?(
+            (function\s*[(<*]) |
             (function\s+) |
-            ([_$[:alpha:]][_$[:alnum:]]*\s*=>) |
-            ([(]\s*(([)]\s*:)|([_$[:alpha:]][_$[:alnum:]]*\s*:)|(\.\.\.) )) |
-            ([<]\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s*[^=>])|(\s*[,]))) |
-            ((<([^<>]|\<[^<>]+\>)+>\s*)?\(([^()]|\([^()]*\))*\)(\s*:\s*(.)*)?\s*=>))
-          ) |
-          (:\s*(
-            (<) |
-            ([(]\s*(
-              ([)]) |
-              (\.\.\.) |
-              ([_$[:alnum:]]+\s*(
-                ([:,?=])|
-                ([)]\s*=>)
-              ))
-            )))
+            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
+          )) |
+          ((async\s*)?(
+            # sure shot arrow functions even if => is on new line
+        (
+          [(]\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*[^()]*)?\))*)?\)                          # parameteres
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+          \s*=>                                                                         # arrow operator
         )
+          ))
+        )) |
+        # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
+        (:\s*(
+          (<) |
+          ([(]\s*(
+            ([)]) |
+            (\.\.\.) |
+            ([_$[:alnum:]]+\s*(
+              ([:,?=])|
+              ([)]\s*=>)
+            ))
+          ))
+        )))
       captures:
         1: storage.modifier.tsx
         2: keyword.operator.rest.tsx
-        3: entity.name.function.tsx
-        4: keyword.operator.optional.tsx
-    - match: '(?:\s*\b(public|private|protected|readonly)\s+)?(\.\.\.)?\s*(?<!=|:)([_$[:alpha:]][_$[:alnum:]]*)\s*(\??)'
+        3: entity.name.function.tsx variable.language.this.tsx
+        4: entity.name.function.tsx
+        5: keyword.operator.optional.tsx
+    - match: '(?x)(?:\s*\b(public|private|protected|readonly)\s+)?(\.\.\.)?\s*(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)'
       captures:
         1: storage.modifier.tsx
         2: keyword.operator.rest.tsx
-        3: variable.parameter.tsx
-        4: keyword.operator.optional.tsx
+        3: variable.parameter.tsx variable.language.this.tsx
+        4: variable.parameter.tsx
+        5: keyword.operator.optional.tsx
   parameter-object-binding-element:
     - include: comment
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''[^'']*\'')|(\"[^"]*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
+    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)|(\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))'
       push:
         - match: '(?=,|\})'
           pop: true
@@ -1530,11 +1685,13 @@ contexts:
         - include: expression
         - include: punctuation-comma
   property-accessor:
-    - match: (?<!\.|\$)\b(get|set)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(get|set)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: storage.type.property.tsx
   punctuation-accessor:
-    - match: \.
-      scope: punctuation.accessor.tsx
+    - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))'
+      captures:
+        1: punctuation.accessor.tsx
+        2: punctuation.accessor.optional.tsx
   punctuation-comma:
     - match: ","
       scope: punctuation.separator.comma.tsx
@@ -1566,7 +1723,7 @@ contexts:
           pop: true
         - include: string-character-escape
   regex:
-    - match: '(?<=[=(:,\[?+!]|return|case|=>|&&|\|\||\*\/)\s*(/)(?![/*])(?=(?:[^/\\\[]|\\.|\[([^\]\\]|\\.)+\])+/(?![/*])[gimy]*(?!\s*[a-zA-Z0-9_$]))'
+    - match: '(?<=[=(:,\[?+!]|return|case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/(?![\/*])[gimuy]*(?!\s*[a-zA-Z0-9_$]))'
       captures:
         1: punctuation.definition.string.begin.tsx
       push:
@@ -1577,7 +1734,7 @@ contexts:
             2: keyword.other.tsx
           pop: true
         - include: regexp
-    - match: '(?<![_$[:alnum:]])/(?![/*])(?=(?:[^/\\\[]|\\.|\[([^\]\\]|\\.)+\])+/(?![/*])[gimy]*(?!\s*[a-zA-Z0-9_$]))'
+    - match: '(?<![_$[:alnum:])])\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/(?![\/*])[gimuy]*(?!\s*[a-zA-Z0-9_$]))'
       captures:
         0: punctuation.definition.string.begin.tsx
       push:
@@ -1591,7 +1748,7 @@ contexts:
   regex-character-class:
     - match: '\\[wWsSdDtrnvf]|\.'
       scope: constant.other.character-class.regexp
-    - match: '\\([0-7]{3}|x\h\h|u\h\h\h\h)'
+    - match: '\\([0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4})'
       scope: constant.character.numeric.regexp
     - match: '\\c[A-Z]'
       scope: constant.character.control.regexp
@@ -1622,7 +1779,7 @@ contexts:
     - match: \((\?:)?
       captures:
         0: punctuation.definition.group.regexp
-        1: punctuation.definition.group.capture.regexp
+        1: punctuation.definition.group.no-capture.regexp
       push:
         - meta_scope: meta.group.regexp
         - match: \)
@@ -1640,7 +1797,7 @@ contexts:
           captures:
             1: punctuation.definition.character-class.regexp
           pop: true
-        - match: '(?:.|(\\(?:[0-7]{3}|x\h\h|u\h\h\h\h))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x\h\h|u\h\h\h\h))|(\\c[A-Z])|(\\.))'
+        - match: '(?:.|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))'
           scope: constant.other.character-class.range.regexp
           captures:
             1: constant.character.numeric.regexp
@@ -1652,64 +1809,67 @@ contexts:
         - include: regex-character-class
     - include: regex-character-class
   return-type:
+    - match: (?<=\))\s*(:)(?=\s*\S)
+      captures:
+        1: keyword.operator.type.annotation.tsx
+      push:
+        - meta_scope: meta.return.type.tsx
+        - match: "(?<![:|&])(?=$|^|[{};,]|//)"
+          pop: true
+        - include: return-type-core
     - match: (?<=\))\s*(:)
       captures:
         1: keyword.operator.type.annotation.tsx
       push:
         - meta_scope: meta.return.type.tsx
-        - match: "(?<!:)((?=$)|(?=[{};,]|//))"
+        - match: '(?<![:|&])((?=[{};,]|//|^\s*$)|((?<=\S)(?=\s*$)))'
           pop: true
-        - include: comment
-        - match: '(?<=:)\s*(\{)'
-          captures:
-            1: punctuation.definition.block.tsx
-          push:
-            - meta_scope: meta.object.type.tsx
-            - match: '\}'
-              captures:
-                0: punctuation.definition.block.tsx
-              pop: true
-            - include: type-object-members
-        - include: type-predicate-operator
-        - include: type
+        - include: return-type-core
+  return-type-core:
+    - include: comment
+    - match: '(?<=[:|&])(?=\s*\{)'
+      push:
+        - match: '(?<=\})'
+          pop: true
+        - include: type-object
+    - include: type-predicate-operator
+    - include: type
   statements:
     - include: string
     - include: template
     - include: comment
     - include: declaration
-    - include: switch-statement
-    - include: for-loop
-    - include: after-operator-block
-    - include: decl-block
     - include: control-statement
+    - include: after-operator-block-as-object-literal
+    - include: decl-block
     - include: expression
     - include: punctuation-semicolon
   string:
     - include: qstring-single
     - include: qstring-double
   string-character-escape:
-    - match: '\\(x\h{2}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)'
+    - match: '\\(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)'
       scope: constant.character.escape.tsx
   super-literal:
-    - match: (?<!\.|\$)\bsuper\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))super\b(?!\$)'
       scope: variable.language.super.tsx
   support-objects:
-    - match: (?<!\.|\$)\b(arguments)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(arguments)\b(?!\$)'
       scope: variable.language.arguments.tsx
     - match: |-
-        (?x)(?<!\.|\$)\b(Array|ArrayBuffer|Atomics|Boolean|DataView|Date|Float32Array|Float64Array|Function|Generator
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Array|ArrayBuffer|Atomics|Boolean|DataView|Date|Float32Array|Float64Array|Function|Generator
         |GeneratorFunction|Int8Array|Int16Array|Int32Array|Intl|Map|Number|Object|Promise|Proxy
         |Reflect|RegExp|Set|SharedArrayBuffer|SIMD|String|Symbol|TypedArray
         |Uint8Array|Uint16Array|Uint32Array|Uint8ClampedArray|WeakMap|WeakSet)\b(?!\$)
       scope: support.class.builtin.tsx
-    - match: (?<!\.|\$)\b((Eval|Internal|Range|Reference|Syntax|Type|URI)?Error)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))((Eval|Internal|Range|Reference|Syntax|Type|URI)?Error)\b(?!\$)'
       scope: support.class.error.tsx
     - match: |-
-        (?x)(?<!\.|\$)\b(clear(Interval|Timeout)|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(clear(Interval|Timeout)|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|
         isFinite|isNaN|parseFloat|parseInt|require|set(Interval|Timeout)|super|unescape|uneval)(?=\s*\()
       scope: support.function.tsx
     - match: |-
-        (?x)(?<!\.|\$)\b(Math)(?:\s*(\.)\s*(?:
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Math)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?:
         (abs|acos|acosh|asin|asinh|atan|atan2|atanh|cbrt|ceil|clz32|cos|cosh|exp|
         expm1|floor|fround|hypot|imul|log|log10|log1p|log2|max|min|pow|random|
         round|sign|sin|sinh|sqrt|tan|tanh|trunc)
@@ -1718,32 +1878,36 @@ contexts:
       captures:
         1: support.constant.math.tsx
         2: punctuation.accessor.tsx
-        3: support.function.math.tsx
-        4: support.constant.property.math.tsx
+        3: punctuation.accessor.optional.tsx
+        4: support.function.math.tsx
+        5: support.constant.property.math.tsx
     - match: |-
-        (?x)(?<!\.|\$)\b(console)(?:\s*(\.)\s*(
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(console)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(
         assert|clear|count|debug|dir|error|group|groupCollapsed|groupEnd|info|log
         |profile|profileEnd|table|time|timeEnd|timeStamp|trace|warn))?\b(?!\$)
       captures:
         1: support.class.console.tsx
         2: punctuation.accessor.tsx
-        3: support.function.console.tsx
-    - match: (?<!\.|\$)\b(JSON)(?:\s*(\.)\s*(parse|stringify))?\b(?!\$)
+        3: punctuation.accessor.optional.tsx
+        4: support.function.console.tsx
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(JSON)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(parse|stringify))?\b(?!\$)'
       captures:
         1: support.constant.json.tsx
         2: punctuation.accessor.tsx
-        3: support.function.json.tsx
+        3: punctuation.accessor.optional.tsx
+        4: support.function.json.tsx
     - match: |-
-        (?x) (\.) \s* (?:
+        (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:
         (constructor|length|prototype|__proto__)
         |
         (EPSILON|MAX_SAFE_INTEGER|MAX_VALUE|MIN_SAFE_INTEGER|MIN_VALUE|NEGATIVE_INFINITY|POSITIVE_INFINITY))\b(?!\$)
       captures:
         1: punctuation.accessor.tsx
-        2: support.variable.property.tsx
-        3: support.constant.tsx
+        2: punctuation.accessor.optional.tsx
+        3: support.variable.property.tsx
+        4: support.constant.tsx
     - match: |-
-        (?x) (?<!\.|\$) \b (?:
+        (?x) (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.)) \b (?:
         (document|event|navigator|performance|screen|window)
         |
         (AnalyserNode|ArrayBufferView|Attr|AudioBuffer|AudioBufferSourceNode|AudioContext|AudioDestinationNode|AudioListener
@@ -1809,7 +1973,7 @@ contexts:
         1: support.variable.dom.tsx
         2: support.class.dom.tsx
     - match: |-
-        (?x) (\.) \s* (?:
+        (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:
         (ATTRIBUTE_NODE|CDATA_SECTION_NODE|COMMENT_NODE|DOCUMENT_FRAGMENT_NODE|DOCUMENT_NODE|DOCUMENT_TYPE_NODE
         |DOMSTRING_SIZE_ERR|ELEMENT_NODE|ENTITY_NODE|ENTITY_REFERENCE_NODE|HIERARCHY_REQUEST_ERR|INDEX_SIZE_ERR
         |INUSE_ATTRIBUTE_ERR|INVALID_CHARACTER_ERR|NO_DATA_ALLOWED_ERR|NO_MODIFICATION_ALLOWED_ERR|NOT_FOUND_ERR
@@ -1840,17 +2004,18 @@ contexts:
         |siblingBelow|size|source|specified|standby|start|status|statusbar|statusText|style|styleSheets|suffixes|summary
         |systemId|systemLanguage|tagName|tags|target|tBodies|text|textAlign|textDecoration|textIndent|textTransform|tFoot|tHead
         |title|toolbar|top|type|undefined|uniqueID|updateInterval|URL|URLUnencoded|useMap|userAgent|userLanguage|userProfile
-        |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<([^<>]|\<[^<>]+\>)+>\s*)?\()
+        |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{[^\{\}]*\})|(\([^\(\)]*\))|(\[[^\[\]]*\]))([^=<>]|=[^<])*\>)*>\s*)?\()
       captures:
         1: punctuation.accessor.tsx
-        2: support.constant.dom.tsx
-        3: support.variable.property.dom.tsx
+        2: punctuation.accessor.optional.tsx
+        3: support.constant.dom.tsx
+        4: support.variable.property.dom.tsx
     - match: |-
-        (?x)(?<!\.|\$)\b(Buffer|EventEmitter|Server|Pipe|Socket|REPLServer|ReadStream|WriteStream|Stream
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Buffer|EventEmitter|Server|Pipe|Socket|REPLServer|ReadStream|WriteStream|Stream
         |Inflate|Deflate|InflateRaw|DeflateRaw|GZip|GUnzip|Unzip|Zip)\b(?!\$)
       scope: support.class.node.tsx
     - match: |-
-        (?x)(?<!\.|\$)\b(process)(?:(\.)(?:
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(process)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?:
           (arch|argv|config|connected|env|execArgv|execPath|exitCode|mainModule|pid|platform|release|stderr|stdin|stdout|title|version|versions)
           |
           (abort|chdir|cwd|disconnect|exit|[sg]ete?[gu]id|send|[sg]etgroups|initgroups|kill|memoryUsage|nextTick|umask|uptime|hrtime)
@@ -1858,18 +2023,20 @@ contexts:
       captures:
         1: support.variable.object.process.tsx
         2: punctuation.accessor.tsx
-        3: support.variable.property.process.tsx
-        4: support.function.process.tsx
-    - match: (?<!\.|\$)\b(?:(exports)|(module)(?:(\.)(exports|id|filename|loaded|parent|children))?)\b(?!\$)
+        3: punctuation.accessor.optional.tsx
+        4: support.variable.property.process.tsx
+        5: support.function.process.tsx
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(exports)|(module)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(exports|id|filename|loaded|parent|children))?)\b(?!\$)'
       captures:
         1: support.type.object.module.tsx
         2: support.type.object.module.tsx
         3: punctuation.accessor.tsx
-        4: support.type.object.module.tsx
-    - match: (?<!\.|\$)\b(global|GLOBAL|root|__dirname|__filename)\b(?!\$)
+        4: punctuation.accessor.optional.tsx
+        5: support.type.object.module.tsx
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(global|GLOBAL|root|__dirname|__filename)\b(?!\$)'
       scope: support.variable.object.node.tsx
     - match: |-
-        (?x) (\.) \s*
+        (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s*
         (?:
          (on(?:Rowsinserted|Rowsdelete|Rowenter|Rowexit|Resize|Resizestart|Resizeend|Reset|
            Readystatechange|Mouseout|Mouseover|Mousedown|Mouseup|Mousemove|
@@ -1946,41 +2113,47 @@ contexts:
         )(?=\s*\()
       captures:
         1: punctuation.accessor.tsx
-        2: support.function.event-handler.tsx
-        3: support.function.tsx
-        4: support.function.dom.tsx
-  switch-block:
-    - match: '\{'
-      captures:
-        0: punctuation.definition.block.tsx
-      push:
-        - meta_scope: switch-block.expr.tsx
-        - match: '(?=\})'
-          pop: true
-        - include: case-clause
-        - include: statements
-  switch-expression:
-    - match: (?<!\.|\$)\b(switch)\s*(\()
-      captures:
-        1: keyword.control.switch.tsx
-        2: meta.brace.round.tsx
-      push:
-        - meta_scope: switch-expression.expr.tsx
-        - match: \)
-          captures:
-            0: meta.brace.round.tsx
-          pop: true
-        - include: expression
+        2: punctuation.accessor.optional.tsx
+        3: support.function.event-handler.tsx
+        4: support.function.tsx
+        5: support.function.dom.tsx
   switch-statement:
-    - match: (?<!\.|\$)(?=\bswitch\s*\()
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bswitch\s*\()'
       push:
         - meta_scope: switch-statement.expr.tsx
         - match: '\}'
           captures:
             0: punctuation.definition.block.tsx
           pop: true
-        - include: switch-expression
-        - include: switch-block
+        - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(switch)\s*(\()'
+          captures:
+            1: keyword.control.switch.tsx
+            2: meta.brace.round.tsx
+          push:
+            - meta_scope: switch-expression.expr.tsx
+            - match: \)
+              captures:
+                0: meta.brace.round.tsx
+              pop: true
+            - include: expression
+        - match: '\{'
+          captures:
+            0: punctuation.definition.block.tsx
+          push:
+            - meta_scope: switch-block.expr.tsx
+            - match: '(?=\})'
+              pop: true
+            - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default(?=:))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+              captures:
+                1: keyword.control.switch.tsx
+              push:
+                - meta_scope: case-clause.expr.tsx
+                - match: ":"
+                  captures:
+                    0: punctuation.definition.section.case-statement.tsx
+                  pop: true
+                - include: expression
+            - include: statements
   template:
     - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"
       captures:
@@ -2000,15 +2173,16 @@ contexts:
         0: punctuation.definition.template-expression.begin.tsx
       push:
         - meta_scope: meta.template.expression.tsx
+        - meta_content_scope: meta.embedded.line.tsx
         - match: '\}'
           captures:
             0: punctuation.definition.template-expression.end.tsx
           pop: true
         - include: expression
   ternary-expression:
-    - match: (\?)
+    - match: '(?!\?\.\s*[^[:digit:]])(\?)'
       captures:
-        0: keyword.operator.ternary.tsx
+        1: keyword.operator.ternary.tsx
       push:
         - match: (:)
           captures:
@@ -2016,7 +2190,7 @@ contexts:
           pop: true
         - include: expression
   this-literal:
-    - match: (?<!\.|\$)\bthis\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))this\b(?!\$)'
       scope: variable.language.this.tsx
   type:
     - include: comment
@@ -2032,28 +2206,15 @@ contexts:
     - include: type-paren-or-function-parameters
     - include: type-function-return-type
     - include: type-name
-  type-annotation:
-    - match: ":"
-      captures:
-        0: keyword.operator.type.annotation.tsx
-      push:
-        - meta_scope: meta.type.annotation.tsx
-        - match: '(?=$|[,);\}\]]|//)|(?==[^>])|(?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)'
-          pop: true
-        - include: comment
-        - include: type
-  type-builtin-literals:
-    - match: (?<!\.|\$)\b(this|true|false|undefined|null|object)\b(?!\$)
-      scope: support.type.builtin.tsx
-  type-declaration:
-    - match: '(?<!\.|\$)(?:(\bexport)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s*'
+  type-alias-declaration:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s*'
       captures:
         1: keyword.control.export.tsx
         2: storage.type.type.tsx
-        3: entity.name.type.tsx
+        3: entity.name.type.alias.tsx
       push:
         - meta_scope: meta.type.declaration.tsx
-        - match: '(?=[};]|\bvar\b|\blet\b|\bconst\b|\btype\b|\bfunction\b|\bclass\b|\binterface\b|\bnamespace\b|\bmodule\b|\bimport\b|\benum\b|\bdeclare\b|\bexport\b|\babstract\b|\basync\b)'
+        - match: '(?=[};]|\babstract\b|\basync\b|\bclass\b|\bconst\b|\bdeclare\b|\benum\b|\bexport\b|\bfunction\b|\bimport\b|\binterface\b|\blet\b|\bmodule\b|\bnamespace\b|\btype\b|\bvar\b)'
           pop: true
         - include: comment
         - include: type-parameters
@@ -2061,12 +2222,32 @@ contexts:
         - match: (=)\s*
           captures:
             1: keyword.operator.assignment.tsx
+  type-annotation:
+    - match: (:)(?=\s*\S)
+      captures:
+        1: keyword.operator.type.annotation.tsx
+      push:
+        - meta_scope: meta.type.annotation.tsx
+        - match: '(?<![:|&])((?=$|^|[,);\}\]]|//)|(?==[^>])|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))'
+          pop: true
+        - include: type
+    - match: (:)
+      captures:
+        1: keyword.operator.type.annotation.tsx
+      push:
+        - meta_scope: meta.type.annotation.tsx
+        - match: '(?<![:|&])((?=[,);\}\]]|//)|(?==[^>])|(?=^\s*$)|((?<=\S)(?=\s*$))|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))'
+          pop: true
+        - include: type
+  type-builtin-literals:
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(this|true|false|undefined|null|object)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+      scope: support.type.builtin.tsx
   type-fn-type-parameters:
-    - match: (?<!\.|\$)\b(new)\b(?=\s*\<)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b(?=\s*\<)'
       scope: meta.type.constructor.tsx
       captures:
         1: keyword.control.new.tsx
-    - match: (?<!\.|\$)\b(new)\b\s*(?=\()
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b\s*(?=\()'
       captures:
         1: keyword.control.new.tsx
       push:
@@ -2093,31 +2274,37 @@ contexts:
           pop: true
         - include: function-parameters
   type-function-return-type:
+    - match: (=>)(?=\s*\S)
+      captures:
+        1: storage.type.function.arrow.tsx
+      push:
+        - meta_scope: meta.type.function.return.tsx
+        - match: '(?<!=>)(?<![|&])(?=[,\]\)\{\}=;>]|//|$)'
+          pop: true
+        - include: type-function-return-type-core
     - match: "=>"
       captures:
         0: storage.type.function.arrow.tsx
       push:
         - meta_scope: meta.type.function.return.tsx
-        - match: '(?<!=>)(?=[,\]\)\{\}=;>]|//|$)'
+        - match: '(?<!=>)(?<![|&])((?=[,\]\)\{\}=;>]|//|^\s*$)|((?<=\S)(?=\s*$)))'
           pop: true
-        - include: comment
-        - match: '(?<==>)\s*(\{)'
-          captures:
-            1: punctuation.definition.block.tsx
-          push:
-            - meta_scope: meta.object.type.tsx
-            - match: '\}'
-              captures:
-                0: punctuation.definition.block.tsx
-              pop: true
-            - include: type-object-members
-        - include: type-predicate-operator
-        - include: type
+        - include: type-function-return-type-core
+  type-function-return-type-core:
+    - include: comment
+    - match: '(?<==>)(?=\s*\{)'
+      push:
+        - match: '(?<=\})'
+          pop: true
+        - include: type-object
+    - include: type-predicate-operator
+    - include: type
   type-name:
-    - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(\.)'
+    - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))'
       captures:
         1: entity.name.type.module.tsx
         2: punctuation.accessor.tsx
+        3: punctuation.accessor.optional.tsx
     - match: "[_$[:alpha:]][_$[:alnum:]]*"
       scope: entity.name.type.tsx
   type-object:
@@ -2130,29 +2317,38 @@ contexts:
           captures:
             0: punctuation.definition.block.tsx
           pop: true
-        - include: type-object-members
-  type-object-members:
-    - include: comment
-    - include: method-declaration
-    - include: indexer-declaration
-    - include: indexer-mapped-type-declaration
-    - include: field-declaration
-    - include: type-annotation
-    - match: \.\.\.
-      captures:
-        0: keyword.operator.spread.tsx
-      push:
-        - match: '(?=\}|;|,|$)|(?<=\})'
-          pop: true
+        - include: comment
+        - include: method-declaration
+        - include: indexer-declaration
+        - include: indexer-mapped-type-declaration
+        - include: field-declaration
+        - include: type-annotation
+        - match: \.\.\.
+          captures:
+            0: keyword.operator.spread.tsx
+          push:
+            - match: '(?=\}|;|,|$)|(?<=\})'
+              pop: true
+            - include: type
+        - include: punctuation-comma
+        - include: punctuation-semicolon
         - include: type
-    - include: punctuation-comma
-    - include: punctuation-semicolon
-    - include: type
   type-operators:
     - include: typeof-operator
+    - match: '([&|])(?=\s*\{)'
+      captures:
+        0: keyword.operator.type.tsx
+      push:
+        - match: '(?<=\})'
+          pop: true
+        - include: type-object
     - match: "[&|]"
-      scope: keyword.operator.type.tsx
-    - match: (?<!\.|\$)\bkeyof\b(?!\$)
+      captures:
+        0: keyword.operator.type.tsx
+      push:
+        - match: (?=\S)
+          pop: true
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))keyof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.keyof.tsx
   type-parameters:
     - match: (<)
@@ -2160,12 +2356,12 @@ contexts:
         1: punctuation.definition.typeparameters.begin.tsx
       push:
         - meta_scope: meta.type.parameters.tsx
-        - match: (?=$)|(>)
+        - match: (>)
           captures:
             1: punctuation.definition.typeparameters.end.tsx
           pop: true
         - include: comment
-        - match: (?<!\.|\$)\b(extends)\b(?!\$)
+        - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(extends)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
           scope: storage.modifier.tsx
         - match: \=(?!>)
           scope: keyword.operator.assignment.tsx
@@ -2184,10 +2380,10 @@ contexts:
         - include: type
         - include: function-parameters
   type-predicate-operator:
-    - match: (?<!\.|\$)\bis\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))is(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.is.tsx
   type-primitive:
-    - match: (?<!\.|\$)\b(string|number|boolean|symbol|any|void|never)\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(string|number|boolean|symbol|any|void|never)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: support.type.primitive.tsx
   type-tuple:
     - match: '\['
@@ -2202,54 +2398,83 @@ contexts:
         - include: type
         - include: punctuation-comma
   typeof-operator:
-    - match: (?<!\.|\$)\btypeof\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))typeof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: keyword.operator.expression.typeof.tsx
   undefined-literal:
-    - match: (?<!\.|\$)\bundefined\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))undefined(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       scope: constant.language.undefined.tsx
   var-expr:
-    - match: (?<!\.|\$)(?:(\bexport)\s+)?\b(var|let|const(?!\s+enum\b))\b(?!\$)
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(var|let|const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
       captures:
         1: keyword.control.export.tsx
         2: storage.type.tsx
       push:
         - meta_scope: meta.var.expr.tsx
-        - match: '(?=$|;|}|(\s+(of|in)\s+))'
+        - match: '(?=$|^|;|}|(\s+(of|in)\s+))'
           pop: true
         - include: destructuring-variable
         - include: var-single-variable
         - include: variable-initializer
         - include: comment
+        - match: (,)\s*(?!\S)
+          captures:
+            1: punctuation.separator.comma.tsx
+          push:
+            - match: '(?<!,)((?==|;|}|(\s+(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$))'
+              pop: true
+            - include: comment
+            - include: destructuring-variable
+            - include: var-single-variable
+            - include: punctuation-comma
         - include: punctuation-comma
   var-single-variable:
     - match: |-
         (?x)([_$[:alpha:]][_$[:alnum:]]*)(?=\s*
-          (=\s*(
-            (async\s+) |
-            (function\s*[(<]) |
+        # function assignment |
+        (=\s*(
+          ((async\s+)?(
+            (function\s*[(<*]) |
             (function\s+) |
-            ([_$[:alpha:]][_$[:alnum:]]*\s*=>) |
-            ([(]\s*(([)]\s*:)|([_$[:alpha:]][_$[:alnum:]]*\s*:)|(\.\.\.) )) |
-            ([<]\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s*[^=>])|(\s*[,]))) |
-            ((<([^<>]|\<[^<>]+\>)+>\s*)?\(([^()]|\([^()]*\))*\)(\s*:\s*(.)*)?\s*=>))
-          ) |
-          (:\s*(
-            (<) |
-            ([(]\s*(
-              ([)]) |
-              (\.\.\.) |
-              ([_$[:alnum:]]+\s*(
-                ([:,?=])|
-                ([)]\s*=>)
-              ))
-            )))
+            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
+          )) |
+          ((async\s*)?(
+            # sure shot arrow functions even if => is on new line
+        (
+          [(]\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*[^()]*)?\))*)?\)                          # parameteres
+          (\s*:\s*([^<>\(\)]|\<[^<>]+\>|\([^\(\)]+\))+)?                                # return type
+          \s*=>                                                                         # arrow operator
         )
+          ))
+        )) |
+        # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
+        (:\s*(
+          (<) |
+          ([(]\s*(
+            ([)]) |
+            (\.\.\.) |
+            ([_$[:alnum:]]+\s*(
+              ([:,?=])|
+              ([)]\s*=>)
+            ))
+          ))
+        )))
       captures:
         1: meta.definition.variable.tsx entity.name.function.tsx
       push:
         - meta_scope: meta.var-single-variable.expr.tsx
-        - match: '(?=$|[;,=}]|(\s+(of|in)\s+))'
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
           pop: true
         - include: var-single-variable-type-annotation
     - match: "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])"
@@ -2257,7 +2482,7 @@ contexts:
         1: meta.definition.variable.tsx variable.other.constant.tsx
       push:
         - meta_scope: meta.var-single-variable.expr.tsx
-        - match: '(?=$|[;,=}]|(\s+(of|in)\s+))'
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
           pop: true
         - include: var-single-variable-type-annotation
     - match: "([_$[:alpha:]][_$[:alnum:]]*)"
@@ -2265,7 +2490,7 @@ contexts:
         1: meta.definition.variable.tsx variable.other.readwrite.tsx
       push:
         - meta_scope: meta.var-single-variable.expr.tsx
-        - match: '(?=$|[;,=}]|(\s+(of|in)\s+))'
+        - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'
           pop: true
         - include: var-single-variable-type-annotation
   var-single-variable-type-annotation:
@@ -2277,13 +2502,13 @@ contexts:
       captures:
         1: keyword.operator.assignment.tsx
       push:
-        - match: '(?=$|[,);}\]])'
+        - match: '(?=$|^|[,);}\]])'
           pop: true
         - include: expression
     - match: (?<!=|!)(=)(?!=)
       captures:
         1: keyword.operator.assignment.tsx
       push:
-        - match: '(?=[,);}\]])|(?=^\s*$)'
+        - match: '(?=[,);}\]])|(?=^\s*$)|(?<=\S)(?<!=)(?=\s*$)'
           pop: true
         - include: expression
diff --git a/sublime_syntaxes/newlines.packdump b/sublime_syntaxes/newlines.packdump
index d9e99dd..96c151f 100644
Binary files a/sublime_syntaxes/newlines.packdump and b/sublime_syntaxes/newlines.packdump differ
diff --git a/sublime_syntaxes/nonewlines.packdump b/sublime_syntaxes/nonewlines.packdump
index c327dd7..37723b0 100644
Binary files a/sublime_syntaxes/nonewlines.packdump and b/sublime_syntaxes/nonewlines.packdump differ