tm-grammars 1.17.3 → 1.17.5

package/grammars/python.json

@@ -11,7 +11,7 @@
   ],
   "repository": {
     "annotated-parameter": {
-      "begin": "(?x)\n\\b\n([[:alpha:]_]\\w*) \\s* (:)\n",
+      "begin": "\\b([[:alpha:]_]\\w*)\\s*(:)",
       "beginCaptures": {
         "1": {
           "name": "variable.parameter.function.language.python"
@@ -37,7 +37,7 @@
       ]
     },
     "assignment-operator": {
-      "match": "(?x)\n<<= | >>= | //= | \\*\\*=\n| \\+= | -= | /= | @=\n| \\*= | %= | ~= | \\^= | &= | \\|=\n| =(?!=)\n",
+      "match": "<<=|>>=|//=|\\*\\*=|\\+=|-=|/=|@=|\\*=|%=|~=|\\^=|&=|\\|=|=(?!=)",
       "name": "keyword.operator.assignment.python"
     },
     "backticks": {
@@ -70,17 +70,17 @@
       ]
     },
     "builtin-exceptions": {
-      "match": "(?x) (?<!\\.) \\b(\n(\nArithmetic | Assertion | Attribute | Buffer | BlockingIO\n| BrokenPipe | ChildProcess\n| (Connection (Aborted | Refused | Reset)?)\n| EOF | Environment | FileExists | FileNotFound\n| FloatingPoint | IO | Import | Indentation | Index | Interrupted\n| IsADirectory | NotADirectory | Permission | ProcessLookup\n| Timeout\n| Key | Lookup | Memory | Name | NotImplemented | OS | Overflow\n| Reference | Runtime | Recursion | Syntax | System\n| Tab | Type | UnboundLocal | Unicode(Encode|Decode|Translate)?\n| Value | Windows | ZeroDivision | ModuleNotFound\n) Error\n|\n((Pending)?Deprecation | Runtime | Syntax | User | Future | Import\n| Unicode | Bytes | Resource\n)? Warning\n|\nSystemExit | Stop(Async)?Iteration\n| KeyboardInterrupt\n| GeneratorExit | (Base)?Exception\n)\\b\n",
+      "match": "(?<!\\.)\\b((Arithmetic|Assertion|Attribute|Buffer|BlockingIO|BrokenPipe|ChildProcess|(Connection(Aborted|Refused|Reset)?)|EOF|Environment|FileExists|FileNotFound|FloatingPoint|IO|Import|Indentation|Index|Interrupted|IsADirectory|NotADirectory|Permission|ProcessLookup|Timeout|Key|Lookup|Memory|Name|NotImplemented|OS|Overflow|Reference|Runtime|Recursion|Syntax|System|Tab|Type|UnboundLocal|Unicode(Encode|Decode|Translate)?|Value|Windows|ZeroDivision|ModuleNotFound)Error|((Pending)?Deprecation|Runtime|Syntax|User|Future|Import|Unicode|Bytes|Resource)?Warning|SystemExit|Stop(Async)?Iteration|KeyboardInterrupt|GeneratorExit|(Base)?Exception)\\b",
       "name": "support.type.exception.python"
     },
     "builtin-functions": {
       "patterns": [
         {
-          "match": "(?x)\n(?<!\\.) \\b(\n__import__ | abs | aiter | all | any | anext | ascii | bin\n| breakpoint | callable | chr | compile | copyright | credits\n| delattr | dir | divmod | enumerate | eval | exec | exit\n| filter | format | getattr | globals | hasattr | hash | help\n| hex | id | input | isinstance | issubclass | iter | len\n| license | locals | map | max | memoryview | min | next\n| oct | open | ord | pow | print | quit | range | reload | repr\n| reversed | round | setattr | sorted | sum | vars | zip\n)\\b\n",
+          "match": "(?<!\\.)\\b(__import__|abs|aiter|all|any|anext|ascii|bin|breakpoint|callable|chr|compile|copyright|credits|delattr|dir|divmod|enumerate|eval|exec|exit|filter|format|getattr|globals|hasattr|hash|help|hex|id|input|isinstance|issubclass|iter|len|license|locals|map|max|memoryview|min|next|oct|open|ord|pow|print|quit|range|reload|repr|reversed|round|setattr|sorted|sum|vars|zip)\\b",
           "name": "support.function.builtin.python"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nfile | reduce | intern | raw_input | unicode | cmp | basestring\n| execfile | long | xrange\n)\\b\n",
+          "match": "(?<!\\.)\\b(file|reduce|intern|raw_input|unicode|cmp|basestring|execfile|long|xrange)\\b",
           "name": "variable.legacy.builtin.python"
         }
       ]
@@ -96,11 +96,11 @@
       ]
     },
     "builtin-types": {
-      "match": "(?x)\n(?<!\\.) \\b(\nbool | bytearray | bytes | classmethod | complex | dict\n| float | frozenset | int | list | object | property\n| set | slice | staticmethod | str | tuple | type\n\n(?# Although 'super' is not a type, it's related to types,\nand is special enough to be highlighted differently from\nother built-ins)\n| super\n)\\b\n",
+      "match": "(?<!\\.)\\b(bool|bytearray|bytes|classmethod|complex|dict|float|frozenset|int|list|object|property|set|slice|staticmethod|str|tuple|type(?#Although'super'isnotatype,it'srelatedtotypes,andisspecialenoughtobehighlighteddifferentlyfromotherbuilt-ins)|super)\\b",
       "name": "support.type.python"
     },
     "call-wrapper-inheritance": {
-      "begin": "(?x)\n\\b(?=\n([[:alpha:]_]\\w*) \\s* (\\()\n)\n",
+      "begin": "\\b(?=([[:alpha:]_]\\w*)\\s*(\\())",
       "comment": "same as a function call, but in inheritance context",
       "end": "(\\))",
       "endCaptures": {
@@ -121,7 +121,7 @@
     "class-declaration": {
       "patterns": [
         {
-          "begin": "(?x)\n\\s*(class)\\s+\n(?=\n[[:alpha:]_]\\w* \\s* (:|\\()\n)\n",
+          "begin": "\\s*(class)\\s+(?=[[:alpha:]_]\\w*\\s*(:|\\())",
           "beginCaptures": {
             "1": {
               "name": "storage.type.class.python"
@@ -205,7 +205,7 @@
           "name": "keyword.operator.assignment.python"
         }
       },
-      "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\s*(=)(?!=)\n"
+      "match": "\\b([[:alpha:]_]\\w*)\\s*(=)(?!=)"
     },
     "class-name": {
       "patterns": [
@@ -216,7 +216,7 @@
           "include": "#builtin-possible-callables"
         },
         {
-          "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n",
+          "match": "\\b([[:alpha:]_]\\w*)\\b",
           "name": "entity.name.type.class.python"
         }
       ]
@@ -232,7 +232,7 @@
     "comments": {
       "patterns": [
         {
-          "begin": "(?x)\n(?:\n\\# \\s* (type:)\n\\s*+ (?# we want `\\s*+` which is possessive quantifier since\nwe do not actually want to backtrack when matching\nwhitespace here)\n(?! $ | \\#)\n)\n",
+          "begin": "(?:\\#\\s*(type:)\\s*+(?#wewant`\\s*+`whichispossessivequantifiersincewedonotactuallywanttobacktrackwhenmatchingwhitespacehere)(?!$|\\#))",
           "beginCaptures": {
             "0": {
               "name": "meta.typehint.comment.python"
@@ -246,11 +246,11 @@
           "name": "comment.line.number-sign.python",
           "patterns": [
             {
-              "match": "(?x)\n\\G ignore\n(?= \\s* (?: $ | \\#))\n",
+              "match": "\\Gignore(?=\\s*(?:$|\\#))",
               "name": "comment.typehint.ignore.notation.python"
             },
             {
-              "match": "(?x)\n(?<!\\.)\\b(\nbool | bytes | float | int | object | str\n| List | Dict | Iterable | Sequence | Set\n| FrozenSet | Callable | Union | Tuple\n| Any | None\n)\\b\n",
+              "match": "(?<!\\.)\\b(bool|bytes|float|int|object|str|List|Dict|Iterable|Sequence|Set|FrozenSet|Callable|Union|Tuple|Any|None)\\b",
               "name": "comment.typehint.type.notation.python"
             },
             {
@@ -337,7 +337,7 @@
       ]
     },
     "decorator": {
-      "begin": "(?x)\n^\\s*\n((@)) \\s* (?=[[:alpha:]_]\\w*)\n",
+      "begin": "^\\s*((@))\\s*(?=[[:alpha:]_]\\w*)",
       "beginCaptures": {
         "1": {
           "name": "entity.name.function.decorator.python"
@@ -346,7 +346,7 @@
           "name": "punctuation.definition.decorator.python"
         }
       },
-      "end": "(?x)\n( \\) )\n\n(?: (.*?) (?=\\s*(?:\\#|$)) )\n| (?=\\n|\\#)\n",
+      "end": "(\\))(?:(.*?)(?=\\s*(?:\\#|$)))|(?=\\n|\\#)",
       "endCaptures": {
         "1": {
           "name": "punctuation.definition.arguments.end.python"
@@ -379,7 +379,7 @@
               "name": "punctuation.separator.period.python"
             }
           },
-          "match": "(?x)\n([[:alpha:]_]\\w*) | (\\.)\n",
+          "match": "([[:alpha:]_]\\w*)|(\\.)",
           "name": "entity.name.function.decorator.python"
         },
         {
@@ -391,7 +391,7 @@
               "name": "invalid.illegal.decorator.python"
             }
           },
-          "match": "(?x)\n\\s* ([^([:alpha:]\\s_\\.#\\\\] .*?) (?=\\#|$)\n",
+          "match": "\\s*([^([:alpha:]\\s_\\.#\\\\].*?)(?=\\#|$)",
           "name": "invalid.illegal.decorator.python"
         }
       ]
@@ -529,7 +529,7 @@
           "name": "keyword.control.flow.python"
         }
       },
-      "match": "(?x)\n(?:\n(?:^|\\G) \\s* (?# '\\G' is necessary for ST)\n((?:>>>|\\.\\.\\.) \\s) (?=\\s*\\S)\n)\n"
+      "match": "(?:(?:^|\\G)\\s*(?#'\\G'isnecessaryforST)((?:>>>|\\.\\.\\.)\\s)(?=\\s*\\S))"
     },
     "docstring-statement": {
       "begin": "^(?=\\s*[rR]?(\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\"))",
@@ -544,7 +544,7 @@
     "double-one-regexp-character-set": {
       "patterns": [
         {
-          "match": "(?x)\n\\[ \\^? \\] (?! .*?\\])\n"
+          "match": "\\[\\s\\^?\\s\\](?!.*?\\])"
         },
         {
           "begin": "(\\[)(\\^)?(\\])?",
@@ -773,7 +773,7 @@
       ]
     },
     "double-one-regexp-named-group": {
-      "begin": "(?x)\n(\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "begin": "(\\()(\\?P<\\w+(?:\\s+[[:alnum:]]+)?>)",
       "beginCaptures": {
         "1": {
           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
@@ -845,7 +845,7 @@
     "double-three-regexp-character-set": {
       "patterns": [
         {
-          "match": "(?x)\n\\[ \\^? \\] (?! .*?\\])\n"
+          "match": "\\[\\s\\^?\\s\\](?!.*?\\])"
         },
         {
           "begin": "(\\[)(\\^)?(\\])?",
@@ -1092,7 +1092,7 @@
       ]
     },
     "double-three-regexp-named-group": {
-      "begin": "(?x)\n(\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "begin": "(\\()(\\?P<\\w+(?:\\s+[[:alnum:]]+)?>)",
       "beginCaptures": {
         "1": {
           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
@@ -1175,13 +1175,13 @@
       "name": "constant.other.ellipsis.python"
     },
     "escape-sequence": {
-      "match": "(?x)\n\\\\ (\nx[0-9A-Fa-f]{2}\n| [0-7]{1,3}\n| [\\\\\"'abfnrtv]\n)\n",
+      "match": "\\\\(x[0-9A-Fa-f]{2}|[0-7]{1,3}|[\\\\\"'abfnrtv])",
       "name": "constant.character.escape.python"
     },
     "escape-sequence-unicode": {
       "patterns": [
         {
-          "match": "(?x)\n\\\\ (\nu[0-9A-Fa-f]{4}\n| U[0-9A-Fa-f]{8}\n| N\\{[\\w\\s]+?\\}\n)\n",
+          "match": "\\\\(u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8}|N\\{[\\w\\s]+?\\})",
           "name": "constant.character.escape.python"
         }
       ]
@@ -1197,7 +1197,7 @@
         },
         {
           "comment": "Tokenize identifiers to help linters",
-          "match": "(?x) \\b ([[:alpha:]_]\\w*) \\b"
+          "match": "\\b([[:alpha:]_]\\w*)\\b"
         }
       ]
     },
@@ -1306,7 +1306,7 @@
         },
         {
           "comment": "Tokenize identifiers to help linters",
-          "match": "(?x) \\b ([[:alpha:]_]\\w*) \\b"
+          "match": "\\b([[:alpha:]_]\\w*)\\b"
         }
       ]
     },
@@ -1327,7 +1327,7 @@
       ]
     },
     "fregexp-quantifier": {
-      "match": "(?x)\n\\{\\{(\n\\d+ | \\d+,(\\d+)? | ,\\d+\n)\\}\\}\n",
+      "match": "\\{\\{(\\d+|\\d+,(\\d+)?|,\\d+)\\}\\}",
       "name": "keyword.operator.quantifier.regexp"
     },
     "fstring-fnorm-quoted-multi-line": {
@@ -1497,7 +1497,7 @@
         }
       },
       "comment": "value interpolation using { ... }",
-      "end": "(?x)\n(\\})\n",
+      "end": "(\\})",
       "endCaptures": {
         "1": {
           "name": "constant.character.format.placeholder.other.python"
@@ -1513,7 +1513,7 @@
       ]
     },
     "fstring-multi-core": {
-      "match": "(?x)\n(.+?)\n(\n(?# .* and .*? in multi-line match need special handling of\nnewlines otherwise SublimeText and Atom will match slightly\ndifferently.\n\nThe guard for newlines has to be separate from the\nlookahead because of special $ matching rule.)\n($\\n?)\n|\n(?=[\\\\\\}\\{]|'''|\"\"\")\n)\n(?# due to how multiline regexps are matched we need a special case\nfor matching a newline character)\n| \\n\n",
+      "match": "(.+?)((?#.*and.*?inmulti-linematchneedspecialhandlingofnewlinesotherwiseSublimeTextandAtomwillmatchslightlydifferently.Theguardfornewlineshastobeseparatefromthelookaheadbecauseofspecial$matchingrule.)($\\n?)|(?=[\\\\\\}\\{]|'''|\"\"\"))(?#duetohowmultilineregexpsarematchedweneedaspecialcaseformatchinganewlinecharacter)|\\n",
       "name": "string.interpolated.python string.quoted.multi.python"
     },
     "fstring-normf-quoted-multi-line": {
@@ -1603,7 +1603,7 @@
       ]
     },
     "fstring-raw-multi-core": {
-      "match": "(?x)\n(.+?)\n(\n(?# .* and .*? in multi-line match need special handling of\nnewlines otherwise SublimeText and Atom will match slightly\ndifferently.\n\nThe guard for newlines has to be separate from the\nlookahead because of special $ matching rule.)\n($\\n?)\n|\n(?=[\\\\\\}\\{]|'''|\"\"\")\n)\n(?# due to how multiline regexps are matched we need a special case\nfor matching a newline character)\n| \\n\n",
+      "match": "(.+?)((?#.*and.*?inmulti-linematchneedspecialhandlingofnewlinesotherwiseSublimeTextandAtomwillmatchslightlydifferently.Theguardfornewlineshastobeseparatefromthelookaheadbecauseofspecial$matchingrule.)($\\n?)|(?=[\\\\\\}\\{]|'''|\"\"\"))(?#duetohowmultilineregexpsarematchedweneedaspecialcaseformatchinganewlinecharacter)|\\n",
       "name": "string.interpolated.python string.quoted.raw.multi.python"
     },
     "fstring-raw-quoted-multi-line": {
@@ -1677,7 +1677,7 @@
       ]
     },
     "fstring-raw-single-core": {
-      "match": "(?x)\n(.+?)\n(\n(?# .* and .*? in multi-line match need special handling of\nnewlines otherwise SublimeText and Atom will match slightly\ndifferently.\n\nThe guard for newlines has to be separate from the\nlookahead because of special $ matching rule.)\n($\\n?)\n|\n(?=[\\\\\\}\\{]|(['\"])|((?<!\\\\)\\n))\n)\n(?# due to how multiline regexps are matched we need a special case\nfor matching a newline character)\n| \\n\n",
+      "match": "(.+?)((?#.*and.*?inmulti-linematchneedspecialhandlingofnewlinesotherwiseSublimeTextandAtomwillmatchslightlydifferently.Theguardfornewlineshastobeseparatefromthelookaheadbecauseofspecial$matchingrule.)($\\n?)|(?=[\\\\\\}\\{]|(['\"])|((?<!\\\\)\\n)))(?#duetohowmultilineregexpsarematchedweneedaspecialcaseformatchinganewlinecharacter)|\\n",
       "name": "string.interpolated.python string.quoted.raw.single.python"
     },
     "fstring-single-brace": {
@@ -1688,7 +1688,7 @@
         }
       },
       "comment": "value interpolation using { ... }",
-      "end": "(?x)\n(\\})|(?=\\n)\n",
+      "end": "(\\})|(?=\\n)",
       "endCaptures": {
         "1": {
           "name": "constant.character.format.placeholder.other.python"
@@ -1704,7 +1704,7 @@
       ]
     },
     "fstring-single-core": {
-      "match": "(?x)\n(.+?)\n(\n(?# .* and .*? in multi-line match need special handling of\nnewlines otherwise SublimeText and Atom will match slightly\ndifferently.\n\nThe guard for newlines has to be separate from the\nlookahead because of special $ matching rule.)\n($\\n?)\n|\n(?=[\\\\\\}\\{]|(['\"])|((?<!\\\\)\\n))\n)\n(?# due to how multiline regexps are matched we need a special case\nfor matching a newline character)\n| \\n\n",
+      "match": "(.+?)((?#.*and.*?inmulti-linematchneedspecialhandlingofnewlinesotherwiseSublimeTextandAtomwillmatchslightlydifferently.Theguardfornewlineshastobeseparatefromthelookaheadbecauseofspecial$matchingrule.)($\\n?)|(?=[\\\\\\}\\{]|(['\"])|((?<!\\\\)\\n)))(?#duetohowmultilineregexpsarematchedweneedaspecialcaseformatchinganewlinecharacter)|\\n",
       "name": "string.interpolated.python string.quoted.single.python"
     },
     "fstring-terminator-multi": {
@@ -1726,7 +1726,7 @@
               "name": "storage.type.format.python"
             }
           },
-          "match": "(?x)\n( (?: =?) (?: ![rsa])? )\n( : \\w? [<>=^]? [-+ ]? \\#?\n\\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )(?=})\n"
+          "match": "((?:=?)(?:![rsa])?)(:\\w?[<>=^]?[-+\\s]?\\#?\\d*,?(\\.\\d+)?[bcdeEfFgGnosxX%]?)(?=})"
         },
         {
           "include": "#fstring-terminator-multi-tail"
@@ -1804,7 +1804,7 @@
               "name": "storage.type.format.python"
             }
           },
