tm-grammars 1.17.4 → 1.17.6

package/grammars/vyper.json

@@ -14,7 +14,7 @@
   ],
   "repository": {
     "annotated-parameter": {
-      "begin": "(?x)\n\\b\n([[:alpha:]_]\\w*) \\s* (:)\n",
+      "begin": "\\b([A-Za-z_]\\w*)\\s*(:)",
       "beginCaptures": {
         "1": {
           "name": "variable.parameter.function.language.python"
@@ -40,7 +40,7 @@
       ]
     },
     "assignment-operator": {
-      "match": "(?x)\n<<= | >>= | //= | \\*\\*=\n| \\+= | -= | /= | @=\n| \\*= | %= | ~= | \\^= | &= | \\|=\n| =(?!=)\n",
+      "match": "<<=|>>=|//=|\\*\\*=|\\+=|-=|/=|@=|\\*=|%=|~=|\\^=|&=|\\|=|=(?!=)",
       "name": "keyword.operator.assignment.python"
     },
     "backticks": {
@@ -73,37 +73,37 @@
       ]
     },
     "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"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nabi_encode | abi_decode | _abi_encode | _abi_decode | floor | ceil | convert | slice | len | concat | sha256 | method_id | keccak256 | ecrecover | ecadd | ecmul | extract32 | as_wei_value | raw_call | blockhash | blobhash | bitwise_and | bitwise_or | bitwise_xor | bitwise_not | uint256_addmod | uint256_mulmod | unsafe_add | unsafe_sub | unsafe_mul | unsafe_div | pow_mod256 | uint2str | isqrt | sqrt | shift | create_minimal_proxy_to | create_forwarder_to | create_copy_of | create_from_blueprint | min | max | empty | abs | min_value | max_value | epsilon)\\b\n",
+          "match": "(?<!\\.)\\b(abi_encode|abi_decode|_abi_encode|_abi_decode|floor|ceil|convert|slice|len|concat|sha256|method_id|keccak256|ecrecover|ecadd|ecmul|extract32|as_wei_value|raw_call|blockhash|blobhash|bitwise_and|bitwise_or|bitwise_xor|bitwise_not|uint256_addmod|uint256_mulmod|unsafe_add|unsafe_sub|unsafe_mul|unsafe_div|pow_mod256|uint2str|isqrt|sqrt|shift|create_minimal_proxy_to|create_forwarder_to|create_copy_of|create_from_blueprint|min|max|empty|abs|min_value|max_value|epsilon)\\b",
           "name": "support.function.builtin.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nsend | print | breakpoint | selfdestruct | raw_call | raw_log | raw_revert | create_minimal_proxy_to | create_forwarder_to | create_copy_of | create_from_blueprint)\\b\n",
+          "match": "(?<!\\.)\\b(send|print|breakpoint|selfdestruct|raw_call|raw_log|raw_revert|create_minimal_proxy_to|create_forwarder_to|create_copy_of|create_from_blueprint)\\b",
           "name": "support.function.builtin.lowlevel.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nstruct | enum | flag | event | interface | HashMap | DynArray | Bytes | String)\\b\n",
+          "match": "(?<!\\.)\\b(struct|enum|flag|event|interface|HashMap|DynArray|Bytes|String)\\b",
           "name": "support.type.reference.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nnonreentrant | internal | view | pure | private | immutable | constant)\\b\n",
+          "match": "(?<!\\.)\\b(nonreentrant|internal|view|pure|private|immutable|constant)\\b",
           "name": "support.function.builtin.modifiers.safe.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\ndeploy | nonpayable | payable | external | modifying)\\b\n",
+          "match": "(?<!\\.)\\b(deploy|nonpayable|payable|external|modifying)\\b",
           "name": "support.function.builtin.modifiers.unsafe.vyper"
         }
       ]
