github-linguist 4.8.5 → 4.8.6

data/grammars/source.elm.json

@@ -21,13 +21,16 @@
       "name": "constant.language.unit.elm"
     },
     {
-      "begin": "^\\b(module)\\s+",
+      "begin": "^\\b((effect|port)\\s+)?(module)\\s+",
       "beginCaptures": {
         "1": {
           "name": "keyword.other.elm"
+        },
+        "3": {
+          "name": "keyword.other.elm"
         }
       },
-      "end": "\\b(where)\\b",
+      "end": "$|;",
       "endCaptures": {
         "1": {
           "name": "keyword.other.elm"
@@ -38,9 +41,31 @@
         {
           "include": "#module_name"
         },
+        {
+          "begin": "(where)\\s*\\{",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.elm"
+            }
+          },
+          "end": "\\}",
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        {
+          "match": "(exposing)",
+          "name": "keyword.other.elm"
+        },
         {
           "include": "#module_exports"
         },
+        {
+          "match": "(where)",
+          "name": "keyword.other.elm"
+        },
         {
           "match": "[a-z]+",
           "name": "invalid"

data/grammars/source.fsharp.json

@@ -315,7 +315,7 @@
         {
           "name": "string.quoted.literal.fsharp",
           "begin": "(?=[^\\\\])(@\")",
-          "end": "(\")",
+          "end": "(\")(?!\")",
           "beginCaptures": {
             "1": {
               "name": "punctuation.definition.string.begin.fsharp"

data/grammars/source.glsl.json

@@ -25,6 +25,37 @@
   "keyEquivalent": "^~G",
   "name": "GLSL",
   "patterns": [
+    {
+      "include": "#literal"
+    },
+    {
+      "include": "#operator"
+    },
+    {
+      "begin": "/\\*",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.comment.block.begin.glsl"
+        }
+      },
+      "end": "\\*/",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.comment.block.end.glsl"
+        }
+      },
+      "name": "comment.block.glsl"
+    },
+    {
+      "begin": "//",
+      "beginCapture": {
+        "0": {
+          "name": "punctuation.definition.comment.glsl"
+        }
+      },
+      "end": "\\n",
+      "name": "comment.line.double-slash.glsl"
+    },
     {
       "match": "^\\s*#\\s*(define|undef|if|ifdef|ifndef|else|elif|endif|error|pragma|extension|version|line)\\b",
       "name": "keyword.directive.preprocessor.glsl"
@@ -60,15 +91,74 @@
     {
       "match": "\\b(abs|acos|all|any|asin|atan|ceil|clamp|cos|cross|degrees|dFdx|dFdy|distance|dot|equal|exp|exp2|faceforward|floor|fract|ftransform|fwidth|greaterThan|greaterThanEqual|inversesqrt|length|lessThan|lessThanEqual|log|log2|matrixCompMult|max|min|mix|mod|noise[1-4]|normalize|not|notEqual|outerProduct|pow|radians|reflect|refract|shadow1D|shadow1DLod|shadow1DProj|shadow1DProjLod|shadow2D|shadow2DLod|shadow2DProj|shadow2DProjLod|sign|sin|smoothstep|sqrt|step|tan|texture1D|texture1DLod|texture1DProj|texture1DProjLod|texture2D|texture2DLod|texture2DProj|texture2DProjLod|texture3D|texture3DLod|texture3DProj|texture3DProjLod|textureCube|textureCubeLod|transpose)\\b",
       "name": "support.function.glsl"
+    }
+  ],
+  "repository": {
+    "literal": {
+      "patterns": [
+        {
+          "include": "#numeric-literal"
+        }
+      ]
     },
-    {
-      "match": "\\b(asm|enum|extern|goto|inline|long|short|sizeof|static|typedef|union|unsigned)\\b",
-      "name": "invalid.illegal.glsl"
+    "operator": {
+      "patterns": [
+        {
+          "include": "#arithmetic-operator"
+        },
+        {
+          "include": "#increment-decrement-operator"
+        },
+        {
+          "include": "#bitwise-operator"
+        },
+        {
+          "include": "#comparative-operator"
+        },
+        {
+          "include": "#assignment-operator"
+        },
+        {
+          "include": "#logical-operator"
+        },
+        {
+          "include": "#ternary-operator"
+        }
+      ]
     },
-    {
-      "include": "source.c"
+    "numeric-literal": {
+      "match": "\\b([0-9][0-9_]*)(\\.([0-9][0-9_]*))?([eE][+/-]?([0-9][0-9_]*))?\\b",
+      "name": "constant.numeric.glsl"
+    },
+    "arithmetic-operator": {
+      "match": "(?<![/=\\-+!*%<>&|\\^~.])(\\+|\\-|\\*|\\/|\\%)(?![/=\\-+!*%<>&|^~.])",
+      "name": "keyword.operator.arithmetic.glsl"
+    },
+    "increment-decrement-operator": {
+      "match": "(?<![/=\\-+!*%<>&|\\^~.])(\\+\\+|\\-\\-)(?![/=\\-+!*%<>&|^~.])",
+      "name": "keyword.operator.increment-or-decrement.glsl"
+    },
+    "bitwise-operator": {
+      "match": "(?<![/=\\-+!*%<>&|\\^~.])(~|&|\\||\\^|<<|>>)(?![/=\\-+!*%<>&|^~.])",
+      "name": "keyword.operator.bitwise.glsl"
+    },
+    "assignment-operator": {
+      "match": "(?<![/=\\-+!*%<>&|\\^~.])(\\+|\\-|\\*|\\%|\\/|<<|>>|&|\\^|\\|)?=(?![/=\\-+!*%<>&|^~.])",
+      "name": "keyword.operator.assignment.glsl"
+    },
+    "comparative-operator": {
+      "match": "(?<![/=\\-+!*%<>&|\\^~.])((=|!)=|(<|>)=?)(?![/=\\-+!*%<>&|^~.])",
+      "name": "keyword.operator.comparative.glsl"
+    },
+    "logical-operator": {
+      "match": "(?<![/=\\-+!*%<>&|\\^~.])(!|&&|\\|\\||\\^\\^)(?![/=\\-+!*%<>&|^~.])",
+      "name": "keyword.operator.arithmetic.glsl"
+    },
+    "ternary-operator": {
+      "match": "(\\?|:)",
+      "name": "keyword.operator.ternary.glsl"
     }
-  ],
+  },
   "scopeName": "source.glsl",
   "uuid": "D0FD1B52-F137-4FBA-A148-B8A893CD948C"
 }

data/grammars/source.js.jsx.json

@@ -24,13 +24,7 @@
           "include": "#ignore-long-lines"
         },
         {
-          "include": "#flowtype-declare"
-        },
-        {
-          "include": "#flowtype-type-aliases"
-        },
-        {
-          "include": "#flowtype-interface"
+          "include": "#flowtype-keywords"
         },
         {
           "include": "#literal-function-labels"
@@ -84,6 +78,9 @@
         {
           "include": "#literal-arrow-function"
         },
+        {
+          "include": "#literal-method-alternate"
+        },
         {
           "include": "#literal-prototype",
           "comment": "after literal-function, which includes some prototype strings"
@@ -108,7 +105,8 @@
           "include": "#literal-language-variable"
         },
         {
-          "include": "#literal-object"
+          "include": "#literal-object",
+          "comment": "before literal-module as it traps default {"
         },
         {
           "include": "#literal-module"
@@ -187,7 +185,7 @@
         {
           "comment": "e.g. 'play': function(arg1, arg2) { }",
           "name": "meta.function.json.js",
-          "begin": "(?<=^|{|,)\\s*+(('|\\\")(\\b[_$a-zA-Z][$\\w]*)(\\k<2>))\\s*+(:)\\s*+(async)?\\s*+((?<!\\.)\\bfunction\\b)\\s*(\\*\\s*)?\\s*(?=\\(|<)",
+          "begin": "(?<=^|{|,)\\s*+(('|\\\")([^\"']*)(\\k<-3>))\\s*+(:)\\s*+(async)?\\s*+((?<!\\.)\\bfunction\\b)\\s*(\\*\\s*)?\\s*(?=\\(|<)",
           "end": "(?=\\{)",
           "applyEndPatternLast": 1,
           "beginCaptures": {
@@ -229,7 +227,7 @@
         {
           "comment": "e.g. play: async <T>(args) => { }",
           "name": "meta.function.json.arrow.js",
-          "begin": "(?<=^|{|,)\\s*+(\\b[_$a-zA-Z][$\\w]*)\\s*+(:)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*[x0-9A-Fa-f]+))*\\s*=>)",
+          "begin": "(?<=^|{|,)\\s*+(\\b[_$a-zA-Z][$\\w]*)\\s*+(:)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*:(\\s*+(&|\\|)?(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*[x0-9A-Fa-f]+))*+)*\\s*=>)",
           "end": "\\s*(=>)",
           "beginCaptures": {
             "1": {
@@ -256,7 +254,7 @@
         {
           "comment": "e.g. play: arg => { }",
           "name": "meta.function.json.arrow.js",
-          "begin": "(?<=^|{|,)\\s*+(\\b[_$a-zA-Z][$\\w]*)\\s*+(:)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+([_$a-zA-Z][$\\w]*)\\s*+(?:\\s*(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
+          "begin": "(?<=^|{|,)\\s*+(\\b[_$a-zA-Z][$\\w]*)\\s*+(:)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+([_$a-zA-Z][$\\w]*)\\s*+(?:\\s*:(\\s*+(&|\\|)?(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*[x0-9A-Fa-f]+))*+)*\\s*=>)",
           "end": "\\s*(=>)",
           "beginCaptures": {
             "1": {
@@ -286,7 +284,7 @@
         {
           "comment": "e.g. 'play': (args) => { }",
           "name": "meta.function.json.arrow.js",
-          "begin": "(?<=^|{|,)\\s*+(('|\\\")(\\b[_$a-zA-Z][$\\w]*)(\\k<2>))\\s*(:)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*+(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\s*+([\"']).*?\\k<-1>(?<!\\\\.))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
+          "begin": "(?<=^|{|,)\\s*+(('|\\\")([^\"']*)(\\k<-3>))\\s*(:)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*:(\\s*+(&|\\|)?(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*[x0-9A-Fa-f]+))*+)*\\s*=>)",
           "end": "\\s*(=>)",
           "applyEndPatternLast": 1,
           "endCaptures": {
@@ -323,7 +321,7 @@
         {
           "comment": "e.g. 'play': arg => { }",
           "name": "meta.function.json.arrow.js",
-          "begin": "(?<=^|{|,)\\s*+(('|\\\")(\\b[_$a-zA-Z][$\\w]*)(\\k<2>))\\s*+(:)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+([_$a-zA-Z][$\\w]*)\\s*+(?:\\s*+(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\s*+([\"']).*?\\k<-1>(?<!\\\\.))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
+          "begin": "(?<=^|{|,)\\s*+(('|\\\")([^\"']*)(\\k<-3>))\\s*+(:)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+([_$a-zA-Z][$\\w]*)\\s*+(?:\\s*:(\\s*+(&|\\|)?(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*[x0-9A-Fa-f]+))*+)*\\s*=>)",
           "end": "\\s*(=>)",
           "beginCaptures": {
             "1": {
@@ -825,69 +823,30 @@
     "literal-keyword-storage": {
       "patterns": [
         {
-          "comment": "flowtype vars with a : to indicate type",
-          "begin": "\\s*+(?<!\\.)\\b(const|let|var)\\b\\s+(?=[$_\\p{L}](?:[$\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}-]*+\\s*+:))",
-          "end": "\\s*((\\;)|(?=\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare)\\b|^\\s*$|}))",
-          "beginCaptures": {
-            "1": {
-              "name": "storage.type.js"
-            }
-          },
-          "endCaptures": {
-            "2": {
-              "name": "punctuation.terminator.statement.js"
-            }
-          },
-          "patterns": [
-            {
-              "include": "#flowtype-variable"
-            }
-          ]
-        },
-        {
-          "comment": "flowtype objects {a,b,{z}} with a : to indicate type",
-          "begin": "\\s*+(?<!\\.)\\b(const|let|var)\\b\\s+(?=(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})\\s*+:)",
-          "end": "\\s*((\\;)|(?=\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare)\\b|^\\s*$|}))",
-          "beginCaptures": {
-            "1": {
-              "name": "storage.type.js"
-            }
-          },
-          "endCaptures": {
-            "2": {
-              "name": "punctuation.terminator.statement.js"
-            }
-          },
-          "patterns": [
-            {
-              "include": "#flowtype-destruct-lhs"
-            }
-          ]
-        },
-        {
-          "comment": "flowtype arrays [a,[b,c]] with a : to indicate type",
-          "begin": "\\s*+(?<!\\.)\\b(const|let|var)\\b\\s+(?=(\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])\\s*+:)",
-          "end": "\\s*((\\;)|(?=\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare)\\b|^\\s*$|}))",
+          "begin": "\\s*+(?<!\\.)\\b(const|let|var)\\b",
+          "end": "\\s*(?=\\;|\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare|interface)\\b|\\)|})",
           "beginCaptures": {
             "1": {
               "name": "storage.type.js"
             }
           },
-          "endCaptures": {
-            "2": {
-              "name": "punctuation.terminator.statement.js"
-            }
-          },
           "patterns": [
             {
-              "include": "#flowtype-destruct-lhs"
+              "comment": "other variables",
+              "begin": "\\s*",
+              "end": "\\s*((,)|(?=(\\;)|\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare|interface)\\b|\\)|}))",
+              "endCaptures": {
+                "2": {
+                  "name": "punctuation.terminator.statement.js"
+                }
+              },
+              "patterns": [
+                {
+                  "include": "#flowtype-variable"
+                }
+              ]
             }
           ]
-        },
-        {
-          "comment": "var statements that done start with a flow indicator",
-          "name": "storage.type.js",
-          "match": "\\s*+(?<!\\.)\\b(const|let|var)\\b"
         }
       ]
     },
@@ -897,7 +856,7 @@
           "comment": "e.g. function play<T>(arg1, arg2) { }",
           "name": "meta.function.js",
           "begin": "\\s*+(?:\\b(async)\\b\\s+)?\\s*+(?:(?<=\\.\\.\\.)|(?<!\\.))(\\bfunction\\b)\\s*+(\\*?)\\s*+([_$a-zA-Z][$\\w]*)?\\s*+(?=\\(|<)",
-          "end": "(?=\\s*+\\{)",
+          "end": "\\s*(?=\\;|{|\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare|interface)\\b|\\)|})",
           "applyEndPatternLast": 1,
           "beginCaptures": {
             "1": {
@@ -923,7 +882,7 @@
           "comment": "e.g. play = function(arg1, arg2) { }",
           "name": "meta.function.js",
           "begin": "\\s*+(\\b[_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(?:(async)\\s+)?\\s*+((?<!\\.)\\bfunction\\b)\\s*+(\\*?)\\s*+([_$a-zA-Z][$\\w]*)?\\s*+(?=\\(|<)",
-          "end": "(?=\\s*+\\{)",
+          "end": "\\s*(?=\\;|{|\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare|interface)\\b|\\)|})",
           "applyEndPatternLast": 1,
           "beginCaptures": {
             "1": {
@@ -955,7 +914,7 @@
           "comment": "e.g. Sound.prototype.play = function(arg1, arg2) { }",
           "name": "meta.prototype.function.js",
           "begin": "\\s*+(\\b_?[A-Z][$\\w]*)?(\\.)(prototype)(\\.)([_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(?:(async)\\s+)?\\s*+((?<!\\.)\\bfunction\\b)\\s*+(\\*?)\\s*+([_$a-zA-Z][$\\w]*)?\\s*+(?=\\(|<)",
-          "end": "(?=\\s*+\\{)",
+          "end": "\\s*(?=\\;|{|\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare|interface)\\b|\\)|})",
           "applyEndPatternLast": 1,
           "beginCaptures": {
             "1": {
@@ -999,7 +958,7 @@
           "comment": "e.g. Sound.play = function(arg1, arg2) { }",
           "name": "meta.function.static.js",
           "begin": "\\s*+(\\b_?[A-Z][$\\w]*)?(\\.)([_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(?:(async)\\s+)?\\s*+((?<!\\.)\\bfunction\\b)\\s*+(\\*?)\\s*+([_$a-zA-Z][$\\w]*)?\\s*+(?=\\(|<)",
-          "end": "(?=\\s*+\\{)",
+          "end": "\\s*(?=\\;|{|\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare|interface)\\b|\\)|})",
           "applyEndPatternLast": 1,
           "beginCaptures": {
             "1": {
@@ -1094,7 +1053,7 @@
       "patterns": [
         {
           "comment": "obj lteral ({ or ,{ or [{ or ={ or return { or default {",
-          "begin": "(?:(?<=\\(|\\[|:)|(?:\\s*(?:(=)|\\b(default)\\b|\\b(return)\\b|(,))))\\s*({)",
+          "begin": "(?:(?<=\\(|\\[)|(?:\\s*(?:(=)|\\b(default)\\b|\\b(return)\\b|(,))))\\s*({)",
           "end": "\\s*+(})",
           "beginCaptures": {
             "1": {
@@ -1216,21 +1175,21 @@
         },
         {
           "name": "meta.function-call.without-arguments.js",
-          "begin": "\\s*+((\\bnew\\b)*)\\s*+([_$a-zA-Z][$\\w]*)\\s*+(?=\\(\\s*+\\))",
-          "end": "\\s*(?<=\\))",
-          "beginCaptures": {
+          "match": "\\s*+((\\bnew\\b)*)\\s*+([_$a-zA-Z][$\\w]*)\\s*+(\\()\\s*+(\\))",
+          "captures": {
             "2": {
               "name": "keyword.operator.js"
             },
             "3": {
               "name": "entity.name.function.js"
+            },
+            "4": {
+              "name": "meta.brace.round.js"
+            },
+            "5": {
+              "name": "meta.brace.round.js"
             }
-          },
-          "patterns": [
-            {
-              "include": "#flowtype-bracketed-parameters"
-            }
-          ]
+          }
         },
         {
           "name": "meta.function-call.without-arguments.js",
@@ -1244,10 +1203,10 @@
           },
           "patterns": [
             {
-              "include": "#flowtype-parse-array"
+              "include": "#square-brackets"
             },
             {
-              "include": "#flowtype-bracketed-parameters"
+              "include": "#round-brackets"
             }
           ]
         },
@@ -1266,7 +1225,7 @@
           },
           "patterns": [
             {
-              "include": "#flowtype-bracketed-parameters"
+              "include": "#round-brackets"
             }
           ]
         },
@@ -1282,10 +1241,10 @@
           },
           "patterns": [
             {
-              "include": "#flowtype-parse-array"
+              "include": "#square-brackets"
             },
             {
-              "include": "#flowtype-bracketed-parameters"
+              "include": "#round-brackets"
             }
           ]
         }
@@ -1421,7 +1380,7 @@
         {
           "comment": "Classes",
           "begin": "\\s*+(?<!\\.)\\b(class)\\s+",
-          "end": "\\s*(})",
+          "end": "\\s*(?<=})",
           "beginCaptures": {
             "0": {
               "name": "meta.class.js"
@@ -1430,11 +1389,6 @@
               "name": "storage.type.class.js"
             }
           },
-          "endCaptures": {
-            "1": {
-              "name": "punctuation.section.class.end.js"
-            }
-          },
           "patterns": [
             {
               "match": "\\s*+\\b(extends)\\b\\s*+",
@@ -1448,42 +1402,30 @@
               }
             },
             {
-              "include": "#flowtype-class-name"
+              "comment": "look for classes names but dont assume uppercase start char",
+              "match": "(?<!\\.)\\s*+([$_\\p{L}](?:[$\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)",
+              "name": "entity.name.class.js"
             },
             {
               "include": "#flowtype-polymorphs"
             },
             {
               "begin": "\\s*+{",
-              "end": "\\s*(?=})",
+              "end": "\\s*(})",
               "contentName": "meta.class.body.js",
               "beginCaptures": {
                 "0": {
                   "name": "punctuation.section.class.begin.js"
                 }
               },
+              "endCaptures": {
+                "1": {
+                  "name": "punctuation.section.class.end.js"
+                }
+              },
               "patterns": [
                 {
-                  "match": "\\s*+\\b(?<!\\.)static\\b(?!\\.)",
-                  "name": "storage.modifier.js"
-                },
-                {
-                  "include": "#literal-method"
-                },
-                {
-                  "include": "#brackets"
-                },
-                {
-                  "include": "#es7-decorators"
-                },
-                {
-                  "include": "#comments"
-                },
-                {
-                  "include": "#flowtype-variable"
-                },
-                {
-                  "include": "#literal-semi-colon"
+                  "include": "#class-body"
                 }
               ]
             },
@@ -1494,6 +1436,50 @@
         }
       ]
     },
+    "class-body": {
+      "patterns": [
+        {
+          "include": "#flowtype-keywords"
+        },
+        {
+          "include": "#literal-method"
+        },
+        {
+          "include": "#brackets"
+        },
+        {
+          "include": "#es7-decorators"
+        },
+        {
+          "include": "#comments"
+        },
+        {
+          "comment": "a line starts with a static, [, name( or a semi-colon anywhere",
+          "begin": "\\s*+(?==[^=>])",
+          "end": "(^\\s*+(?=([$\\w]*\\s*+\\??\\s*+(:|=(?!^==|=>))|\\[|[$\\w]\\s*+\\(|\\bstatic\\b|\\s*++)))|\\s*(;)",
+          "endCaptures": {
+            "4": {
+              "name": "punctuation.terminator.statement.js"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#expression"
+            }
+          ]
+        },
+        {
+          "match": "\\s*+\\b(?<!\\.)static\\b(?!\\.)",
+          "name": "storage.modifier.js"
+        },
+        {
+          "include": "#flowtype-variable"
+        },
+        {
+          "include": "#literal-semi-colon"
+        }
+      ]
+    },
     "literal-method-call": {
       "patterns": [
         {
@@ -1517,8 +1503,10 @@
         },
         {
           "name": "meta.function-call.static.with-arguments.js",
-          "match": "\\s*+(?:(?<=\\.)|\\b)\\s*+([A-Z][$\\w]*)\\s*+(\\.)([_$a-zA-Z][$\\w]*)\\s*+(?=\\()",
-          "captures": {
+          "begin": "\\s*+(?:(?<=\\.)|\\b)\\s*+([A-Z][$\\w]*)\\s*+(\\.)([_$a-zA-Z][$\\w]*)\\s*+(?=\\()",
+          "end": "(?=.)",
+          "applyEndPatternLast": 1,
+          "beginCaptures": {
             "1": {
               "name": "variable.other.class.js"
             },
@@ -1528,7 +1516,12 @@
             "3": {
               "name": "entity.name.function.js"
             }
-          }
+          },
+          "patterns": [
+            {
+              "include": "#round-brackets"
+            }
+          ]
         },
         {
           "name": "meta.function-call.method.without-arguments.js",
@@ -1544,12 +1537,19 @@
         },
         {
           "name": "meta.function-call.method.with-arguments.js",
-          "match": "\\s*+(?<=\\.)([_$a-zA-Z][$\\w]*)\\s*+(?=\\()",
-          "captures": {
+          "begin": "\\s*+(?<=\\.)([_$a-zA-Z][$\\w]*)\\s*+(?=\\()",
+          "end": "(?=.)",
+          "applyEndPatternLast": 1,
+          "beginCaptures": {
             "1": {
               "name": "entity.name.function.js"
             }
-          }
+          },
+          "patterns": [
+            {
+              "include": "#round-brackets"
+            }
+          ]
         }
       ]
     },
@@ -1658,7 +1658,7 @@
         {
           "comment": "e.g. (args) => { }",
           "name": "meta.function.arrow.js",
-          "begin": "\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*+(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(((')((?:[^']|\\\\')*)('))|\\s*+((\")((?:[^\"]|\\\\\")*)(\")))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
+          "begin": "\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*:(\\s*+(&|\\|)?(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*[x0-9A-Fa-f]+))*+)*\\s*=>)",
           "end": "\\s*(=>)",
           "applyEndPatternLast": 1,
           "endCaptures": {
@@ -1680,31 +1680,23 @@
         {
           "comment": "e.g. arg => { }",
           "name": "meta.function.arrow.js",
-          "begin": "\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+([_$a-zA-Z][$\\w]*)\\s*+(?:\\s*+(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(((')((?:[^']|\\\\')*)('))|\\s*+((\")((?:[^\"]|\\\\\")*)(\")))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
-          "end": "\\s*(=>)",
-          "beginCaptures": {
+          "match": "\\s*+(\\basync\\b)?\\s*+([_$a-zA-Z][$\\w]*)\\s*(=>)",
+          "captures": {
             "1": {
               "name": "storage.type.js"
-            }
-          },
-          "endCaptures": {
-            "1": {
-              "name": "storage.type.function.arrow.js"
-            }
-          },
-          "patterns": [
-            {
-              "include": "#flowtype-polymorphs"
             },
-            {
-              "include": "#flowtype-variable"
+            "2": {
+              "name": "variable.other.readwrite.js"
+            },
+            "3": {
+              "name": "storage.type.function.arrow.js"
             }
-          ]
+          }
         },
         {
           "comment": "e.g. play = (args) => { }",
           "name": "meta.function.arrow.js",
-          "begin": "\\s*+(\\b[_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*+(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(((')((?:[^']|\\\\')*)('))|\\s*+((\")((?:[^\"]|\\\\\")*)(\")))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
+          "begin": "\\s*+(\\b[_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*:(\\s*+(&|\\|)?(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*[x0-9A-Fa-f]+))*+)*\\s*=>)",
           "end": "\\s*(=>)",
           "applyEndPatternLast": 1,
           "beginCaptures": {
@@ -1732,9 +1724,8 @@
         {
           "comment": "e.g. play = arg => { }",
           "name": "meta.function.arrow.js",
-          "begin": "\\s*+(\\b[_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+([_$a-zA-Z][$\\w]*)\\s*+(?:\\s*+(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(((')((?:[^']|\\\\')*)('))|\\s*+((\")((?:[^\"]|\\\\\")*)(\")))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
-          "end": "\\s*(=>)",
-          "beginCaptures": {
+          "match": "\\s*+(\\b[_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+\\s*+(\\basync\\b)?\\s*+([_$a-zA-Z][$\\w]*)\\s*(=>)",
+          "captures": {
             "1": {
               "name": "entity.name.function.js"
             },
@@ -1743,26 +1734,19 @@
             },
             "3": {
               "name": "storage.type.js"
-            }
-          },
-          "endCaptures": {
-            "1": {
-              "name": "storage.type.function.arrow.js"
-            }
-          },
-          "patterns": [
-            {
-              "include": "#flowtype-polymorphs"
             },
-            {
-              "include": "#flowtype-variable"
+            "4": {
+              "name": "variable.other.readwrite.js"
+            },
+            "5": {
+              "name": "storage.type.function.arrow.js"
             }
-          ]
+          }
         },
         {
           "comment": "Sound.prototype.play = (args) => { }",
           "name": "meta.prototype.function.arrow.js",
-          "begin": "\\s*+(\\b[A-Z][$\\w]*)?(\\.)(prototype)(\\.)([_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*+(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(((')((?:[^']|\\\\')*)('))|\\s*+((\")((?:[^\"]|\\\\\")*)(\")))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
+          "begin": "\\s*+(\\b[A-Z][$\\w]*)?(\\.)(prototype)(\\.)([_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*:(\\s*+(&|\\|)?(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*[x0-9A-Fa-f]+))*+)*\\s*=>)",
           "end": "\\s*(=>)",
           "applyEndPatternLast": 1,
           "beginCaptures": {
@@ -1802,9 +1786,8 @@
         {
           "comment": "e.g. Sound.prototype.play = arg => { }",
           "name": "meta.prototype.function.arrow.js",
-          "begin": "\\s*+(\\b_?[A-Z][$\\w]*)?(\\.)(prototype)(\\.)([_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+([_$a-zA-Z][$\\w]*)\\s*+(?:\\s*+(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(((')((?:[^']|\\\\')*)('))|\\s*+((\")((?:[^\"]|\\\\\")*)(\")))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
-          "end": "\\s*(=>)",
-          "beginCaptures": {
+          "match": "\\s*+(\\b_?[A-Z][$\\w]*)?(\\.)(prototype)(\\.)([_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+([_$a-zA-Z][$\\w]*)\\s*(=>)",
+          "captures": {
             "1": {
               "name": "entity.name.class.js"
             },
@@ -1825,26 +1808,19 @@
             },
             "7": {
               "name": "storage.type.js"
-            }
-          },
-          "endCaptures": {
-            "1": {
-              "name": "storage.type.function.arrow.js"
-            }
-          },
-          "patterns": [
-            {
-              "include": "#flowtype-polymorphs"
             },
-            {
-              "include": "#flowtype-variable"
+            "8": {
+              "name": "variable.other.readwrite.js"
+            },
+            "9": {
+              "name": "storage.type.function.arrow.js"
             }
-          ]
+          }
         },
         {
           "comment": "e.g. Sound.play = (args) => { }",
           "name": "meta.function.static.arrow.js",
-          "begin": "\\s*+(\\b_?[A-Z][$\\w]*)?(\\.)([_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*+(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(((')((?:[^']|\\\\')*)('))|\\s*+((\")((?:[^\"]|\\\\\")*)(\")))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
+          "begin": "\\s*+(\\b_?[A-Z][$\\w]*)?(\\.)([_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*:(\\s*+(&|\\|)?(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*[x0-9A-Fa-f]+))*+)*\\s*=>)",
           "end": "\\s*(=>)",
           "applyEndPatternLast": 1,
           "beginCaptures": {
@@ -1878,9 +1854,8 @@
         {
           "comment": "e.g. Sound.play = arg => { }",
           "name": "meta.function.static.arrow.js",
-          "begin": "\\s*+(\\b_?[A-Z][$\\w]*)?(\\.)([_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+([_$a-zA-Z][$\\w]*)\\s*+(?:\\s*+(:|\\|)(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(((')((?:[^']|\\\\')*)('))|\\s*+((\")((?:[^\"]|\\\\\")*)(\")))|\\s*+[x0-9A-Fa-f]+))*\\s*+=>)",
-          "end": "\\s*(=>)",
-          "beginCaptures": {
+          "match": "\\s*+(\\b_?[A-Z][$\\w]*)?(\\.)([_$a-zA-Z][$\\w]*)\\s*+(=)\\s*+(\\basync\\b)?\\s*+([_$a-zA-Z][$\\w]*)\\s*(=>)",
+          "captures": {
             "1": {
               "name": "entity.name.class.js"
             },
@@ -1895,30 +1870,24 @@
             },
             "5": {
               "name": "storage.type.js"
-            }
-          },
-          "endCaptures": {
-            "1": {
-              "name": "storage.type.function.arrow.js"
-            }
-          },
-          "patterns": [
-            {
-              "include": "#flowtype-polymorphs"
             },
-            {
-              "include": "#flowtype-variable"
+            "6": {
+              "name": "variable.other.readwrite.js"
+            },
+            "7": {
+              "name": "storage.type.function.arrow.js"
             }
-          ]
+          }
         }
       ]
     },
-    "literal-method": {
+    "literal-method-alternate": {
+      "comment": "it assumes methods start on a new line/statement and have a open brace on the same line",
       "patterns": [
         {
           "comment": "e.g. play<T,T>(arg1, arg2): Type<T> { }",
           "name": "meta.function.method.js",
-          "begin": "\\s*+(\\bstatic\\b)?\\s*+(\\basync\\b)?\\s*+(\\*?)\\s*+(?<!\\.)([_$a-zA-Z][$\\w]*)\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?(\\())",
+          "begin": "(?:^|;)\\s*+(\\bstatic\\b)?\\s*+(\\basync\\b)?\\s*+(\\*?)\\s*+(?<!\\.)(?!\\b(break|case|catch|continue|do|else|finally|for|function|if|export|import|package|return|switch|throw|try|while|with)\\b)([_$a-zA-Z][$\\w]*)\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*+(?:\\s*:(\\s*+(&|\\|)?(\\s*+[$_a-zA-Z0-9]+(<(?:(?>[^<>]+)|\\g<-1>)*>)?|\\s*+(\\{(?:(?>[^{}]+)|\\g<-1>)*\\})|\\s*+(\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])|\\s*+(\\s*([\"']).*?\\k<-1>(?<!\\\\.))|\\s*[x0-9A-Fa-f]+))*+)*\\s*\\{)",
           "end": "\\s*(?=.)",
           "applyEndPatternLast": 1,
           "beginCaptures": {
@@ -1931,7 +1900,7 @@
             "3": {
               "name": "keyword.generator.asterisk.js"
             },
-            "4": {
+            "5": {
               "name": "entity.name.function.method.js"
             }
           },
@@ -1940,11 +1909,15 @@
               "include": "#flowtype"
             }
           ]
-        },
-        {
-          "comment": "e.g. [var]<T,T>(arg1, arg2): Type<T> { } or 'var'<T,T>(arg1, arg2)",
-          "name": "meta.function.method.js",
-          "begin": "\\s*+(\\bstatic\\b)?\\s*+(\\basync\\b)?\\s*+(\\*?)\\s*+(?=((\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\])|\\s*+(((')((?:[^']|\\\\')*)('))|\\s*+((\")((?:[^\"]|\\\\\")*)(\"))))\\s*+(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\())",
+        }
+      ]
+    },
+    "literal-method": {
+      "patterns": [
+        {
+          "comment": "e.g. play<T,T>(arg1, arg2): Type<T> { }",
+          "name": "meta.function.method.js",
+          "begin": "(?<!:)\\s*+(\\bstatic\\b)?\\s*+(\\basync\\b)?\\s*+(\\*?)\\s*+(?<!\\.)([_$a-zA-Z][$\\w]*)\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?(\\())",
           "end": "\\s*(?=.)",
           "applyEndPatternLast": 1,
           "beginCaptures": {
@@ -1959,20 +1932,66 @@
             },
             "4": {
               "name": "entity.name.function.method.js"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#flowtype"
+            }
+          ]
+        },
+        {
+          "comment": "e.g. 'play'<T,T>(arg1, arg2): Type<T> { }",
+          "name": "meta.function.method.js",
+          "begin": "(?<!:)\\s*+(\\bstatic\\b)?\\s*+(\\basync\\b)?\\s*+(\\*?)\\s*+(?<!\\.)(('|\\\")([^\"']*)(\\k<-3>))\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?(\\())",
+          "end": "\\s*(?=.)",
+          "applyEndPatternLast": 1,
+          "beginCaptures": {
+            "1": {
+              "name": "storage.modifier.js"
             },
-            "6": {
+            "2": {
+              "name": "storage.type.js"
+            },
+            "3": {
+              "name": "keyword.generator.asterisk.js"
+            },
+            "4": {
               "name": "entity.name.function.method.js"
             }
           },
           "patterns": [
             {
-              "include": "#flowtype-parse-array"
+              "include": "#flowtype"
+            }
+          ]
+        },
+        {
+          "comment": "e.g. [var]<T,T>(arg1, arg2): Type<T> { } or 'var'<T,T>(arg1, arg2)",
+          "name": "meta.function.method.js",
+          "begin": "(?<!:)\\s*+(\\bstatic\\b)?\\s*+(\\basync\\b)?\\s*+(\\*?)\\s*+(?=((\\[(?:(?>[^\\[\\]]+)|\\g<-1>)*\\]))\\s*+(<(?:(?>[^<>]+)|\\g<-1>)*>)?\\s*+(\\())",
+          "end": "\\s*(?=.)",
+          "applyEndPatternLast": 1,
+          "beginCaptures": {
+            "1": {
+              "name": "storage.modifier.js"
             },
-            {
-              "include": "#literal-string"
+            "2": {
+              "name": "storage.type.js"
             },
+            "3": {
+              "name": "keyword.generator.asterisk.js"
+            },
+            "4": {
+              "name": "entity.name.function.method.js"
+            }
+          },
+          "patterns": [
             {
               "include": "#flowtype"
+            },
+            {
+              "include": "#square-brackets"
             }
           ]
         },
@@ -1984,7 +2003,7 @@
           "applyEndPatternLast": 1,
           "beginCaptures": {
             "1": {
-              "name": "storage.modifier.static.js"
+              "name": "storage.modifier.js"
             },
             "2": {
               "name": "storage.type.accessor.js"
@@ -2007,7 +2026,7 @@
           "applyEndPatternLast": 1,
           "beginCaptures": {
             "1": {
-              "name": "storage.modifier.static.js"
+              "name": "storage.modifier.js"
             },
             "2": {
               "name": "storage.type.accessor.js"
@@ -2122,12 +2141,202 @@
     "literal-module": {
       "patterns": [
         {
-          "name": "keyword.control.module.js",
-          "match": "\\s*+(?<!\\.)\\b(import|export|default)\\b"
+          "include": "#literal-module-import"
+        },
+        {
+          "include": "#literal-module-export"
+        }
+      ]
+    },
+    "literal-module-import": {
+      "begin": "\\s*+(?<!\\.)\\b(import)(?!\\s*:)\\b",
+      "end": "\\s*(?:(?:(\\bfrom\\b)?+\\s++(('|\\\")([^\\\"']*)(\\k<-3>)))|(?=\\;|^\\s*\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare|interface)\\b|\\)|}))",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.control.module.js"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "keyword.control.module.js"
+        },
+        "3": {
+          "name": "punctuation.definition.string.begin.js"
+        },
+        "4": {
+          "name": "string.quoted.module.js"
+        },
+        "5": {
+          "name": "punctuation.definition.string.begin.js"
+        }
+      },
+      "patterns": [
+        {
+          "match": "\\s*\\b(default)\\b",
+          "captures": {
+            "1": {
+              "name": "keyword.control.module.js"
+            }
+          }
+        },
+        {
+          "match": "\\s*\\b(typeof|type)\\b\\s++(?=\\{|[$_a-zA-Z])(?!\\b(instanceof|in|as)\\b|,)",
+          "captures": {
+            "1": {
+              "name": "keyword.other.typedef.flowtype"
+            }
+          }
+        },
+        {
+          "name": "keyword.operator.module.all.js",
+          "match": "\\*"
+        },
+        {
+          "include": "#literal-module-as"
+        },
+        {
+          "include": "#literal-module-brackets"
+        },
+        {
+          "include": "#literal-variable"
+        },
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#literal-comma"
+        }
+      ]
+    },
+    "literal-module-export": {
+      "patterns": [
+        {
+          "comment": "e.g. export let variable =, export type a=",
+          "match": "\\s*+(?<!\\.)\\b(export)(?!\\s*:)\\b(?=\\s++(let|type|typeof)\\s++[$_a-zA-Z])",
+          "captures": {
+            "1": {
+              "name": "keyword.control.module.js"
+            }
+          }
+        },
+        {
+          "comment": "export {  or  export * or export var from module",
+          "begin": "\\s*+(?<!\\.)\\b(export)\\b(?=\\s++({|\\*|[$_a-zA-Z][$_\\w]*(\\s++from\\b|\\s*,)))",
+          "end": "\\s*(?:(?:(\\bfrom\\b)?+\\s++(('|\\\")([^\\\"']*)(\\k<-3>)))|(?=\\;|^\\s*\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare|interface)\\b|\\)|}))",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.control.module.js"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "keyword.control.module.js"
+            },
+            "3": {
+              "name": "punctuation.definition.string.begin.js"
+            },
+            "4": {
+              "name": "string.quoted.module.js"
+            },
+            "5": {
+              "name": "punctuation.definition.string.begin.js"
+            }
+          },
+          "patterns": [
+            {
+              "name": "keyword.operator.module.all.js",
+              "match": "\\*"
+            },
+            {
+              "include": "#literal-module-as"
+            },
+            {
+              "include": "#literal-module-brackets"
+            },
+            {
+              "include": "#literal-variable"
+            },
+            {
+              "include": "#comments"
+            },
+            {
+              "include": "#literal-comma"
+            }
+          ]
+        },
+        {
+          "comment": "trap expressions among - export function* () {}",
+          "match": "\\s*+(?<!\\.)\\b(export|default)(?!\\s*:)\\b",
+          "captures": {
+            "1": {
+              "name": "keyword.control.module.js"
+            }
+          }
+        }
+      ]
+    },
+    "literal-module-as": {
+      "match": "\\s*+(?:(\\*)|([$_a-zA-Z][$_\\w]*))\\s++(\\bas\\b)\\s++(?:(\\bdefault\\b)|([$_a-zA-Z][$_\\w]*))",
+      "captures": {
+        "1": {
+          "name": "keyword.operator.module.all.js"
+        },
+        "2": {
+          "name": "variable.other.readwrite.js"
+        },
+        "3": {
+          "name": "keyword.control.module.reference.js"
         },
+        "4": {
+          "name": "keyword.control.module.js"
+        },
+        "5": {
+          "name": "variable.other.readwrite.js"
+        }
+      }
+    },
+    "literal-module-brackets": {
+      "patterns": [
         {
-          "name": "keyword.control.module.reference.js",
-          "match": "\\s*+(?<!\\.)\\b(from|as)\\b"
+          "begin": "\\s*+(?:(\\{)|(\\[))",
+          "end": "\\s*(?:(\\})|(\\]))",
+          "beginCaptures": {
+            "1": {
+              "name": "meta.brace.curly.js"
+            },
+            "2": {
+              "name": "meta.brace.square.js"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "meta.brace.curly.js"
+            },
+            "2": {
+              "name": "meta.brace.square.js"
+            }
+          },
+          "patterns": [
+            {
+              "name": "keyword.operator.module.all.js",
+              "match": "\\*"
+            },
+            {
+              "include": "#literal-module-as"
+            },
+            {
+              "include": "#literal-module-brackets"
+            },
+            {
+              "include": "#literal-variable"
+            },
+            {
+              "include": "#literal-string"
+            },
+            {
+              "include": "#literal-comma"
+            }
+          ]
         }
       ]
     },
@@ -2526,6 +2735,18 @@
     },
     "flowtype-variable": {
       "patterns": [
+        {
+          "comment": "e.g. let a: ()=>null  =  function() {return null}",
+          "match": "(?<!\\.)\\s*+([$_\\p{L}](?:[$.\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)\\s*+(\\??)\\s*+(?=:\\s*(\\bFunction\\b|(\\((?:(?>[^()]+)|\\g<-1>)*\\))\\s*=>|\\(\\s*$))",
+          "captures": {
+            "1": {
+              "name": "storage.type.function.js"
+            },
+            "2": {
+              "name": "keyword.operator.optional.parameter.flowtype"
+            }
+          }
+        },
         {
           "comment": "name of variable spread var with optional ? and optional flowtype :",
           "match": "\\s*+((?<!\\.)\\.\\.\\.)?([$_\\p{L}](?:[$.\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)\\s*+(\\??)\\s*+(?=:|=>)",
@@ -2546,118 +2767,71 @@
         }
       ]
     },
-    "flowtype-destruct-lhs": {
-      "comment": "use this pattern to colour code the variable part correctly",
+    "flowtype-vars-and-props": {
       "patterns": [
         {
-          "begin": "\\s*+{",
-          "end": "\\s*}",
+          "comment": "flowtype optional arg/parameter e.g. protocol? : string",
+          "name": "punctuation.type.flowtype",
+          "match": "\\s*+\\?"
+        },
+        {
+          "comment": "Type Unions |",
+          "name": "kewyword.operator.union.flowtype",
+          "match": "\\s*+\\|"
+        },
+        {
+          "comment": "intersection of types &",
+          "name": "kewyword.operator.intersection.flowtype",
+          "match": "\\s*+\\&"
+        },
+        {
+          "comment": "typed entity :",
+          "begin": "\\s*+(:)",
+          "end": "(?=.)",
+          "applyEndPatternLast": 1,
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.type.flowtype"
+            }
+          },
           "patterns": [
             {
-              "include": "#flowtype-destruct-lhs"
+              "include": "#flowtype-parse-types"
             }
           ]
         },
         {
-          "begin": "\\s*+\\[",
-          "end": "\\s*\\]",
+          "include": "#literal-comma"
+        },
+        {
+          "comment": "An Iterator prefix?",
+          "match": "\\s*+@@"
+        },
+        {
+          "begin": "\\s*+(=>)",
+          "end": "(?=.)",
+          "applyEndPatternLast": 1,
+          "beginCaptures": {
+            "1": {
+              "name": "storage.type.function.arrow.js"
+            }
+          },
           "patterns": [
             {
-              "include": "#flowtype-destruct-lhs"
+              "include": "#flowtype-parse-types"
             }
           ]
         },
         {
-          "comment": "string as destructor target",
-          "match": "\\s*+((['\\\"]).*?\\k<-1>(?<!\\\\.))\\s*+(:)\\s*+(([$_\\p{L}](?:[$.\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+))",
-          "captures": {
-            "1": {
-              "name": "string.quoted.js"
-            },
-            "3": {
-              "name": "punctuation"
-            },
-            "4": {
-              "name": "variable.other.property.js"
-            }
-          }
-        },
-        {
-          "comment": "prop name : var name as destructor target",
-          "match": "\\s*+([$_\\p{L}](?:[$.\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)\\s*+(:)\\s*+(([$_\\p{L}](?:[$.\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+))",
-          "captures": {
-            "1": {
-              "name": "string.unquoted.js"
-            },
-            "2": {
-              "name": "punctuation"
-            },
-            "3": {
-              "name": "variable.other.property.js"
-            }
-          }
-        },
-        {
-          "comment": "var name as destructor target",
-          "match": "\\s*+((?<!\\.)\\.\\.\\.)?([$_\\p{L}](?:[$.\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)",
-          "captures": {
-            "1": {
-              "name": "keyword.operator.spread.js"
-            },
-            "2": {
-              "name": "variable.other.property.js"
-            }
-          }
-        },
-        {
-          "include": "#literal-comma"
-        },
-        {
-          "include": "#flowtype-vars-and-props"
-        }
-      ]
-    },
-    "flowtype-vars-and-props": {
-      "patterns": [
-        {
-          "comment": "flowtype optional arg/parameter e.g. protocol? : string",
-          "name": "punctuation.type.flowtype",
-          "match": "\\s*+\\?"
-        },
-        {
-          "comment": "typed entity :",
-          "begin": "\\s*+(:)",
-          "end": "(?=.)",
-          "applyEndPatternLast": 1,
-          "beginCaptures": {
-            "1": {
-              "name": "punctuation.type.flowtype"
-            }
-          },
+          "comment": "assignment var = or = ",
+          "begin": "\\s*+(?=([$_\\p{L}](?:[$.\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)?\\s*=)(?!=>|==)",
+          "end": "\\s*(?=,|;|\\)|}|\\]|\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield)\\b|type\\s+[$\\w]+|declare\\s+[$\\w]+|interface\\s+[$\\w]+)",
           "patterns": [
             {
-              "include": "#flowtype-parse-types"
+              "include": "#expression"
             }
           ]
         },
-        {
-          "include": "#literal-object"
-        },
-        {
-          "include": "#literal-comma"
-        },
-        {
-          "comment": "An Iterator prefix?",
-          "match": "\\s*+@@"
-        },
-        {
-          "match": "\\s*+(=>)",
-          "captures": {
-            "1": {
-              "name": "storage.type.function.arrow.js"
-            }
-          }
-        },
         {
           "include": "#flowtype-bracketed-parameters"
         },
@@ -2669,47 +2843,6 @@
         }
       ]
     },
-    "flowtype-parse-operators": {
-      "patterns": [
-        {
-          "comment": "call back with a form  ) => type",
-          "begin": "(?<=\\))\\s*+(=>)",
-          "end": "(?=.)",
-          "applyEndPatternLast": 1,
-          "beginCaptures": {
-            "1": {
-              "name": "storage.type.function.arrow.js"
-            }
-          },
-          "patterns": [
-            {
-              "include": "#flowtype-parse-types"
-            }
-          ]
-        },
-        {
-          "include": "#literal-object"
-        },
-        {
-          "comment": "some form of default assignment for func args",
-          "begin": "\\s*+=(?!>|=|==)",
-          "end": "\\s*(?=,|;|\\)|}|\\]|\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare)\\b)",
-          "beginCaptures": {
-            "0": {
-              "name": "keyword.operator.assignment.js"
-            }
-          },
-          "patterns": [
-            {
-              "include": "#literal-labels"
-            },
-            {
-              "include": "#expression"
-            }
-          ]
-        }
-      ]
-    },
     "flowtype-parse-types": {
       "patterns": [
         {
@@ -2753,7 +2886,7 @@
         },
         {
           "comment": "custom primitive/var Types e.g. abc avoid abc(",
-          "match": "(?!^)\\s*+(?!\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare)\\b)([$_\\p{L}][$.\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}]*+)(?!\\s*+\\()",
+          "match": "(?!^)\\s*+(?!\\b(if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare|interface)\\b)([$_\\p{L}][$.\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}]*+)(?!\\s*+\\()",
           "captures": {
             "2": {
               "name": "support.type.primitive.flowtype"
@@ -2775,6 +2908,20 @@
           "name": "kewyword.operator.existential.flowtype",
           "match": "\\s*+\\*"
         },
+        {
+          "comment": "types of type marker e.g. <T: number | string>",
+          "name": "punctuation.type.flowtype",
+          "match": "\\s*+(:)"
+        },
+        {
+          "comment": "call back with a form  ) => type",
+          "match": "(?<=\\))\\s*+(=>)",
+          "captures": {
+            "1": {
+              "name": "storage.type.function.arrow.js"
+            }
+          }
+        },
         {
           "include": "#literal-string"
         },
@@ -2787,9 +2934,6 @@
         {
           "include": "#flowtype-parse-objects"
         },
-        {
-          "include": "#flowtype-parse-operators"
-        },
         {
           "include": "#flowtype-parse-array"
         },
@@ -2802,7 +2946,7 @@
       "patterns": [
         {
           "comment": "Get parameters within a function/method call",
-          "begin": "\\s*+(\\()",
+          "begin": "(?<!=)\\s*+(\\()",
           "end": "\\s*(\\))",
           "beginCaptures": {
             "1": {
@@ -2844,12 +2988,7 @@
           },
           "patterns": [
             {
-              "match": "\\s*+(,|:)",
-              "captures": {
-                "1": {
-                  "name": "punctuation.type.separator.flowtype"
-                }
-              }
+              "include": "#literal-comma"
             },
             {
               "match": "\\s*+(\\+|-)",
@@ -2880,12 +3019,7 @@
           },
           "patterns": [
             {
-              "match": "\\s*+(,|:)",
-              "captures": {
-                "1": {
-                  "name": "punctuation.type.separator.flowtype"
-                }
-              }
+              "include": "#literal-comma"
             },
             {
               "match": "\\s*+(\\+|-)",
@@ -2903,8 +3037,8 @@
       ]
     },
     "flowtype-parse-objects": {
-      "comment": "object literal flowtype  preceded by either  : | & ? symbols",
-      "begin": "(?<=:|\\||&|\\?)\\s*+(\\{)",
+      "comment": "object literal flowtype  preceded by either => : | & ? symbols",
+      "begin": "(?<=:|\\||&|\\?|=>|<)\\s*+(\\{)",
       "end": "\\s*(\\})",
       "applyEndPatternLast": 1,
       "beginCaptures": {
@@ -2944,7 +3078,7 @@
     },
     "flowtype-parse-array": {
       "comment": "arrays such as [name: string, dob: Date]",
-      "begin": "\\s*+(\\[)",
+      "begin": "(?<!=|[$_A-Za-z0-9])\\s*+(\\[)",
       "end": "\\s*(\\])",
       "beginCaptures": {
         "1": {
@@ -2964,25 +3098,13 @@
     },
     "flowtype-type-aliases": {
       "patterns": [
-        {
-          "comment": "import for types",
-          "match": "\\s*+(?<!\\.)\\b(import)\\b\\s*+(type)\\b",
-          "captures": {
-            "1": {
-              "name": "keyword.control.module.js"
-            },
-            "2": {
-              "name": "support.type.type.flowtype"
-            }
-          }
-        },
         {
           "comment": "type aliases for export but avoid type instaceof or type in operators",
-          "begin": "\\s*+\\b(type)\\b\\s+(?!(instanceof|in)\\b)(?=[$_\\p{L}])",
-          "end": "\\s*(\\;|\\n|\\b(?=if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare)\\b)",
+          "begin": "\\s*+\\b(type)\\b\\s*(?!(instanceof|in)\\b)(?=[$_A-Za-z{\\[])",
+          "end": "\\s*(\\;)|\\b(?=if|switch|try|var|let|const|static|function|return|class|do|for|while|debugger|export|import|yield|type|declare|interface)\\b",
           "beginCaptures": {
             "1": {
-              "name": "support.type.type.flowtype"
+              "name": "keyword.other.typedef.flowtype"
             }
           },
           "endCaptures": {
@@ -3040,232 +3162,250 @@
       ]
     },
     "flowtype-interface": {
+      "begin": "\\s*+(?<!\\.)\\b(interface)\\s++",
+      "end": "\\s*(?<=})",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.interface.flowtype"
+        }
+      },
       "patterns": [
         {
-          "comment": "find declare module and declare class defs",
-          "begin": "\\s*+\\b(interface)\\s+(?=[$_\\p{L}])",
-          "end": "\\s*(?:(;)|\\n|(}))",
-          "applyEndPatternLast": 1,
+          "comment": "look for interface names but dont assume uppercase start char",
+          "match": "(?<!\\.)\\s*+([$_\\p{L}](?:[$\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)",
+          "name": "support.type.class.interface.js"
+        },
+        {
+          "include": "#flowtype-polymorphs"
+        },
+        {
+          "begin": "\\s*+{",
+          "end": "\\s*(})",
+          "contentName": "meta.class.body.js",
           "beginCaptures": {
-            "1": {
-              "name": "support.type.interface.flowtype"
+            "0": {
+              "name": "punctuation.section.class.begin.js"
             }
           },
           "endCaptures": {
             "1": {
-              "name": "punctuation.terminator.statement.js"
-            },
-            "2": {
               "name": "punctuation.section.class.end.js"
             }
           },
           "patterns": [
             {
-              "include": "#comments"
+              "include": "#flowtype-literal-method"
             },
             {
-              "match": "\\s*+\\b(extends)\\b\\s*+",
-              "captures": {
-                "1": {
-                  "name": "storage.type.extends.flowtype"
-                }
-              }
-            },
-            {
-              "include": "#flowtype"
-            },
-            {
-              "include": "#flowtype-interface-name"
-            },
-            {
-              "begin": "\\s*+{",
-              "end": "\\s*(?=})",
-              "contentName": "meta.class.body.js",
-              "beginCaptures": {
-                "0": {
-                  "name": "punctuation.section.class.begin.js"
-                }
-              },
-              "patterns": [
-                {
-                  "match": "\\s*+\\b(?<!\\.)static\\b(?!\\.)",
-                  "name": "storage.modifier.js"
-                },
-                {
-                  "include": "#flowtype"
-                },
-                {
-                  "include": "#flowtype-variable"
-                },
-                {
-                  "include": "#comments"
-                },
-                {
-                  "include": "#flowtype-function-name"
-                }
-              ]
+              "include": "#class-body"
             }
           ]
         }
       ]
     },
-    "flowtype-function-name": {
-      "match": "\\s*+(\\bstatic\\b)?\\s*+([$_\\p{L}][$.\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}]*)?\\s*+(?!:)(?=\\(|<.*\\()",
-      "captures": {
-        "1": {
-          "name": "storage.modifier.static.js"
-        },
-        "2": {
-          "name": "entity.name.function.js"
-        }
-      }
-    },
-    "flowtype-class-name": {
-      "comment": "look for classes names but dont assume uppercase start char",
-      "match": "(?<!\\.)\\s*+([$_\\p{L}](?:[$\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)",
-      "name": "entity.name.class.js"
-    },
-    "flowtype-interface-name": {
-      "comment": "look for interface names but dont assume uppercase start char",
-      "match": "(?<!\\.)\\s*+([$_\\p{L}](?:[$\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)",
-      "name": "support.type.class.interface.js"
-    },
     "flowtype-declare": {
       "patterns": [
         {
-          "begin": "\\s*+\\b(declare)\\s+(?=(class|function|module|var))\\b",
+          "match": "\\s*+(?<!\\.)\\b(declare)\\b\\s++(?=\\b(function|var|type|interface)\\s++)",
+          "captures": {
+            "1": {
+              "name": "keyword.other.declare.flowtype"
+            }
+          }
+        },
+        {
+          "comment": "declare module.exports:",
+          "begin": "\\s*+(?<!\\.)\\b(declare)\\b\\s*+\\b(module)(.)(exports)(:)",
           "end": "(?=.)",
           "applyEndPatternLast": 1,
           "beginCaptures": {
             "1": {
-              "name": "support.type.declare.flowtype"
+              "name": "keyword.other.declare.flowtype"
+            },
+            "2": {
+              "name": "storage.type.module.flowtype"
+            },
+            "3": {
+              "name": "keyword.operator.accessor.flowtype"
+            },
+            "4": {
+              "name": "storage.type.module.flowtype"
+            },
+            "5": {
+              "name": "punctuation.type.flowtype"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#flowtype-parse-types"
+            }
+          ]
+        },
+        {
+          "comment": "declare modules",
+          "begin": "\\s*+(?<!\\.)\\b(declare)\\b\\s*+\\b(module)\\b",
+          "end": "\\s*(?<=})",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.declare.flowtype"
+            },
+            "2": {
+              "name": "storage.type.module.flowtype"
             }
           },
           "patterns": [
             {
-              "include": "#flowtype-declare-classes"
+              "include": "#flowtype-polymorphs"
             },
             {
-              "include": "#flowtype-declare-modules"
+              "comment": "look for module names but dont assume uppercase start char",
+              "match": "(?<!\\.)\\s*+([$_\\p{L}](?:[$\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)",
+              "name": "entity.name.class.js"
             },
             {
-              "include": "#flowtype-declare-function"
+              "comment": "look for module names in quoted string forms",
+              "include": "#literal-string"
             },
             {
-              "include": "#flowtype-declare-vars"
+              "begin": "\\s*+({)",
+              "end": "\\s*(})",
+              "contentName": "meta.class.body.js",
+              "beginCaptures": {
+                "1": {
+                  "name": "punctuation.section.class.begin.js"
+                }
+              },
+              "endCaptures": {
+                "1": {
+                  "name": "punctuation.section.class.end.js"
+                }
+              },
+              "patterns": [
+                {
+                  "include": "#flowtype-literal-method"
+                },
+                {
+                  "include": "#class-body"
+                }
+              ]
             }
           ]
-        }
-      ]
-    },
-    "flowtype-declare-modules": {
-      "match": "\\s*+\\bmodule\\b\\s+",
-      "name": "support.type.object.module.js"
-    },
-    "flowtype-declare-classes": {
-      "patterns": [
+        },
         {
-          "begin": "\\s*+\\b(class)\\s+",
-          "end": "\\s*(})",
-          "applyEndPatternLast": 1,
+          "comment": "declare classes",
+          "begin": "\\s*+(?<!\\.)\\b(declare)\\b\\s*+\\b(class)\\b",
+          "end": "\\s*(?<=})",
           "beginCaptures": {
             "1": {
+              "name": "keyword.other.declare.flowtype"
+            },
+            "2": {
               "name": "storage.type.class.flowtype"
             }
           },
-          "endCaptures": {
-            "1": {
-              "name": "punctuation.section.class.end.js"
-            }
-          },
           "patterns": [
             {
-              "match": "\\s*+\\b(extends|mixins)\\b\\s*+",
+              "include": "#flowtype-polymorphs"
+            },
+            {
+              "comment": "look for extends keyword",
+              "match": "\\s*+\\b((extends))\\b\\s*+",
               "captures": {
                 "1": {
-                  "name": "storage.type.extends.flowtype"
+                  "name": "meta.class.extends.js"
+                },
+                "2": {
+                  "name": "storage.type.extends.js"
                 }
               }
             },
             {
-              "begin": "{",
-              "end": "\\s*(?=})",
-              "contentName": "meta.class.body.js",
+              "comment": "look for mixins keyword",
+              "begin": "\\s*+\\b((mixins))\\b\\s*+",
+              "end": "\\s*(?={)",
               "beginCaptures": {
-                "0": {
-                  "name": "punctuation.section.class.begin.js"
+                "1": {
+                  "name": "meta.class.extends.js"
+                },
+                "2": {
+                  "name": "storage.type.extends.js"
                 }
               },
               "patterns": [
                 {
-                  "match": "\\s*+\\b(?<!\\.)static\\b(?!\\.)",
-                  "name": "storage.modifier.js"
-                },
-                {
-                  "include": "#literal-method"
-                },
-                {
-                  "include": "#flowtype"
-                },
-                {
-                  "include": "#flowtype-variable"
-                },
-                {
-                  "include": "#comments"
+                  "comment": "look for mixin names but dont assume uppercase start char",
+                  "match": "(?<!\\.)\\s*+([$_\\p{L}](?:[$\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)",
+                  "name": "entity.name.class.js"
                 },
                 {
-                  "include": "#flowtype-function-name"
+                  "include": "#literal-comma"
                 }
               ]
             },
             {
-              "include": "#flowtype-class-name"
+              "comment": "look for class names but dont assume uppercase start char",
+              "match": "(?<!\\.)\\s*+([$_\\p{L}](?:[$\\p{L}\\p{Mn}\\p{Mc}\\p{Nd}\\p{Nl}\\p{Pc}])*+)",
+              "name": "entity.name.class.js"
             },
             {
-              "include": "#flowtype-polymorphs"
+              "begin": "\\s*+({)",
+              "end": "\\s*(})",
+              "contentName": "meta.class.body.js",
+              "beginCaptures": {
+                "1": {
+                  "name": "punctuation.section.class.begin.js"
+                }
+              },
+              "endCaptures": {
+                "1": {
+                  "name": "punctuation.section.class.end.js"
+                }
+              },
+              "patterns": [
+                {
+                  "include": "#flowtype-literal-method"
+                },
+                {
+                  "include": "#class-body"
+                }
+              ]
             }
           ]
         }
       ]
     },
-    "flowtype-declare-function": {
+    "flowtype-literal-method": {
+      "comment": "trap methods without a name  e.g.   <Key, Value>(): Map<Key, Value>",
+      "begin": "(?<!:)\\s*+(?=(<(?:(?>[^<>]+)|\\g<-1>)*>)?(\\())",
+      "end": "\\s*(?=.)",
+      "applyEndPatternLast": 1,
+      "beginCaptures": {
+        "1": {
+          "name": "storage.modifier.js"
+        },
+        "2": {
+          "name": "storage.type.js"
+        },
+        "3": {
+          "name": "keyword.generator.asterisk.js"
+        }
+      },
       "patterns": [
         {
-          "begin": "\\s*+\\b(function)\\s+",
-          "end": "\\s*(;)",
-          "applyEndPatternLast": 1,
-          "beginCaptures": {
-            "1": {
-              "name": "storage.type.function.js"
-            }
-          },
-          "patterns": [
-            {
-              "include": "#flowtype"
-            },
-            {
-              "include": "#flowtype-function-name"
-            }
-          ]
+          "include": "#flowtype"
         }
       ]
     },
-    "flowtype-declare-vars": {
+    "flowtype-keywords": {
       "patterns": [
         {
-          "begin": "\\s*+\\b(var)\\s+",
-          "end": "\\s*(?=.)",
-          "applyEndPatternLast": 1,
-          "beginCaptures": {
-            "1": {
-              "name": "storage.type.var.js"
-            }
-          },
-          "patterns": [
-            {
-              "include": "#flowtype-variable"
-            }
-          ]
+          "include": "#flowtype-declare"
+        },
+        {
+          "include": "#flowtype-type-aliases"
+        },
+        {
+          "include": "#flowtype-interface"
         }
       ]
     },