-          "match": "(?x)\n( (?: =?) (?: ![rsa])? )\n( : \\w? [<>=^]? [-+ ]? \\#?\n\\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )(?=})\n"
+          "match": "((?:=?)(?:![rsa])?)(:\\w?[<>=^]?[-+\\s]?\\#?\\d*,?(\\.\\d+)?[bcdeEfFgGnosxX%]?)(?=})"
         },
         {
           "include": "#fstring-terminator-single-tail"
@@ -1883,7 +1883,7 @@
               "name": "keyword.operator.unpacking.arguments.python"
             }
           },
-          "match": "(?x)\n(?:(?<=[,(])|^) \\s* (\\*{1,2})\n"
+          "match": "(?:(?<=[,(])|^)\\s*(\\*{1,2})"
         },
         {
           "include": "#lambda-incomplete"
@@ -1923,7 +1923,7 @@
       ]
     },
     "function-call": {
-      "begin": "(?x)\n\\b(?=\n([[:alpha:]_]\\w*) \\s* (\\()\n)\n",
+      "begin": "\\b(?=([[:alpha:]_]\\w*)\\s*(\\())",
       "comment": "Regular function call of the type \"name(args)\"",
       "end": "(\\))",
       "endCaptures": {
@@ -1945,7 +1945,7 @@
       ]
     },
     "function-declaration": {
-      "begin": "(?x)\n\\s*\n(?:\\b(async) \\s+)? \\b(def)\\s+\n(?=\n[[:alpha:]_][[:word:]]* \\s* \\(\n)\n",
+      "begin": "\\s*(?:\\b(async)\\s+)?\\b(def)\\s+(?=[[:alpha:]_][[:word:]]*\\s*\\()",
       "beginCaptures": {
         "1": {
           "name": "storage.type.function.async.python"
@@ -1985,7 +1985,7 @@
           "include": "#builtin-possible-callables"
         },
         {
-          "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n",
+          "match": "\\b([[:alpha:]_]\\w*)\\b",
           "name": "entity.name.function.python"
         }
       ]
@@ -1997,7 +1997,7 @@
         },
         {
           "comment": "Some color schemas support meta.function-call.generic scope",
-          "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n",
+          "match": "\\b([[:alpha:]_]\\w*)\\b",
           "name": "meta.function-call.generic.python"
         }
       ]