@@ -121,29 +121,29 @@
     "builtin-types": {
       "patterns": [
         {
-          "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"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nuint248 | HashMap | bytes22 | int88 | bytes24 | bytes11 | int24 | bytes28 | bytes19 | uint136 | decimal | uint40 | uint168 | uint120 | int112 | bytes4 | uint192 | String | int104 | bytes29 | int120 | uint232 | bytes8 | bool | bytes14 | int56 | uint32 | int232 | uint48 | bytes17 | bytes12 | uint24 | int160 | int72 | int256 | uint56 | uint80 | uint104 | uint144 | uint200 | bytes20 | uint160 | bytes18 | bytes16 | uint8 | int40 | Bytes | uint72 | bytes2 | bytes23 | int48 | bytes6 | bytes13 | int192 | bytes15 | uint96 | address | uint64 | uint88 | bytes7 | int64 | bytes32 | bytes30 | int176 | int248 | uint128 | int8 | int136 | int216 | bytes31 | int144 | bytes1 | int168 | bytes5 | uint216 | int200 | bytes25 | uint112 | int128 | bytes10 | uint16 | DynArray | int16 | int32 | int208 | int184 | bytes9 | int224 | bytes3 | int80 | uint152 | bytes21 | int96 | uint256 | uint176 | uint240 | bytes27 | bytes26 | int240 | uint224 | uint184 | uint208 | int152)\\b\n",
+          "match": "(?<!\\.)\\b(uint248|HashMap|bytes22|int88|bytes24|bytes11|int24|bytes28|bytes19|uint136|decimal|uint40|uint168|uint120|int112|bytes4|uint192|String|int104|bytes29|int120|uint232|bytes8|bool|bytes14|int56|uint32|int232|uint48|bytes17|bytes12|uint24|int160|int72|int256|uint56|uint80|uint104|uint144|uint200|bytes20|uint160|bytes18|bytes16|uint8|int40|Bytes|uint72|bytes2|bytes23|int48|bytes6|bytes13|int192|bytes15|uint96|address|uint64|uint88|bytes7|int64|bytes32|bytes30|int176|int248|uint128|int8|int136|int216|bytes31|int144|bytes1|int168|bytes5|uint216|int200|bytes25|uint112|int128|bytes10|uint16|DynArray|int16|int32|int208|int184|bytes9|int224|bytes3|int80|uint152|bytes21|int96|uint256|uint176|uint240|bytes27|bytes26|int240|uint224|uint184|uint208|int152)\\b",
           "name": "support.type.basetype.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nmax_int128 | min_int128 | nonlocal | babbage | _default_ | ___init___ | await | indexed | ____init____ | true | constant | with | from | nonpayable | finally | enum | zero_wei | del | for | ____default____ | if | none | or | global | def | not | class | twei | struct | mwei | empty_bytes32 | nonreentrant | transient | false | assert | event | pass | finney | init | lovelace | min_decimal | shannon | public | external | internal | flagunreachable | _init_ | return | in | and | raise | try | gwei | break | zero_address | pwei | range | wei | while | ada | yield | as | immutable | continue | async | lambda | default | is | szabo | kwei | import | max_uint256 | elif | ___default___ | else | except | max_decimal | interface | payable | ether)\\b\n",
+          "match": "(?<!\\.)\\b(max_int128|min_int128|nonlocal|babbage|_default_|___init___|await|indexed|____init____|true|constant|with|from|nonpayable|finally|enum|zero_wei|del|for|____default____|if|none|or|global|def|not|class|twei|struct|mwei|empty_bytes32|nonreentrant|transient|false|assert|event|pass|finney|init|lovelace|min_decimal|shannon|public|external|internal|flagunreachable|_init_|return|in|and|raise|try|gwei|break|zero_address|pwei|range|wei|while|ada|yield|as|immutable|continue|async|lambda|default|is|szabo|kwei|import|max_uint256|elif|___default___|else|except|max_decimal|interface|payable|ether)\\b",
           "name": "support.type.keywords.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nZERO_ADDRESS | EMPTY_BYTES32 | MAX_INT128 | MIN_INT128 | MAX_DECIMAL | MIN_DECIMAL | MIN_UINT256 | MAX_UINT256\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(ZERO_ADDRESS|EMPTY_BYTES32|MAX_INT128|MIN_INT128|MAX_DECIMAL|MIN_DECIMAL|MIN_UINT256|MAX_UINT256(?#Although'super'isnotatype,it'srelatedtotypes,andisspecialenoughtobehighlighteddifferentlyfromotherbuilt-ins)|super)\\b",
           "name": "support.type.constant.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nimplements | uses | initializes | exports)\\b\n",
+          "match": "(?<!\\.)\\b(implements|uses|initializes|exports)\\b",
           "name": "entity.other.inherited-class.modules.vyper"
         }
       ]
     },
     "call-wrapper-inheritance": {
-      "begin": "(?x)\n\\b(?=\n([[:alpha:]_]\\w*) \\s* (\\()\n)\n",
+      "begin": "\\b(?=([A-Za-z_]\\w*)\\s*(\\())",
       "comment": "same as a function call, but in inheritance context",
       "end": "(\\))",
       "endCaptures": {
@@ -164,7 +164,7 @@
     "class-declaration": {
       "patterns": [
         {
-          "begin": "(?x)\n\\s*(class)\\s+\n(?=\n[[:alpha:]_]\\w* \\s* (:|\\()\n)\n",
+          "begin": "\\s*(class)\\s+(?=[A-Za-z_]\\w*\\s*(:|\\())",
           "beginCaptures": {
             "1": {
               "name": "storage.type.class.python"
@@ -248,7 +248,7 @@
           "name": "keyword.operator.assignment.python"
         }
       },
-      "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\s*(=)(?!=)\n"
+      "match": "\\b([A-Za-z_]\\w*)\\s*(=)(?!=)"
     },
     "class-name": {
       "patterns": [
@@ -259,7 +259,7 @@
           "include": "#builtin-possible-callables"
         },
         {
-          "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n",
+          "match": "\\b([A-Za-z_]\\w*)\\b",
           "name": "entity.name.type.class.python"
         }
       ]
@@ -275,7 +275,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"
@@ -289,11 +289,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"
             },
             {
@@ -301,7 +301,7 @@
               "name": "comment.typehint.punctuation.notation.python"
             },
             {
-              "match": "([[:alpha:]_]\\w*)",
+              "match": "([A-Za-z_]\\w*)",
               "name": "comment.typehint.variable.notation.python"
             }
           ]
@@ -380,7 +380,7 @@
       ]
     },
     "decorator": {
-      "begin": "(?x)\n^\\s*\n((@)) \\s* (?=[[:alpha:]_]\\w*)\n",
+      "begin": "^\\s*((@))\\s*(?=[A-Za-z_]\\w*)",
       "beginCaptures": {
         "1": {
           "name": "entity.name.function.decorator.python"
@@ -389,7 +389,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"
@@ -422,7 +422,7 @@
               "name": "punctuation.separator.period.python"
             }
           },
-          "match": "(?x)\n([[:alpha:]_]\\w*) | (\\.)\n",
+          "match": "([A-Za-z_]\\w*)|(\\.)",
           "name": "entity.name.function.decorator.python"
         },
         {
@@ -434,7 +434,7 @@
               "name": "invalid.illegal.decorator.python"
             }
           },