@@ -2035,7 +2035,7 @@
           "name": "keyword.control.import.python"
         }
       },
-      "match": "(?x)\n\\b(?:\n(\nand | assert | async | await | break | class | continue | def\n| del | elif | else | except | finally | for | from | global\n| if | in | is | (?<=\\.)lambda | lambda(?=\\s*[\\.=])\n| nonlocal | not | or | pass | raise | return | try | while | with\n| yield\n) | (\nas | import\n)\n)\\b\n"
+      "match": "\\b(?:(and|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|in|is|(?<=\\.)lambda|lambda(?=\\s*[\\.=])|nonlocal|not|or|pass|raise|return|try|while|with|yield)|(as|import))\\b"
     },
     "illegal-object-name": {
       "comment": "It's illegal to name class or function \"True\"",
@@ -2110,7 +2110,7 @@
           "name": "entity.other.inherited-class.python"
         }
       },
-      "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n"
+      "match": "\\b([[:alpha:]_]\\w*)\\b"
     },
     "inheritance-name": {
       "patterns": [
@@ -2128,7 +2128,7 @@
     "item-access": {
       "patterns": [
         {
-          "begin": "(?x)\n\\b(?=\n[[:alpha:]_]\\w* \\s* \\[\n)\n",
+          "begin": "\\b(?=[[:alpha:]_]\\w*\\s*\\[)",
           "end": "(\\])",
           "endCaptures": {
             "1": {
@@ -2181,7 +2181,7 @@
           "include": "#special-names"
         },
         {
-          "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n",
+          "match": "\\b([[:alpha:]_]\\w*)\\b",
           "name": "meta.indexed-name.python"
         }
       ]
@@ -2205,7 +2205,7 @@
           "match": "\\b(lambda)\\s*?(?=[,\\n]|$)"
         },
         {
-          "begin": "(?x)\n\\b (lambda) \\b\n",
+          "begin": "\\b(lambda)\\b",
           "beginCaptures": {
             "1": {
               "name": "storage.type.function.lambda.python"
@@ -2276,7 +2276,7 @@
       "name": "storage.type.function.lambda.python"
     },
     "lambda-parameter-with-default": {
-      "begin": "(?x)\n\\b\n([[:alpha:]_]\\w*) \\s* (=)\n",
+      "begin": "\\b([[:alpha:]_]\\w*)\\s*(=)",
       "beginCaptures": {
         "1": {
           "name": "variable.parameter.function.language.python"
@@ -2317,7 +2317,7 @@
               "name": "punctuation.separator.continuation.line.python"
             }
           },
-          "end": "(?x)\n(?=^\\s*$)\n|\n(?! (\\s* [rR]? (\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\"))\n|\n(\\G $)  (?# '\\G' is necessary for ST)\n)\n",
+          "end": "(?=^\\s*$)|(?!(\\s*[rR]?(\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\"))|(\\G$)(?#'\\G'isnecessaryforST))",
           "patterns": [
             {
               "include": "#regexp"
@@ -2385,7 +2385,7 @@
         }
       },
       "comment": "these methods have magic interpretation by python and are generally called\nindirectly through syntactic constructs\n",
-      "match": "(?x)\n\\b(\n__(?:\nabs | add | aenter | aexit | aiter | and | anext\n| await | bool | call | ceil | class_getitem\n| cmp | coerce | complex | contains | copy\n| deepcopy | del | delattr | delete | delitem\n| delslice | dir | div | divmod | enter | eq\n| exit | float | floor | floordiv | format | ge\n| get | getattr | getattribute | getinitargs\n| getitem | getnewargs | getslice | getstate | gt\n| hash | hex | iadd | iand | idiv | ifloordiv |\n| ilshift | imod | imul | index | init\n| instancecheck | int | invert | ior | ipow\n| irshift | isub | iter | itruediv | ixor | le\n| len | long | lshift | lt | missing | mod | mul\n| ne | neg | new | next | nonzero | oct | or | pos\n| pow | radd | rand | rdiv | rdivmod | reduce\n| reduce_ex | repr | reversed | rfloordiv |\n| rlshift | rmod | rmul | ror | round | rpow\n| rrshift | rshift | rsub | rtruediv | rxor | set\n| setattr | setitem | set_name | setslice\n| setstate | sizeof | str | sub | subclasscheck\n| truediv | trunc | unicode | xor | matmul\n| rmatmul | imatmul | init_subclass | set_name\n| fspath | bytes | prepare | length_hint\n)__\n)\\b\n"
+      "match": "\\b(__(?:abs|add|aenter|aexit|aiter|and|anext|await|bool|call|ceil|class_getitem|cmp|coerce|complex|contains|copy|deepcopy|del|delattr|delete|delitem|delslice|dir|div|divmod|enter|eq|exit|float|floor|floordiv|format|ge|get|getattr|getattribute|getinitargs|getitem|getnewargs|getslice|getstate|gt|hash|hex|iadd|iand|idiv|ifloordiv||ilshift|imod|imul|index|init|instancecheck|int|invert|ior|ipow|irshift|isub|iter|itruediv|ixor|le|len|long|lshift|lt|missing|mod|mul|ne|neg|new|next|nonzero|oct|or|pos|pow|radd|rand|rdiv|rdivmod|reduce|reduce_ex|repr|reversed|rfloordiv||rlshift|rmod|rmul|ror|round|rpow|rrshift|rshift|rsub|rtruediv|rxor|set|setattr|setitem|set_name|setslice|setstate|sizeof|str|sub|subclasscheck|truediv|trunc|unicode|xor|matmul|rmatmul|imatmul|init_subclass|set_name|fspath|bytes|prepare|length_hint)__)\\b"
     },
     "magic-names": {
       "patterns": [
@@ -2404,7 +2404,7 @@
         }
       },
       "comment": "magic variables which a class/module may have.",
-      "match": "(?x)\n\\b(\n__(?:\nall | annotations | bases | builtins | class\n| closure | code | debug | defaults | dict | doc | file | func\n| globals | kwdefaults | match_args | members | metaclass | methods\n| module | mro | mro_entries | name | qualname | post_init | self\n| signature | slots | subclasses | version | weakref | wrapped\n| classcell | spec | path | package | future | traceback\n)__\n)\\b\n"
+      "match": "\\b(__(?:all|annotations|bases|builtins|class|closure|code|debug|defaults|dict|doc|file|func|globals|kwdefaults|match_args|members|metaclass|methods|module|mro|mro_entries|name|qualname|post_init|self|signature|slots|subclasses|version|weakref|wrapped|classcell|spec|path|package|future|traceback)__)\\b"
     },
     "member-access": {
       "begin": "(\\.)\\s*(?!\\.)",
@@ -2413,7 +2413,7 @@
           "name": "punctuation.separator.period.python"
         }
       },
-      "end": "(?x)\n\n\n(?<=\\S)(?=\\W) |\n\n\n(^|(?<=\\s))(?=[^\\\\\\w\\s]) |\n$\n",
+      "end": "(?<=\\S)(?=\\W)|(^|(?<=\\s))(?=[^\\\\\\w\\s])|$",
       "name": "meta.member.access.python",
       "patterns": [
         {
@@ -2429,7 +2429,7 @@
     },
     "member-access-attribute": {
       "comment": "Highlight attribute access in otherwise non-specialized cases.",
-      "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n",
+      "match": "\\b([[:alpha:]_]\\w*)\\b",
       "name": "meta.attribute.python"
     },
     "member-access-base": {
@@ -2508,7 +2508,7 @@
           "name": "storage.type.number.python"
         }
       },
-      "match": "(?x)\n(?<![\\w\\.])\n(0[bB]) (_?[01])+\n\\b\n",
+      "match": "(?<![\\w\\.])(0[bB])(_?[01])+\\b",
       "name": "constant.numeric.bin.python"
     },
     "number-dec": {
@@ -2520,7 +2520,7 @@
           "name": "invalid.illegal.dec.python"
         }
       },
-      "match": "(?x)\n(?<![\\w\\.])(?:\n[1-9](?: _?[0-9] )*\n|\n0+\n|\n[0-9](?: _?[0-9] )* ([jJ])\n|\n0 ([0-9]+)(?![eE\\.])\n)\\b\n",
+      "match": "(?<![\\w\\.])(?:[1-9](?:_?[0-9])*|0+|[0-9](?:_?[0-9])*([jJ])|0([0-9]+)(?![eE\\.]))\\b",
       "name": "constant.numeric.dec.python"
     },
     "number-float": {
@@ -2529,7 +2529,7 @@
           "name": "storage.type.imaginary.number.python"
         }
       },
-      "match": "(?x)\n(?<! \\w)(?:\n(?:\n\\.[0-9](?: _?[0-9] )*\n|\n[0-9](?: _?[0-9] )* \\. [0-9](?: _?[0-9] )*\n|\n[0-9](?: _?[0-9] )* \\.\n) (?: [eE][+-]?[0-9](?: _?[0-9] )* )?\n|\n[0-9](?: _?[0-9] )* (?: [eE][+-]?[0-9](?: _?[0-9] )* )\n)([jJ])?\\b\n",
+      "match": "(?<!\\w)(?:(?:\\.[0-9](?:_?[0-9])*|[0-9](?:_?[0-9])*\\.[0-9](?:_?[0-9])*|[0-9](?:_?[0-9])*\\.)(?:[eE][+-]?[0-9](?:_?[0-9])*)?|[0-9](?:_?[0-9])*(?:[eE][+-]?[0-9](?:_?[0-9])*))([jJ])?\\b",
       "name": "constant.numeric.float.python"
     },
     "number-hex": {
@@ -2538,7 +2538,7 @@
           "name": "storage.type.number.python"
         }
       },
-      "match": "(?x)\n(?<![\\w\\.])\n(0[xX]) (_?[0-9a-fA-F])+\n\\b\n",
+      "match": "(?<![\\w\\.])(0[xX])(_?[0-9a-fA-F])+\\b",
       "name": "constant.numeric.hex.python"
     },
     "number-long": {
@@ -2548,7 +2548,7 @@
         }
       },
       "comment": "this is to support python2 syntax for long ints",