-          "match": "(?x)\n\\s* ([^([:alpha:]\\s_\\.#\\\\] .*?) (?=\\#|$)\n",
+          "match": "\\s*([^(A-Za-z\\s_\\.#\\\\].*?)(?=\\#|$)",
           "name": "invalid.illegal.decorator.python"
         }
       ]
@@ -572,7 +572,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]?(\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\"))",
@@ -587,7 +587,7 @@
     "double-one-regexp-character-set": {
       "patterns": [
         {
-          "match": "(?x)\n\\[ \\^? \\] (?! .*?\\])\n"
+          "match": "\\[\\s\\^?\\s\\](?!.*?\\])"
         },
         {
           "begin": "(\\[)(\\^)?(\\])?",
@@ -648,7 +648,7 @@
       ]
     },
     "double-one-regexp-conditional": {
-      "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
+      "begin": "(\\()\\?\\((\\w+(?:\\s+[0-9A-Za-z]+)?|\\d+)\\)",
       "beginCaptures": {
         "0": {
           "name": "keyword.operator.conditional.regexp"
@@ -816,7 +816,7 @@
       ]
     },
     "double-one-regexp-named-group": {
-      "begin": "(?x)\n(\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "begin": "(\\()(\\?P<\\w+(?:\\s+[0-9A-Za-z]+)?>)",
       "beginCaptures": {
         "1": {
           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
@@ -888,7 +888,7 @@
     "double-three-regexp-character-set": {
       "patterns": [
         {
-          "match": "(?x)\n\\[ \\^? \\] (?! .*?\\])\n"
+          "match": "\\[\\s\\^?\\s\\](?!.*?\\])"
         },
         {
           "begin": "(\\[)(\\^)?(\\])?",
@@ -949,7 +949,7 @@
       ]
     },
     "double-three-regexp-conditional": {
-      "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
+      "begin": "(\\()\\?\\((\\w+(?:\\s+[0-9A-Za-z]+)?|\\d+)\\)",
       "beginCaptures": {
         "0": {
           "name": "keyword.operator.conditional.regexp"
@@ -1135,7 +1135,7 @@
       ]
     },
     "double-three-regexp-named-group": {
-      "begin": "(?x)\n(\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "begin": "(\\()(\\?P<\\w+(?:\\s+[0-9A-Za-z]+)?>)",
       "beginCaptures": {
         "1": {
           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
@@ -1218,13 +1218,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"
         }
       ]
@@ -1240,7 +1240,7 @@
         },
         {
           "comment": "Tokenize identifiers to help linters",
-          "match": "(?x) \\b ([[:alpha:]_]\\w*) \\b"
+          "match": "\\b([A-Za-z_]\\w*)\\b"
         }
       ]
     },
@@ -1352,7 +1352,7 @@
         },
         {
           "comment": "Tokenize identifiers to help linters",
-          "match": "(?x) \\b ([[:alpha:]_]\\w*) \\b"
+          "match": "\\b([A-Za-z_]\\w*)\\b"
         }
       ]
     },
@@ -1373,7 +1373,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": {
@@ -1543,7 +1543,7 @@
         }
       },
       "comment": "value interpolation using { ... }",
-      "end": "(?x)\n(\\})\n",
+      "end": "(\\})",
       "endCaptures": {
         "1": {
           "name": "constant.character.format.placeholder.other.python"
@@ -1559,7 +1559,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": {
@@ -1649,7 +1649,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": {
@@ -1723,7 +1723,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": {
@@ -1734,7 +1734,7 @@
         }
       },
       "comment": "value interpolation using { ... }",
-      "end": "(?x)\n(\\})|(?=\\n)\n",
+      "end": "(\\})|(?=\\n)",
       "endCaptures": {
         "1": {
           "name": "constant.character.format.placeholder.other.python"
@@ -1750,7 +1750,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": {
@@ -1772,7 +1772,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"
@@ -1850,7 +1850,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"
@@ -1929,7 +1929,7 @@
               "name": "keyword.operator.unpacking.arguments.python"
             }
           },
-          "match": "(?x)\n(?:(?<=[,(])|^) \\s* (\\*{1,2})\n"
+          "match": "(?:(?<=[,(])|^)\\s*(\\*{1,2})"
         },
         {
           "include": "#lambda-incomplete"
@@ -1946,7 +1946,7 @@
               "name": "keyword.operator.assignment.python"
             }
           },
-          "match": "\\b([[:alpha:]_]\\w*)\\s*(=)(?!=)"
+          "match": "\\b([A-Za-z_]\\w*)\\s*(=)(?!=)"
         },
         {
           "match": "=(?!=)",
@@ -1969,7 +1969,7 @@
       ]
     },
     "function-call": {
-      "begin": "(?x)\n\\b(?=\n([[:alpha:]_]\\w*) \\s* (\\()\n)\n",
+      "begin": "\\b(?=([A-Za-z_]\\w*)\\s*(\\())",
       "comment": "Regular function call of the type \"name(args)\"",
       "end": "(\\))",
       "endCaptures": {
@@ -1991,7 +1991,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+(?=[A-Za-z_][\\w]*\\s*\\()",
       "beginCaptures": {
         "1": {
           "name": "storage.type.function.async.python"
@@ -2025,11 +2025,11 @@
     "function-def-name": {
       "patterns": [
         {
-          "match": "(?x)\n\\b (__default__) \\b\n",
+          "match": "\\b(__default__)\\b",
           "name": "entity.name.function.fallback.vyper"
         },
         {
-          "match": "(?x)\n\\b (__init__) \\b\n",
+          "match": "\\b(__init__)\\b",
           "name": "entity.name.function.constructor.vyper"
         },
         {
@@ -2039,7 +2039,7 @@
           "include": "#builtin-possible-callables"
         },
         {
-          "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n",
+          "match": "\\b([A-Za-z_]\\w*)\\b",
           "name": "entity.name.function.python"
         }
       ]
@@ -2051,7 +2051,7 @@
         },
         {
           "comment": "Some color schemas support meta.function-call.generic scope",
-          "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n",
+          "match": "\\b([A-Za-z_]\\w*)\\b",
           "name": "meta.function-call.generic.python"
         }
       ]
@@ -2089,7 +2089,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\"",
@@ -2164,7 +2164,7 @@
           "name": "entity.other.inherited-class.python"
         }
       },
-      "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n"
+      "match": "\\b([A-Za-z_]\\w*)\\b"
     },
     "inheritance-name": {
       "patterns": [
@@ -2182,7 +2182,7 @@
     "item-access": {
       "patterns": [
         {
-          "begin": "(?x)\n\\b(?=\n[[:alpha:]_]\\w* \\s* \\[\n)\n",
+          "begin": "\\b(?=[A-Za-z_]\\w*\\s*\\[)",
           "end": "(\\])",
           "endCaptures": {
             "1": {
@@ -2235,7 +2235,7 @@
           "include": "#special-names"
         },
         {
-          "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n",
+          "match": "\\b([A-Za-z_]\\w*)\\b",
           "name": "meta.indexed-name.python"
         },
         {
@@ -2262,7 +2262,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"
@@ -2300,7 +2300,7 @@
                   "name": "punctuation.separator.parameters.python"
                 }
               },
-              "match": "([[:alpha:]_]\\w*)\\s*(?:(,)|(?=:|$))"
+              "match": "([A-Za-z_]\\w*)\\s*(?:(,)|(?=:|$))"
             },
             {
               "include": "#comments"
@@ -2333,7 +2333,7 @@
       "name": "storage.type.function.lambda.python"
     },
     "lambda-parameter-with-default": {
-      "begin": "(?x)\n\\b\n([[:alpha:]_]\\w*) \\s* (=)\n",
+      "begin": "\\b([A-Za-z_]\\w*)\\s*(=)",
       "beginCaptures": {
         "1": {
           "name": "variable.parameter.function.language.python"
@@ -2374,7 +2374,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"
@@ -2442,7 +2442,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": [
@@ -2461,7 +2461,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*(?!\\.)",
@@ -2470,7 +2470,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": [
         {
@@ -2486,7 +2486,7 @@
     },
     "member-access-attribute": {
       "comment": "Highlight attribute access in otherwise non-specialized cases.",
-      "match": "(?x)\n\\b ([[:alpha:]_]\\w*) \\b\n",
+      "match": "\\b([A-Za-z_]\\w*)\\b",
       "name": "meta.attribute.python"
     },
     "member-access-base": {
@@ -2568,7 +2568,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": {
@@ -2580,7 +2580,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": {
@@ -2589,7 +2589,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": {
@@ -2598,7 +2598,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": {
@@ -2608,7 +2608,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": {
@@ -2617,11 +2617,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": {
@@ -2656,7 +2656,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": {
@@ -2673,7 +2673,7 @@
           "name": "punctuation.separator.parameters.python"
         }
       },
-      "match": "(?x)\n\\b ((self)|(cls)) \\b \\s*(?:(,)|(?=\\)))\n"
+      "match": "\\b((self)|(cls))\\b\\s*(?:(,)|(?=\\)))"
     },
     "parameters": {
       "begin": "(\\()",
@@ -2719,7 +2719,7 @@
               "name": "punctuation.separator.parameters.python"
             }
           },
-          "match": "(?x)\n([[:alpha:]_]\\w*)\n\\s* (?: (,) | (?=[)#\\n=]))\n"
+          "match": "([A-Za-z_]\\w*)\\s*(?:(,)|(?=[)#\\n=]))"
         },
         {
           "include": "#comments"
@@ -2772,7 +2772,7 @@
           "name": "support.other.parenthesis.regexp punctuation.parenthesis.backreference.named.end.regexp"
         }
       },
-      "match": "(?x)\n(\\()  (\\?P= \\w+(?:\\s+[[:alnum:]]+)?)  (\\))\n",
+      "match": "(\\()(\\?P=\\w+(?:\\s+[0-9A-Za-z]+)?)(\\))",
       "name": "meta.backreference.named.regexp"
     },
     "regexp-backreference-number": {
@@ -2914,7 +2914,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": {
@@ -2941,7 +2941,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": {
@@ -2949,7 +2949,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": {
@@ -3017,7 +3017,7 @@
       ]
     },
     "reserved-names-vyper": {
-      "match": "(?x)\n\\b (max_int128 | min_int128 | nonlocal | babbage | _default_ | ___init___ | await | indexed | ____init____ | true | constant | with | from | nonpayable | finally | enum | zero_wei | del | for | ____default____ | if | none | or | global | def | not | class | twei | struct | mwei | empty_bytes32 | nonreentrant | transient | false | assert | event | pass | finney | init | lovelace | min_decimal | shannon | public | external | internal | flagunreachable | _init_ | return | in | and | raise | try | gwei | break | zero_address | pwei | range | wei | while | ada | yield | as | immutable | continue | async | lambda | default | is | szabo | kwei | import | max_uint256 | elif | ___default___ | else | except | max_decimal | interface | payable | ether) \\b\n",
+      "match": "\\b(max_int128|min_int128|nonlocal|babbage|_default_|___init___|await|indexed|____init____|true|constant|with|from|nonpayable|finally|enum|zero_wei|del|for|____default____|if|none|or|global|def|not|class|twei|struct|mwei|empty_bytes32|nonreentrant|transient|false|assert|event|pass|finney|init|lovelace|min_decimal|shannon|public|external|internal|flagunreachable|_init_|return|in|and|raise|try|gwei|break|zero_address|pwei|range|wei|while|ada|yield|as|immutable|continue|async|lambda|default|is|szabo|kwei|import|max_uint256|elif|___default___|else|except|max_decimal|interface|payable|ether)\\b",
       "name": "name.reserved.vyper"
     },
     "return-annotation": {
@@ -3064,7 +3064,7 @@
     "single-one-regexp-character-set": {
       "patterns": [
         {
-          "match": "(?x)\n\\[ \\^? \\] (?! .*?\\])\n"
+          "match": "\\[\\s\\^?\\s\\](?!.*?\\])"
         },
         {
           "begin": "(\\[)(\\^)?(\\])?",
@@ -3125,7 +3125,7 @@
       ]
     },
     "single-one-regexp-conditional": {
-      "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
+      "begin": "(\\()\\?\\((\\w+(?:\\s+[0-9A-Za-z]+)?|\\d+)\\)",
       "beginCaptures": {
         "0": {
           "name": "keyword.operator.conditional.regexp"
@@ -3293,7 +3293,7 @@
       ]
     },
     "single-one-regexp-named-group": {
-      "begin": "(?x)\n(\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "begin": "(\\()(\\?P<\\w+(?:\\s+[0-9A-Za-z]+)?>)",
       "beginCaptures": {
         "1": {
           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
@@ -3365,7 +3365,7 @@
     "single-three-regexp-character-set": {
       "patterns": [
         {
-          "match": "(?x)\n\\[ \\^? \\] (?! .*?\\])\n"
+          "match": "\\[\\s\\^?\\s\\](?!.*?\\])"
         },
         {
           "begin": "(\\[)(\\^)?(\\])?",
@@ -3426,7 +3426,7 @@
       ]
     },
     "single-three-regexp-conditional": {
-      "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
+      "begin": "(\\()\\?\\((\\w+(?:\\s+[0-9A-Za-z]+)?|\\d+)\\)",
       "beginCaptures": {
         "0": {
           "name": "keyword.operator.conditional.regexp"
@@ -3612,7 +3612,7 @@
       ]
     },
     "single-three-regexp-named-group": {
-      "begin": "(?x)\n(\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "begin": "(\\()(\\?P<\\w+(?:\\s+[0-9A-Za-z]+)?>)",
       "beginCaptures": {
         "1": {
           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
@@ -3691,7 +3691,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(_*[A-Z][_\\d]*[A-Z])[A-Z\\d]*(_\\w*)?\\b",
       "name": "constant.other.caps.python"
     },
     "special-variables": {
@@ -3703,40 +3703,40 @@
           "name": "variable.language.special.cls.python"
         }
       },
-      "match": "(?x)\n\\b (?<!\\.) (?:\n(self) | (cls)\n)\\b\n"
+      "match": "\\b(?<!\\.)(?:(self)|(cls))\\b"
     },
     "special-variables-types": {
       "patterns": [
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nlog)\\b\n",
+          "match": "(?<!\\.)\\b(log)\\b",
           "name": "variable.language.special.log.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nmsg)\\b\n",
+          "match": "(?<!\\.)\\b(msg)\\b",
           "name": "variable.language.special.msg.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nblock)\\b\n",
+          "match": "(?<!\\.)\\b(block)\\b",
           "name": "variable.language.special.block.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\ntx)\\b\n",
+          "match": "(?<!\\.)\\b(tx)\\b",
           "name": "variable.language.special.tx.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nchain)\\b\n",
+          "match": "(?<!\\.)\\b(chain)\\b",
           "name": "variable.language.special.chain.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nextcall)\\b\n",
+          "match": "(?<!\\.)\\b(extcall)\\b",
           "name": "variable.language.special.extcall.vyper"
         },
         {
-          "match": "(?x)\n(?<!\\.) \\b(\nstaticcall)\\b\n",
+          "match": "(?<!\\.)\\b(staticcall)\\b",
           "name": "variable.language.special.staticcall.vyper"
         },
         {
-          "match": "(?x)\n\\b (__interface__) \\b\n",
+          "match": "\\b(__interface__)\\b",
           "name": "variable.language.special.__interface__.vyper"
         }
       ]
@@ -3789,11 +3789,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"
         },
         {
@@ -3806,7 +3806,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"
         }
       ]
     },
@@ -3922,7 +3922,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*(\\.[A-Za-z_]\\w*|\\[[^\\]'\"]+\\])*(![rsa])?(:\\w?[<>=^]?[-+\\s]?\\#?\\d*,?(\\.\\d+)?[bcdeEfFgGnosxX%]?)?}))",
           "name": "meta.format.brace.python"
         },
         {
@@ -3937,7 +3937,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*(\\.[A-Za-z_]\\w*|\\[[^\\]'\"]+\\])*(![rsa])?(:)[^'\"{}\\n]*(?:\\{[^'\"}\\n]*?\\}[^'\"{}\\n]*)*})",
           "name": "meta.format.brace.python"
         }
       ]
@@ -3964,7 +3964,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": {
@@ -3972,7 +3972,7 @@
       "name": "constant.language.python"
     },
     "string-multi-bad-brace1-formatting-raw": {
-      "begin": "(?x)\n(?= \\{%\n( .*? (?!'''|\"\"\") )\n%\\}\n)\n",
+      "begin": "(?=\\{%(.*?(?!'''|\"\"\"))%\\})",
       "comment": "template using {% ... %}",
       "end": "(?='''|\"\"\")",
       "patterns": [
@@ -3982,7 +3982,7 @@
       ]
     },
     "string-multi-bad-brace1-formatting-unicode": {
-      "begin": "(?x)\n(?= \\{%\n( .*? (?!'''|\"\"\") )\n%\\}\n)\n",
+      "begin": "(?=\\{%(.*?(?!'''|\"\"\"))%\\})",
       "comment": "template using {% ... %}",
       "end": "(?='''|\"\"\")",
       "patterns": [
@@ -3998,7 +3998,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": [
@@ -4011,7 +4011,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": [
@@ -4239,7 +4239,7 @@
       ]
     },
     "string-single-bad-brace1-formatting-raw": {
-      "begin": "(?x)\n(?= \\{%\n( .*? (?!(['\"])|((?<!\\\\)\\n)) )\n%\\}\n)\n",
+      "begin": "(?=\\{%(.*?(?!(['\"])|((?<!\\\\)\\n)))%\\})",
       "comment": "template using {% ... %}",
       "end": "(?=(['\"])|((?<!\\\\)\\n))",
       "patterns": [
@@ -4249,7 +4249,7 @@
       ]
     },
     "string-single-bad-brace1-formatting-unicode": {
-      "begin": "(?x)\n(?= \\{%\n( .*? (?!(['\"])|((?<!\\\\)\\n)) )\n%\\}\n)\n",
+      "begin": "(?=\\{%(.*?(?!(['\"])|((?<!\\\\)\\n)))%\\})",
       "comment": "template using {% ... %}",
       "end": "(?=(['\"])|((?<!\\\\)\\n))",
       "patterns": [
@@ -4265,7 +4265,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": [
@@ -4278,7 +4278,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": [