-      "match": "(?x)\n(?<![\\w\\.])\n([1-9][0-9]* | 0) ([lL])\n\\b\n",
+      "match": "(?<![\\w\\.])([1-9][0-9]*|0)([lL])\\b",
       "name": "constant.numeric.bin.python"
     },
     "number-oct": {
@@ -2557,11 +2557,11 @@
           "name": "storage.type.number.python"
         }
       },
-      "match": "(?x)\n(?<![\\w\\.])\n(0[oO]) (_?[0-7])+\n\\b\n",
+      "match": "(?<![\\w\\.])(0[oO])(_?[0-7])+\\b",
       "name": "constant.numeric.oct.python"
     },
     "odd-function-call": {
-      "begin": "(?x)\n(?<= \\] | \\) ) \\s*\n(?=\\()\n",
+      "begin": "(?<=\\]|\\))\\s*(?=\\()",
       "comment": "A bit obscured function call where there may have been an\narbitrary number of other operations to get the function.\nE.g. \"arr[idx](args)\"\n",
       "end": "(\\))",
       "endCaptures": {
@@ -2596,7 +2596,7 @@
           "name": "keyword.operator.assignment.python"
         }
       },
-      "match": "(?x)\n\\b(?<!\\.)\n(?:\n(and | or | not | in | is)                         (?# 1)\n|\n(for | if | else | await | (?:yield(?:\\s+from)?))  (?# 2)\n)\n(?!\\s*:)\\b\n\n| (<< | >> | & | \\| | \\^ | ~)                          (?# 3)\n\n| (\\*\\* | \\* | \\+ | - | % | // | / | @)                (?# 4)\n\n| (!= | == | >= | <= | < | >)                          (?# 5)\n\n| (:=)                                                 (?# 6)\n"
+      "match": "\\b(?<!\\.)(?:(and|or|not|in|is)(?#1)|(for|if|else|await|(?:yield(?:\\s+from)?))(?#2))(?!\\s*:)\\b|(<<|>>|&|\\||\\^|~)(?#3)|(\\*\\*|\\*|\\+|-|%|//|/|@)(?#4)|(!=|==|>=|<=|<|>)(?#5)|(:=)(?#6)"
     },
     "parameter-special": {
       "captures": {
@@ -2613,7 +2613,7 @@
           "name": "punctuation.separator.parameters.python"
         }
       },
-      "match": "(?x)\n\\b ((self)|(cls)) \\b \\s*(?:(,)|(?=\\)))\n"
+      "match": "\\b((self)|(cls))\\b\\s*(?:(,)|(?=\\)))"
     },
     "parameters": {
       "begin": "(\\()",
@@ -2659,7 +2659,7 @@
               "name": "punctuation.separator.parameters.python"
             }
           },
-          "match": "(?x)\n([[:alpha:]_]\\w*)\n\\s* (?: (,) | (?=[)#\\n=]))\n"
+          "match": "([[:alpha:]_]\\w*)\\s*(?:(,)|(?=[)#\\n=]))"
         },
         {
           "include": "#comments"
@@ -2712,7 +2712,7 @@
           "name": "support.other.parenthesis.regexp punctuation.parenthesis.backreference.named.end.regexp"
         }
       },
-      "match": "(?x)\n(\\()  (\\?P= \\w+(?:\\s+[[:alnum:]]+)?)  (\\))\n",
+      "match": "(\\()(\\?P=\\w+(?:\\s+[[:alnum:]]+)?)(\\))",
       "name": "meta.backreference.named.regexp"
     },
     "regexp-backreference-number": {
@@ -2854,7 +2854,7 @@
       "name": "constant.character.escape.regexp"
     },
     "regexp-escape-character": {
-      "match": "(?x)\n\\\\ (\nx[0-9A-Fa-f]{2}\n| 0[0-7]{1,2}\n| [0-7]{3}\n)\n",
+      "match": "\\\\(x[0-9A-Fa-f]{2}|0[0-7]{1,2}|[0-7]{3})",
       "name": "constant.character.escape.regexp"
     },
     "regexp-escape-sequence": {
@@ -2881,7 +2881,7 @@
       "name": "support.other.escape.special.regexp"
     },
     "regexp-escape-unicode": {
-      "match": "(?x)\n\\\\ (\nu[0-9A-Fa-f]{4}\n| U[0-9A-Fa-f]{8}\n)\n",
+      "match": "\\\\(u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})",
       "name": "constant.character.unicode.regexp"
     },
     "regexp-flags": {
@@ -2889,7 +2889,7 @@
       "name": "storage.modifier.flag.regexp"
     },
     "regexp-quantifier": {
-      "match": "(?x)\n\\{(\n\\d+ | \\d+,(\\d+)? | ,\\d+\n)\\}\n",
+      "match": "\\{(\\d+|\\d+,(\\d+)?|,\\d+)\\}",
       "name": "keyword.operator.quantifier.regexp"
     },
     "regexp-single-one-line": {
@@ -3000,7 +3000,7 @@
     "single-one-regexp-character-set": {
       "patterns": [
         {
-          "match": "(?x)\n\\[ \\^? \\] (?! .*?\\])\n"
+          "match": "\\[\\s\\^?\\s\\](?!.*?\\])"
         },
         {
           "begin": "(\\[)(\\^)?(\\])?",
@@ -3229,7 +3229,7 @@
       ]
     },
     "single-one-regexp-named-group": {
-      "begin": "(?x)\n(\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "begin": "(\\()(\\?P<\\w+(?:\\s+[[:alnum:]]+)?>)",
       "beginCaptures": {
         "1": {
           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
@@ -3301,7 +3301,7 @@
     "single-three-regexp-character-set": {
       "patterns": [
         {
-          "match": "(?x)\n\\[ \\^? \\] (?! .*?\\])\n"
+          "match": "\\[\\s\\^?\\s\\](?!.*?\\])"
         },
         {
           "begin": "(\\[)(\\^)?(\\])?",
@@ -3548,7 +3548,7 @@
       ]
     },
     "single-three-regexp-named-group": {
-      "begin": "(?x)\n(\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "begin": "(\\()(\\?P<\\w+(?:\\s+[[:alnum:]]+)?>)",
       "beginCaptures": {
         "1": {
           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
@@ -3627,7 +3627,7 @@
       ]
     },
     "special-names": {
-      "match": "(?x)\n\\b\n\n\n\n\n\n(\n_* [[:upper:]] [_\\d]* [[:upper:]]\n)\n[[:upper:]\\d]* (_\\w*)?\n\\b\n",
+      "match": "\\b(_*[[:upper:]][_\\d]*[[:upper:]])[[:upper:]\\d]*(_\\w*)?\\b",
       "name": "constant.other.caps.python"
     },
     "special-variables": {
@@ -3639,7 +3639,7 @@
           "name": "variable.language.special.cls.python"
         }
       },
-      "match": "(?x)\n\\b (?<!\\.) (?:\n(self) | (cls)\n)\\b\n"
+      "match": "\\b(?<!\\.)(?:(self)|(cls))\\b"
     },
     "statement": {
       "patterns": [
@@ -3689,11 +3689,11 @@
           "name": "keyword.control.import.python"
         },
         {
-          "match": "(?x)\n\\b(?<!\\.)(\nasync | continue | del | assert | break | finally | for\n| from | elif | else | if | except | pass | raise\n| return | try | while | with\n)\\b\n",
+          "match": "\\b(?<!\\.)(async|continue|del|assert|break|finally|for|from|elif|else|if|except|pass|raise|return|try|while|with)\\b",
           "name": "keyword.control.flow.python"
         },
         {
-          "match": "(?x)\n\\b(?<!\\.)(\nglobal | nonlocal\n)\\b\n",
+          "match": "\\b(?<!\\.)(global|nonlocal)\\b",
           "name": "storage.modifier.declaration.python"
         },
         {
@@ -3706,7 +3706,7 @@
               "name": "keyword.control.flow.python"
             }
           },
-          "match": "(?x)\n^\\s*(\ncase | match\n)(?=\\s*([-+\\w\\d(\\[{'\":#]|$))\\b\n"
+          "match": "^\\s*(case|match)(?=\\s*([-+\\w\\d(\\[{'\":#]|$))\\b"
         }
       ]
     },
@@ -3822,7 +3822,7 @@
               "name": "storage.type.format.python"
             }
           },
-          "match": "(?x)\n(\n{{ | }}\n| (?:\n{\n\\w* (\\.[[:alpha:]_]\\w* | \\[[^\\]'\"]+\\])*\n(![rsa])?\n( : \\w? [<>=^]? [-+ ]? \\#?\n\\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )?\n})\n)\n",
+          "match": "({{|}}|(?:{\\w*(\\.[[:alpha:]_]\\w*|\\[[^\\]'\"]+\\])*(![rsa])?(:\\w?[<>=^]?[-+\\s]?\\#?\\d*,?(\\.\\d+)?[bcdeEfFgGnosxX%]?)?}))",
           "name": "meta.format.brace.python"
         },
         {
@@ -3837,7 +3837,7 @@
               "name": "storage.type.format.python"
             }
           },
-          "match": "(?x)\n(\n{\n\\w* (\\.[[:alpha:]_]\\w* | \\[[^\\]'\"]+\\])*\n(![rsa])?\n(:)\n[^'\"{}\\n]* (?:\n\\{ [^'\"}\\n]*? \\} [^'\"{}\\n]*\n)*\n}\n)\n",
+          "match": "({\\w*(\\.[[:alpha:]_]\\w*|\\[[^\\]'\"]+\\])*(![rsa])?(:)[^'\"{}\\n]*(?:\\{[^'\"}\\n]*?\\}[^'\"{}\\n]*)*})",
           "name": "meta.format.brace.python"
         }
       ]
@@ -3864,7 +3864,7 @@
           "name": "constant.character.format.placeholder.other.python"
         }
       },
-      "match": "(?x)\n(\n% (\\([\\w\\s]*\\))?\n[-+#0 ]*\n(\\d+|\\*)? (\\.(\\d+|\\*))?\n([hlL])?\n[diouxXeEfFgGcrsab%]\n)\n",
+      "match": "(%(\\([\\w\\s]*\\))?[-+#0\\s]*(\\d+|\\*)?(\\.(\\d+|\\*))?([hlL])?[diouxXeEfFgGcrsab%])",
       "name": "meta.format.percent.python"
     },
     "string-line-continuation": {
@@ -3872,7 +3872,7 @@
       "name": "constant.language.python"
     },
     "string-multi-bad-brace1-formatting-raw": {
-      "begin": "(?x)\n(?= \\{%\n( .*? (?!'''|\"\"\") )\n%\\}\n)\n",
+      "begin": "(?=\\{%(.*?(?!'''|\"\"\"))%\\})",
       "comment": "template using {% ... %}",
       "end": "(?='''|\"\"\")",
       "patterns": [
@@ -3882,7 +3882,7 @@
       ]
     },
     "string-multi-bad-brace1-formatting-unicode": {
-      "begin": "(?x)\n(?= \\{%\n( .*? (?!'''|\"\"\") )\n%\\}\n)\n",
+      "begin": "(?=\\{%(.*?(?!'''|\"\"\"))%\\})",
       "comment": "template using {% ... %}",
       "end": "(?='''|\"\"\")",
       "patterns": [
@@ -3898,7 +3898,7 @@
       ]
     },
     "string-multi-bad-brace2-formatting-raw": {
-      "begin": "(?x)\n(?!\\{\\{)\n(?= \\{ (\n\\w*? (?!'''|\"\"\") [^!:\\.\\[}\\w]\n)\n.*?(?!'''|\"\"\")\n\\}\n)\n",
+      "begin": "(?!\\{\\{)(?=\\{(\\w*?(?!'''|\"\"\")[^!:\\.\\[}\\w]).*?(?!'''|\"\"\")\\})",
       "comment": "odd format or format-like syntax",
       "end": "(?='''|\"\"\")",
       "patterns": [
@@ -3911,7 +3911,7 @@
       ]
     },
     "string-multi-bad-brace2-formatting-unicode": {
-      "begin": "(?x)\n(?!\\{\\{)\n(?= \\{ (\n\\w*? (?!'''|\"\"\") [^!:\\.\\[}\\w]\n)\n.*?(?!'''|\"\"\")\n\\}\n)\n",
+      "begin": "(?!\\{\\{)(?=\\{(\\w*?(?!'''|\"\"\")[^!:\\.\\[}\\w]).*?(?!'''|\"\"\")\\})",
       "comment": "odd format or format-like syntax",
       "end": "(?='''|\"\"\")",
       "patterns": [
@@ -4139,7 +4139,7 @@
       ]
     },
     "string-single-bad-brace1-formatting-raw": {
-      "begin": "(?x)\n(?= \\{%\n( .*? (?!(['\"])|((?<!\\\\)\\n)) )\n%\\}\n)\n",
+      "begin": "(?=\\{%(.*?(?!(['\"])|((?<!\\\\)\\n)))%\\})",
       "comment": "template using {% ... %}",
       "end": "(?=(['\"])|((?<!\\\\)\\n))",
       "patterns": [
@@ -4149,7 +4149,7 @@
       ]
     },
     "string-single-bad-brace1-formatting-unicode": {
-      "begin": "(?x)\n(?= \\{%\n( .*? (?!(['\"])|((?<!\\\\)\\n)) )\n%\\}\n)\n",
+      "begin": "(?=\\{%(.*?(?!(['\"])|((?<!\\\\)\\n)))%\\})",
       "comment": "template using {% ... %}",
       "end": "(?=(['\"])|((?<!\\\\)\\n))",
       "patterns": [
@@ -4165,7 +4165,7 @@
       ]
     },
     "string-single-bad-brace2-formatting-raw": {
-      "begin": "(?x)\n(?!\\{\\{)\n(?= \\{ (\n\\w*? (?!(['\"])|((?<!\\\\)\\n)) [^!:\\.\\[}\\w]\n)\n.*?(?!(['\"])|((?<!\\\\)\\n))\n\\}\n)\n",
+      "begin": "(?!\\{\\{)(?=\\{(\\w*?(?!(['\"])|((?<!\\\\)\\n))[^!:\\.\\[}\\w]).*?(?!(['\"])|((?<!\\\\)\\n))\\})",
       "comment": "odd format or format-like syntax",
       "end": "(?=(['\"])|((?<!\\\\)\\n))",
       "patterns": [
@@ -4178,7 +4178,7 @@
       ]
     },
     "string-single-bad-brace2-formatting-unicode": {
-      "begin": "(?x)\n(?!\\{\\{)\n(?= \\{ (\n\\w*? (?!(['\"])|((?<!\\\\)\\n)) [^!:\\.\\[}\\w]\n)\n.*?(?!(['\"])|((?<!\\\\)\\n))\n\\}\n)\n",
+      "begin": "(?!\\{\\{)(?=\\{(\\w*?(?!(['\"])|((?<!\\\\)\\n))[^!:\\.\\[}\\w]).*?(?!(['\"])|((?<!\\\\)\\n))\\})",
       "comment": "odd format or format-like syntax",
       "end": "(?=(['\"])|((?<!\\\\)\\n))",
       "patterns": [