├── README.md
├── LICENSE
└── syntaxes
    └── mojo.syntax.json


/README.md:
--------------------------------------------------------------------------------
 1 | # mojo-syntax
 2 | 
 3 | This repository contains a TextMate grammar for the Mojo 🔥 programming
 4 | language.
 5 | 
 6 | ## Contributing
 7 | 
 8 | The Mojo syntax has been converted from [VS Code's Python syntax][1], which
 9 | itself was converted from [MagicPython.tmLanguage][2]. Many fixes or
10 | improvements to Mojo's syntax also apply to these two projects, so in many
11 | cases, creating a pull request against one of these two repositories is the way
12 | to go. Once accepted there, we can pull down the changes into this project.
13 | 
14 | For Mojo-specific updates, we'd be happy to review pull requests sent here.
15 | Please include a description of the problem that the change addresses.
16 | 
17 | Reports of general issues with Mojo or how its syntax is highlighted on GitHub,
18 | or requests to update this grammar based on changes to the VS Code or
19 | MagicPython syntax files, can be sent as issues on the main Mojo repository
20 | [here][3].
21 | 
22 | [1]: https://github.com/microsoft/vscode/blob/c4cfd83472c59f183d79cb9526c42105880bf8ab/extensions/python/syntaxes/MagicPython.tmLanguage.json
23 | [2]: https://github.com/MagicStack/MagicPython/blob/7d0f2b22a5ad8fccbd7341bc7b7a715169283044/grammars/MagicPython.tmLanguage
24 | [3]: https://github.com/modularml/mojo
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License
 2 | 
 3 | Copyright (c) 2022-present Modular Inc.  https://www.modular.com
 4 | Copyright (c) 2015-present MagicStack Inc.  http://magic.io
 5 | Copyright (c) 2015-present Microsoft Corporation
 6 | 
 7 | Permission is hereby granted, free of charge, to any person obtaining a copy
 8 | of this software and associated documentation files (the "Software"), to deal
 9 | in the Software without restriction, including without limitation the rights
10 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 | copies of the Software, and to permit persons to whom the Software is
12 | furnished to do so, subject to the following conditions:
13 | 
14 | The above copyright notice and this permission notice shall be included in
15 | all copies or substantial portions of the Software.
16 | 
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 | THE SOFTWARE.
24 | 


--------------------------------------------------------------------------------
/syntaxes/mojo.syntax.json:
--------------------------------------------------------------------------------
   1 | {
   2 |   "information_for_contributors": [
   3 |     "This file has been converted from https://github.com/MagicStack/MagicPython/blob/master/grammars/MagicPython.tmLanguage",
   4 |     "If you want to provide a fix or improvement, please create a pull request against the original repository.",
   5 |     "Once accepted there, we are happy to receive an update request."
   6 |   ],
   7 |   "version": "https://github.com/MagicStack/MagicPython/commit/7d0f2b22a5ad8fccbd7341bc7b7a715169283044",
   8 |   "name": "MagicPython",
   9 |   "scopeName": "source.mojo",
  10 |   "patterns": [
  11 |     {
  12 |       "include": "#statement"
  13 |     },
  14 |     {
  15 |       "include": "#expression"
  16 |     }
  17 |   ],
  18 |   "repository": {
  19 |     "impossible": {
  20 |       "comment": "This is a special rule that should be used where no match is desired. It is not a good idea to match something like '1{0}' because in some cases that can result in infinite loops in token generation. So the rule instead matches and impossible expression to allow a match to fail and move to the next token.",
  21 |       "match": "$.^"
  22 |     },
  23 |     "statement": {
  24 |       "patterns": [
  25 |         {
  26 |           "include": "#import"
  27 |         },
  28 |         {
  29 |           "include": "#class-declaration"
  30 |         },
  31 |         {
  32 |           "include": "#function-declaration"
  33 |         },
  34 |         {
  35 |           "include": "#generator"
  36 |         },
  37 |         {
  38 |           "include": "#statement-keyword"
  39 |         },
  40 |         {
  41 |           "include": "#assignment-operator"
  42 |         },
  43 |         {
  44 |           "include": "#decorator"
  45 |         },
  46 |         {
  47 |           "include": "#semicolon"
  48 |         }
  49 |       ]
  50 |     },
  51 |     "semicolon": {
  52 |       "patterns": [
  53 |         {
  54 |           "name": "invalid.deprecated.semicolon.python",
  55 |           "match": "\\;$"
  56 |         }
  57 |       ]
  58 |     },
  59 |     "comments": {
  60 |       "patterns": [
  61 |         {
  62 |           "name": "comment.line.number-sign.python",
  63 |           "contentName": "meta.typehint.comment.python",
  64 |           "begin": "(?x)\n  (?:\n    \\# \\s* (type:)\n    \\s*+ (?# we want `\\s*+` which is possessive quantifier since\n             we do not actually want to backtrack when matching\n             whitespace here)\n    (?! $ | \\#)\n  )\n",
  65 |           "end": "(?:$|(?=\\#))",
  66 |           "beginCaptures": {
  67 |             "0": {
  68 |               "name": "meta.typehint.comment.python"
  69 |             },
  70 |             "1": {
  71 |               "name": "comment.typehint.directive.notation.python"
  72 |             }
  73 |           },
  74 |           "patterns": [
  75 |             {
  76 |               "name": "comment.typehint.ignore.notation.python",
  77 |               "match": "(?x)\n  \\G ignore\n  (?= \\s* (?: $ | \\#))\n"
  78 |             },
  79 |             {
  80 |               "name": "comment.typehint.type.notation.python",
  81 |               "match": "(?x)\n  (?<!\\.)\\b(\n    bool | bytes | float | int | object | str\n    | List | Dict | Iterable | Sequence | Set\n    | FrozenSet | Callable | Union | Tuple\n    | Any | None\n  )\\b\n"
  82 |             },
  83 |             {
  84 |               "name": "comment.typehint.punctuation.notation.python",
  85 |               "match": "([\\[\\]\\(\\),\\.\\=\\*]|(->))"
  86 |             },
  87 |             {
  88 |               "name": "comment.typehint.variable.notation.python",
  89 |               "match": "([[:alpha:]_]\\w*)"
  90 |             }
  91 |           ]
  92 |         },
  93 |         {
  94 |           "include": "#comments-base"
  95 |         }
  96 |       ]
  97 |     },
  98 |     "statement-keyword": {
  99 |       "patterns": [
 100 |         {
 101 |           "name": "storage.type.function.python",
 102 |           "match": "\\b((async\\s+)?\\s*(def|fn))\\b"
 103 |         },
 104 |         {
 105 |           "name": "keyword.control.flow.python",
 106 |           "comment": "if `as` is eventually followed by `:` or line continuation\nit's probably control flow like:\n    with foo as bar, \\\n         Foo as Bar:\n      try:\n        do_stuff()\n      except Exception as e:\n        pass\n",
 107 |           "match": "\\b(?<!\\.)as\\b(?=.*[:\\\\])"
 108 |         },
 109 |         {
 110 |           "name": "keyword.control.import.python",
 111 |           "comment": "other legal use of `as` is in an import",
 112 |           "match": "\\b(?<!\\.)as\\b"
 113 |         },
 114 |         {
 115 |           "name": "keyword.control.flow.python",
 116 |           "match": "(?x)\n  \\b(?<!\\.)(\n    async | continue | del | assert | break | finally | for\n    | from | elif | else | if | except | pass | raise\n    | return | try | while | with\n  )\\b\n"
 117 |         },
 118 |         {
 119 |           "name": "storage.modifier.declaration.python",
 120 |           "match": "(?x)\n  \\b(?<!\\.)(\n    global | nonlocal\n  )\\b\n"
 121 |         },
 122 |         {
 123 |           "name": "storage.type.class.python",
 124 |           "match": "\\b(?<!\\.)(class|struct|trait)\\b"
 125 |         },
 126 |         {
 127 |           "match": "(?x)\n  ^\\s*(\n    case | match\n  )(?=\\s*([-+\\w\\d(\\[{'\":#]|$))\\b\n",
 128 |           "captures": {
 129 |             "1": {
 130 |               "name": "keyword.control.flow.python"
 131 |             }
 132 |           }
 133 |         },
 134 |         {
 135 |           "match": "\\b(var|let|alias|comptime) \\s*([[:alpha:]_]\\w*)\\b",
 136 |           "captures": {
 137 |             "1": {
 138 |               "name": "storage.modifier.declaration.python"
 139 |             },
 140 |             "2": {
 141 |               "name": "variable.other.python"
 142 |             }
 143 |           }
 144 |         }
 145 |       ]
 146 |     },
 147 |     "expression-bare": {
 148 |       "comment": "valid Python expressions w/o comments and line continuation",
 149 |       "patterns": [
 150 |         {
 151 |           "include": "#backticks"
 152 |         },
 153 |         {
 154 |           "include": "#literal"
 155 |         },
 156 |         {
 157 |           "include": "#regexp"
 158 |         },
 159 |         {
 160 |           "include": "#string"
 161 |         },
 162 |         {
 163 |           "include": "#lambda"
 164 |         },
 165 |         {
 166 |           "include": "#generator"
 167 |         },
 168 |         {
 169 |           "include": "#illegal-operator"
 170 |         },
 171 |         {
 172 |           "include": "#operator"
 173 |         },
 174 |         {
 175 |           "include": "#curly-braces"
 176 |         },
 177 |         {
 178 |           "include": "#item-access"
 179 |         },
 180 |         {
 181 |           "include": "#list"
 182 |         },
 183 |         {
 184 |           "include": "#odd-function-call"
 185 |         },
 186 |         {
 187 |           "include": "#round-braces"
 188 |         },
 189 |         {
 190 |           "include": "#function-call"
 191 |         },
 192 |         {
 193 |           "include": "#builtin-functions"
 194 |         },
 195 |         {
 196 |           "include": "#builtin-types"
 197 |         },
 198 |         {
 199 |           "include": "#builtin-exceptions"
 200 |         },
 201 |         {
 202 |           "include": "#magic-names"
 203 |         },
 204 |         {
 205 |           "include": "#special-names"
 206 |         },
 207 |         {
 208 |           "include": "#illegal-names"
 209 |         },
 210 |         {
 211 |           "include": "#special-variables"
 212 |         },
 213 |         {
 214 |           "include": "#ellipsis"
 215 |         },
 216 |         {
 217 |           "include": "#punctuation"
 218 |         },
 219 |         {
 220 |           "include": "#line-continuation"
 221 |         }
 222 |       ]
 223 |     },
 224 |     "expression-base": {
 225 |       "comment": "valid Python expressions with comments and line continuation",
 226 |       "patterns": [
 227 |         {
 228 |           "include": "#comments"
 229 |         },
 230 |         {
 231 |           "include": "#expression-bare"
 232 |         },
 233 |         {
 234 |           "include": "#line-continuation"
 235 |         }
 236 |       ]
 237 |     },
 238 |     "expression": {
 239 |       "comment": "All valid Python expressions",
 240 |       "patterns": [
 241 |         {
 242 |           "include": "#expression-base"
 243 |         },
 244 |         {
 245 |           "include": "#member-access"
 246 |         },
 247 |         {
 248 |           "comment": "Tokenize identifiers to help linters",
 249 |           "match": "(?x) \\b ([[:alpha:]_]\\w*) \\b"
 250 |         }
 251 |       ]
 252 |     },
 253 |     "member-access": {
 254 |       "name": "meta.member.access.python",
 255 |       "begin": "(\\.)\\s*(?!\\.)",
 256 |       "end": "(?x)\n  # stop when you've just read non-whitespace followed by non-word\n  # i.e. when finished reading an identifier or function call\n  (?<=\\S)(?=\\W) |\n  # stop when seeing the start of something that's not a word,\n  # i.e. when seeing a non-identifier\n  (^|(?<=\\s))(?=[^\\\\\\w\\s]) |\n  $\n",
 257 |       "beginCaptures": {
 258 |         "1": {
 259 |           "name": "punctuation.separator.period.python"
 260 |         }
 261 |       },
 262 |       "patterns": [
 263 |         {
 264 |           "include": "#function-call"
 265 |         },
 266 |         {
 267 |           "include": "#member-access-base"
 268 |         },
 269 |         {
 270 |           "include": "#member-access-attribute"
 271 |         }
 272 |       ]
 273 |     },
 274 |     "member-access-base": {
 275 |       "patterns": [
 276 |         {
 277 |           "include": "#magic-names"
 278 |         },
 279 |         {
 280 |           "include": "#illegal-names"
 281 |         },
 282 |         {
 283 |           "include": "#illegal-object-name"
 284 |         },
 285 |         {
 286 |           "include": "#special-names"
 287 |         },
 288 |         {
 289 |           "include": "#line-continuation"
 290 |         },
 291 |         {
 292 |           "include": "#item-access"
 293 |         }
 294 |       ]
 295 |     },
 296 |     "member-access-attribute": {
 297 |       "comment": "Highlight attribute access in otherwise non-specialized cases.",
 298 |       "name": "meta.attribute.python",
 299 |       "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
 300 |     },
 301 |     "special-names": {
 302 |       "name": "constant.other.caps.python",
 303 |       "match": "(?x)\n  \\b\n    # we want to see \"enough\", meaning 2 or more upper-case\n    # letters in the beginning of the constant\n    #\n    # for more details refer to:\n    #   https://github.com/MagicStack/MagicPython/issues/42\n    (\n      _* [[:upper:]] [_\\d]* [[:upper:]]\n    )\n    [[:upper:]\\d]* (_\\w*)?\n  \\b\n"
 304 |     },
 305 |     "curly-braces": {
 306 |       "begin": "\\{",
 307 |       "end": "\\}",
 308 |       "beginCaptures": {
 309 |         "0": {
 310 |           "name": "punctuation.definition.dict.begin.python"
 311 |         }
 312 |       },
 313 |       "endCaptures": {
 314 |         "0": {
 315 |           "name": "punctuation.definition.dict.end.python"
 316 |         }
 317 |       },
 318 |       "patterns": [
 319 |         {
 320 |           "name": "punctuation.separator.dict.python",
 321 |           "match": ":"
 322 |         },
 323 |         {
 324 |           "include": "#expression"
 325 |         }
 326 |       ]
 327 |     },
 328 |     "list": {
 329 |       "begin": "\\[",
 330 |       "end": "\\]",
 331 |       "beginCaptures": {
 332 |         "0": {
 333 |           "name": "punctuation.definition.list.begin.python"
 334 |         }
 335 |       },
 336 |       "endCaptures": {
 337 |         "0": {
 338 |           "name": "punctuation.definition.list.end.python"
 339 |         }
 340 |       },
 341 |       "patterns": [
 342 |         {
 343 |           "include": "#expression"
 344 |         }
 345 |       ]
 346 |     },
 347 |     "odd-function-call": {
 348 |       "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",
 349 |       "begin": "(?x)\n  (?<= \\] | \\) ) \\s*\n  (?=\\()\n",
 350 |       "end": "(\\))",
 351 |       "endCaptures": {
 352 |         "1": {
 353 |           "name": "punctuation.definition.arguments.end.python"
 354 |         }
 355 |       },
 356 |       "patterns": [
 357 |         {
 358 |           "include": "#function-arguments"
 359 |         }
 360 |       ]
 361 |     },
 362 |     "round-braces": {
 363 |       "begin": "\\(",
 364 |       "end": "\\)",
 365 |       "beginCaptures": {
 366 |         "0": {
 367 |           "name": "punctuation.parenthesis.begin.python"
 368 |         }
 369 |       },
 370 |       "endCaptures": {
 371 |         "0": {
 372 |           "name": "punctuation.parenthesis.end.python"
 373 |         }
 374 |       },
 375 |       "patterns": [
 376 |         {
 377 |           "include": "#expression"
 378 |         }
 379 |       ]
 380 |     },
 381 |     "line-continuation": {
 382 |       "patterns": [
 383 |         {
 384 |           "match": "(\\\\)\\s*(\\S.*$\\n?)",
 385 |           "captures": {
 386 |             "1": {
 387 |               "name": "punctuation.separator.continuation.line.python"
 388 |             },
 389 |             "2": {
 390 |               "name": "invalid.illegal.line.continuation.python"
 391 |             }
 392 |           }
 393 |         },
 394 |         {
 395 |           "begin": "(\\\\)\\s*$\\n?",
 396 |           "end": "(?x)\n  (?=^\\s*$)\n  |\n  (?! (\\s* [rR]? (\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\"))\n      |\n      (\\G $)  (?# '\\G' is necessary for ST)\n  )\n",
 397 |           "beginCaptures": {
 398 |             "1": {
 399 |               "name": "punctuation.separator.continuation.line.python"
 400 |             }
 401 |           },
 402 |           "patterns": [
 403 |             {
 404 |               "include": "#regexp"
 405 |             },
 406 |             {
 407 |               "include": "#string"
 408 |             }
 409 |           ]
 410 |         }
 411 |       ]
 412 |     },
 413 |     "assignment-operator": {
 414 |       "name": "keyword.operator.assignment.python",
 415 |       "match": "(?x)\n     <<= | >>= | //= | \\*\\*=\n    | \\+= | -= | /= | @=\n    | \\*= | %= | ~= | \\^= | &= | \\|=\n    | =(?!=)\n"
 416 |     },
 417 |     "operator": {
 418 |       "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",
 419 |       "captures": {
 420 |         "1": {
 421 |           "name": "keyword.operator.logical.python"
 422 |         },
 423 |         "2": {
 424 |           "name": "keyword.control.flow.python"
 425 |         },
 426 |         "3": {
 427 |           "name": "keyword.operator.bitwise.python"
 428 |         },
 429 |         "4": {
 430 |           "name": "keyword.operator.arithmetic.python"
 431 |         },
 432 |         "5": {
 433 |           "name": "keyword.operator.comparison.python"
 434 |         },
 435 |         "6": {
 436 |           "name": "keyword.operator.assignment.python"
 437 |         }
 438 |       }
 439 |     },
 440 |     "punctuation": {
 441 |       "patterns": [
 442 |         {
 443 |           "name": "punctuation.separator.colon.python",
 444 |           "match": ":"
 445 |         },
 446 |         {
 447 |           "name": "punctuation.separator.element.python",
 448 |           "match": ","
 449 |         }
 450 |       ]
 451 |     },
 452 |     "literal": {
 453 |       "patterns": [
 454 |         {
 455 |           "name": "constant.language.python",
 456 |           "match": "\\b(True|False|None|NotImplemented|Ellipsis)\\b"
 457 |         },
 458 |         {
 459 |           "include": "#number"
 460 |         }
 461 |       ]
 462 |     },
 463 |     "number": {
 464 |       "name": "constant.numeric.python",
 465 |       "patterns": [
 466 |         {
 467 |           "include": "#number-float"
 468 |         },
 469 |         {
 470 |           "include": "#number-dec"
 471 |         },
 472 |         {
 473 |           "include": "#number-hex"
 474 |         },
 475 |         {
 476 |           "include": "#number-oct"
 477 |         },
 478 |         {
 479 |           "include": "#number-bin"
 480 |         },
 481 |         {
 482 |           "include": "#number-long"
 483 |         },
 484 |         {
 485 |           "name": "invalid.illegal.name.python",
 486 |           "match": "\\b[0-9]+\\w+"
 487 |         }
 488 |       ]
 489 |     },
 490 |     "number-float": {
 491 |       "name": "constant.numeric.float.python",
 492 |       "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",
 493 |       "captures": {
 494 |         "1": {
 495 |           "name": "storage.type.imaginary.number.python"
 496 |         }
 497 |       }
 498 |     },
 499 |     "number-dec": {
 500 |       "name": "constant.numeric.dec.python",
 501 |       "match": "(?x)\n  (?<![\\w\\.])(?:\n      [1-9](?: _?[0-9] )*\n      |\n      0+\n      |\n      [0-9](?: _?[0-9] )* ([jJ])\n      |\n      0 ([0-9]+)(?![eE\\.])\n  )\\b\n",
 502 |       "captures": {
 503 |         "1": {
 504 |           "name": "storage.type.imaginary.number.python"
 505 |         },
 506 |         "2": {
 507 |           "name": "invalid.illegal.dec.python"
 508 |         }
 509 |       }
 510 |     },
 511 |     "number-hex": {
 512 |       "name": "constant.numeric.hex.python",
 513 |       "match": "(?x)\n  (?<![\\w\\.])\n    (0[xX]) (_?[0-9a-fA-F])+\n  \\b\n",
 514 |       "captures": {
 515 |         "1": {
 516 |           "name": "storage.type.number.python"
 517 |         }
 518 |       }
 519 |     },
 520 |     "number-oct": {
 521 |       "name": "constant.numeric.oct.python",
 522 |       "match": "(?x)\n  (?<![\\w\\.])\n    (0[oO]) (_?[0-7])+\n  \\b\n",
 523 |       "captures": {
 524 |         "1": {
 525 |           "name": "storage.type.number.python"
 526 |         }
 527 |       }
 528 |     },
 529 |     "number-bin": {
 530 |       "name": "constant.numeric.bin.python",
 531 |       "match": "(?x)\n  (?<![\\w\\.])\n    (0[bB]) (_?[01])+\n  \\b\n",
 532 |       "captures": {
 533 |         "1": {
 534 |           "name": "storage.type.number.python"
 535 |         }
 536 |       }
 537 |     },
 538 |     "number-long": {
 539 |       "name": "constant.numeric.bin.python",
 540 |       "comment": "this is to support python2 syntax for long ints",
 541 |       "match": "(?x)\n  (?<![\\w\\.])\n    ([1-9][0-9]* | 0) ([lL])\n  \\b\n",
 542 |       "captures": {
 543 |         "2": {
 544 |           "name": "storage.type.number.python"
 545 |         }
 546 |       }
 547 |     },
 548 |     "regexp": {
 549 |       "patterns": [
 550 |         {
 551 |           "include": "#regexp-single-three-line"
 552 |         },
 553 |         {
 554 |           "include": "#regexp-double-three-line"
 555 |         },
 556 |         {
 557 |           "include": "#regexp-single-one-line"
 558 |         },
 559 |         {
 560 |           "include": "#regexp-double-one-line"
 561 |         }
 562 |       ]
 563 |     },
 564 |     "string": {
 565 |       "patterns": [
 566 |         {
 567 |           "include": "#string-quoted-multi-line"
 568 |         },
 569 |         {
 570 |           "include": "#string-quoted-single-line"
 571 |         },
 572 |         {
 573 |           "include": "#string-bin-quoted-multi-line"
 574 |         },
 575 |         {
 576 |           "include": "#string-bin-quoted-single-line"
 577 |         },
 578 |         {
 579 |           "include": "#string-raw-quoted-multi-line"
 580 |         },
 581 |         {
 582 |           "include": "#string-raw-quoted-single-line"
 583 |         },
 584 |         {
 585 |           "include": "#string-raw-bin-quoted-multi-line"
 586 |         },
 587 |         {
 588 |           "include": "#string-raw-bin-quoted-single-line"
 589 |         },
 590 |         {
 591 |           "include": "#fstring-fnorm-quoted-multi-line"
 592 |         },
 593 |         {
 594 |           "include": "#fstring-fnorm-quoted-single-line"
 595 |         },
 596 |         {
 597 |           "include": "#fstring-normf-quoted-multi-line"
 598 |         },
 599 |         {
 600 |           "include": "#fstring-normf-quoted-single-line"
 601 |         },
 602 |         {
 603 |           "include": "#fstring-raw-quoted-multi-line"
 604 |         },
 605 |         {
 606 |           "include": "#fstring-raw-quoted-single-line"
 607 |         }
 608 |       ]
 609 |     },
 610 |     "string-unicode-guts": {
 611 |       "patterns": [
 612 |         {
 613 |           "include": "#string-mojo-code-block"
 614 |         },
 615 |         {
 616 |           "include": "#escape-sequence-unicode"
 617 |         },
 618 |         {
 619 |           "include": "#string-entity"
 620 |         },
 621 |         {
 622 |           "include": "#string-brace-formatting"
 623 |         }
 624 |       ]
 625 |     },
 626 |     "string-consume-escape": {
 627 |       "match": "\\\\['\"\\n\\\\]"
 628 |     },
 629 |     "string-raw-guts": {
 630 |       "patterns": [
 631 |         {
 632 |           "include": "#string-consume-escape"
 633 |         },
 634 |         {
 635 |           "include": "#string-formatting"
 636 |         },
 637 |         {
 638 |           "include": "#string-brace-formatting"
 639 |         }
 640 |       ]
 641 |     },
 642 |     "string-raw-bin-guts": {
 643 |       "patterns": [
 644 |         {
 645 |           "include": "#string-consume-escape"
 646 |         },
 647 |         {
 648 |           "include": "#string-formatting"
 649 |         }
 650 |       ]
 651 |     },
 652 |     "string-entity": {
 653 |       "patterns": [
 654 |         {
 655 |           "include": "#escape-sequence"
 656 |         },
 657 |         {
 658 |           "include": "#string-line-continuation"
 659 |         },
 660 |         {
 661 |           "include": "#string-formatting"
 662 |         }
 663 |       ]
 664 |     },
 665 |     "fstring-guts": {
 666 |       "patterns": [
 667 |         {
 668 |           "include": "#escape-sequence-unicode"
 669 |         },
 670 |         {
 671 |           "include": "#escape-sequence"
 672 |         },
 673 |         {
 674 |           "include": "#string-line-continuation"
 675 |         },
 676 |         {
 677 |           "include": "#fstring-formatting"
 678 |         }
 679 |       ]
 680 |     },
 681 |     "fstring-raw-guts": {
 682 |       "patterns": [
 683 |         {
 684 |           "include": "#string-consume-escape"
 685 |         },
 686 |         {
 687 |           "include": "#fstring-formatting"
 688 |         }
 689 |       ]
 690 |     },
 691 |     "fstring-illegal-single-brace": {
 692 |       "comment": "it is illegal to have a multiline brace inside a single-line string",
 693 |       "begin": "(\\{)(?=[^\\n}]*$\\n?)",
 694 |       "end": "(\\})|(?=\\n)",
 695 |       "beginCaptures": {
 696 |         "1": {
 697 |           "name": "constant.character.format.placeholder.other.python"
 698 |         }
 699 |       },
 700 |       "endCaptures": {
 701 |         "1": {
 702 |           "name": "constant.character.format.placeholder.other.python"
 703 |         }
 704 |       },
 705 |       "patterns": [
 706 |         {
 707 |           "include": "#fstring-terminator-single"
 708 |         },
 709 |         {
 710 |           "include": "#f-expression"
 711 |         }
 712 |       ]
 713 |     },
 714 |     "fstring-illegal-multi-brace": {
 715 |       "patterns": [
 716 |         {
 717 |           "include": "#impossible"
 718 |         }
 719 |       ]
 720 |     },
 721 |     "f-expression": {
 722 |       "comment": "All valid Python expressions, except comments and line continuation",
 723 |       "patterns": [
 724 |         {
 725 |           "include": "#expression-bare"
 726 |         },
 727 |         {
 728 |           "include": "#member-access"
 729 |         },
 730 |         {
 731 |           "comment": "Tokenize identifiers to help linters",
 732 |           "match": "(?x) \\b ([[:alpha:]_]\\w*) \\b"
 733 |         }
 734 |       ]
 735 |     },
 736 |     "escape-sequence-unicode": {
 737 |       "patterns": [
 738 |         {
 739 |           "name": "constant.character.escape.python",
 740 |           "match": "(?x)\n  \\\\ (\n        u[0-9A-Fa-f]{4}\n        | U[0-9A-Fa-f]{8}\n        | N\\{[\\w\\s]+?\\}\n     )\n"
 741 |         }
 742 |       ]
 743 |     },
 744 |     "escape-sequence": {
 745 |       "name": "constant.character.escape.python",
 746 |       "match": "(?x)\n  \\\\ (\n        x[0-9A-Fa-f]{2}\n        | [0-7]{1,3}\n        | [\\\\\"'abfnrtv]\n     )\n"
 747 |     },
 748 |     "string-line-continuation": {
 749 |       "name": "constant.language.python",
 750 |       "match": "\\\\$"
 751 |     },
 752 |     "string-formatting": {
 753 |       "name": "meta.format.percent.python",
 754 |       "match": "(?x)\n  (\n    % (\\([\\w\\s]*\\))?\n      [-+#0 ]*\n      (\\d+|\\*)? (\\.(\\d+|\\*))?\n      ([hlL])?\n      [diouxXeEfFgGcrsab%]\n  )\n",
 755 |       "captures": {
 756 |         "1": {
 757 |           "name": "constant.character.format.placeholder.other.python"
 758 |         }
 759 |       }
 760 |     },
 761 |     "string-brace-formatting": {
 762 |       "patterns": [
 763 |         {
 764 |           "name": "meta.format.brace.python",
 765 |           "match": "(?x)\n  (\n    {{ | }}\n    | (?:\n      {\n        \\w* (\\.[[:alpha:]_]\\w* | \\[[^\\]'\"]+\\])*\n        (![rsa])?\n        ( : \\w? [<>=^]? [-+ ]? \\#?\n          \\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )?\n      })\n  )\n",
 766 |           "captures": {
 767 |             "1": {
 768 |               "name": "constant.character.format.placeholder.other.python"
 769 |             },
 770 |             "3": {
 771 |               "name": "storage.type.format.python"
 772 |             },
 773 |             "4": {
 774 |               "name": "storage.type.format.python"
 775 |             }
 776 |           }
 777 |         },
 778 |         {
 779 |           "name": "meta.format.brace.python",
 780 |           "match": "(?x)\n  (\n    {\n      \\w* (\\.[[:alpha:]_]\\w* | \\[[^\\]'\"]+\\])*\n      (![rsa])?\n      (:)\n        [^'\"{}\\n]* (?:\n          \\{ [^'\"}\\n]*? \\} [^'\"{}\\n]*\n        )*\n    }\n  )\n",
 781 |           "captures": {
 782 |             "1": {
 783 |               "name": "constant.character.format.placeholder.other.python"
 784 |             },
 785 |             "3": {
 786 |               "name": "storage.type.format.python"
 787 |             },
 788 |             "4": {
 789 |               "name": "storage.type.format.python"
 790 |             }
 791 |           }
 792 |         }
 793 |       ]
 794 |     },
 795 |     "fstring-formatting": {
 796 |       "patterns": [
 797 |         {
 798 |           "include": "#fstring-formatting-braces"
 799 |         },
 800 |         {
 801 |           "include": "#fstring-formatting-singe-brace"
 802 |         }
 803 |       ]
 804 |     },
 805 |     "fstring-formatting-singe-brace": {
 806 |       "name": "invalid.illegal.brace.python",
 807 |       "match": "(}(?!}))"
 808 |     },
 809 |     "import": {
 810 |       "comment": "Import statements used to correctly mark `from`, `import`, and `as`\n",
 811 |       "patterns": [
 812 |         {
 813 |           "begin": "\\b(?<!\\.)(from)\\b(?=.+import)",
 814 |           "end": "$|(?=import)",
 815 |           "beginCaptures": {
 816 |             "1": {
 817 |               "name": "keyword.control.import.python"
 818 |             }
 819 |           },
 820 |           "patterns": [
 821 |             {
 822 |               "name": "punctuation.separator.period.python",
 823 |               "match": "\\.+"
 824 |             },
 825 |             {
 826 |               "include": "#expression"
 827 |             }
 828 |           ]
 829 |         },
 830 |         {
 831 |           "begin": "\\b(?<!\\.)(import)\\b",
 832 |           "end": "$",
 833 |           "beginCaptures": {
 834 |             "1": {
 835 |               "name": "keyword.control.import.python"
 836 |             }
 837 |           },
 838 |           "patterns": [
 839 |             {
 840 |               "name": "keyword.control.import.python",
 841 |               "match": "\\b(?<!\\.)as\\b"
 842 |             },
 843 |             {
 844 |               "include": "#expression"
 845 |             }
 846 |           ]
 847 |         }
 848 |       ]
 849 |     },
 850 |     "class-declaration": {
 851 |       "patterns": [
 852 |         {
 853 |           "name": "meta.class.python",
 854 |           "begin": "(?x)\n  \\s*(class|struct|trait)\\s+\n    (?=\n      [[:alpha:]_]\\w* \\s* (:|\\()\n    )\n",
 855 |           "end": "(:)",
 856 |           "beginCaptures": {
 857 |             "1": {
 858 |               "name": "storage.type.class.python"
 859 |             }
 860 |           },
 861 |           "endCaptures": {
 862 |             "1": {
 863 |               "name": "punctuation.section.class.begin.python"
 864 |             }
 865 |           },
 866 |           "patterns": [
 867 |             {
 868 |               "include": "#class-name"
 869 |             },
 870 |             {
 871 |               "include": "#class-inheritance"
 872 |             }
 873 |           ]
 874 |         }
 875 |       ]
 876 |     },
 877 |     "class-name": {
 878 |       "patterns": [
 879 |         {
 880 |           "include": "#illegal-object-name"
 881 |         },
 882 |         {
 883 |           "include": "#builtin-possible-callables"
 884 |         },
 885 |         {
 886 |           "name": "entity.name.type.class.python",
 887 |           "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
 888 |         }
 889 |       ]
 890 |     },
 891 |     "class-inheritance": {
 892 |       "name": "meta.class.inheritance.python",
 893 |       "begin": "(\\()",
 894 |       "end": "(\\))",
 895 |       "beginCaptures": {
 896 |         "1": {
 897 |           "name": "punctuation.definition.inheritance.begin.python"
 898 |         }
 899 |       },
 900 |       "endCaptures": {
 901 |         "1": {
 902 |           "name": "punctuation.definition.inheritance.end.python"
 903 |         }
 904 |       },
 905 |       "patterns": [
 906 |         {
 907 |           "name": "keyword.operator.unpacking.arguments.python",
 908 |           "match": "(\\*\\*|\\*)"
 909 |         },
 910 |         {
 911 |           "name": "punctuation.separator.inheritance.python",
 912 |           "match": ","
 913 |         },
 914 |         {
 915 |           "name": "keyword.operator.assignment.python",
 916 |           "match": "=(?!=)"
 917 |         },
 918 |         {
 919 |           "name": "support.type.metaclass.python",
 920 |           "match": "\\bmetaclass\\b"
 921 |         },
 922 |         {
 923 |           "include": "#illegal-names"
 924 |         },
 925 |         {
 926 |           "include": "#class-kwarg"
 927 |         },
 928 |         {
 929 |           "include": "#call-wrapper-inheritance"
 930 |         },
 931 |         {
 932 |           "include": "#expression-base"
 933 |         },
 934 |         {
 935 |           "include": "#member-access-class"
 936 |         },
 937 |         {
 938 |           "include": "#inheritance-identifier"
 939 |         }
 940 |       ]
 941 |     },
 942 |     "class-kwarg": {
 943 |       "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\s*(=)(?!=)\n",
 944 |       "captures": {
 945 |         "1": {
 946 |           "name": "entity.other.inherited-class.python variable.parameter.class.python"
 947 |         },
 948 |         "2": {
 949 |           "name": "keyword.operator.assignment.python"
 950 |         }
 951 |       }
 952 |     },
 953 |     "inheritance-identifier": {
 954 |       "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n",
 955 |       "captures": {
 956 |         "1": {
 957 |           "name": "entity.other.inherited-class.python"
 958 |         }
 959 |       }
 960 |     },
 961 |     "member-access-class": {
 962 |       "name": "meta.member.access.python",
 963 |       "begin": "(\\.)\\s*(?!\\.)",
 964 |       "end": "(?<=\\S)(?=\\W)|$",
 965 |       "beginCaptures": {
 966 |         "1": {
 967 |           "name": "punctuation.separator.period.python"
 968 |         }
 969 |       },
 970 |       "patterns": [
 971 |         {
 972 |           "include": "#call-wrapper-inheritance"
 973 |         },
 974 |         {
 975 |           "include": "#member-access-base"
 976 |         },
 977 |         {
 978 |           "include": "#inheritance-identifier"
 979 |         }
 980 |       ]
 981 |     },
 982 |     "lambda": {
 983 |       "patterns": [
 984 |         {
 985 |           "match": "((?<=\\.)lambda|lambda(?=\\s*[\\.=]))",
 986 |           "captures": {
 987 |             "1": {
 988 |               "name": "keyword.control.flow.python"
 989 |             }
 990 |           }
 991 |         },
 992 |         {
 993 |           "match": "\\b(lambda)\\s*?(?=[,\\n]|$)",
 994 |           "captures": {
 995 |             "1": {
 996 |               "name": "storage.type.function.lambda.python"
 997 |             }
 998 |           }
 999 |         },
1000 |         {
1001 |           "name": "meta.lambda-function.python",
1002 |           "begin": "(?x)\n  \\b (lambda) \\b\n",
1003 |           "end": "(:)|(\\n)",
1004 |           "beginCaptures": {
1005 |             "1": {
1006 |               "name": "storage.type.function.lambda.python"
1007 |             }
1008 |           },
1009 |           "endCaptures": {
1010 |             "1": {
1011 |               "name": "punctuation.section.function.lambda.begin.python"
1012 |             }
1013 |           },
1014 |           "contentName": "meta.function.lambda.parameters.python",
1015 |           "patterns": [
1016 |             {
1017 |               "name": "storage.modifier",
1018 |               "match": "\\b(owned|borrowed|inout)\\b"
1019 |             },
1020 |             {
1021 |               "name": "keyword.operator.positional.parameter.python",
1022 |               "match": "/"
1023 |             },
1024 |             {
1025 |               "name": "keyword.operator.unpacking.parameter.python",
1026 |               "match": "(\\*\\*|\\*)"
1027 |             },
1028 |             {
1029 |               "include": "#lambda-nested-incomplete"
1030 |             },
1031 |             {
1032 |               "include": "#illegal-names"
1033 |             },
1034 |             {
1035 |               "match": "([[:alpha:]_]\\w*)\\s*(?:(,)|(?=:|$))",
1036 |               "captures": {
1037 |                 "1": {
1038 |                   "name": "variable.parameter.function.language.python"
1039 |                 },
1040 |                 "2": {
1041 |                   "name": "punctuation.separator.parameters.python"
1042 |                 }
1043 |               }
1044 |             },
1045 |             {
1046 |               "include": "#comments"
1047 |             },
1048 |             {
1049 |               "include": "#backticks"
1050 |             },
1051 |             {
1052 |               "include": "#lambda-parameter-with-default"
1053 |             },
1054 |             {
1055 |               "include": "#line-continuation"
1056 |             },
1057 |             {
1058 |               "include": "#illegal-operator"
1059 |             }
1060 |           ]
1061 |         }
1062 |       ]
1063 |     },
1064 |     "lambda-incomplete": {
1065 |       "name": "storage.type.function.lambda.python",
1066 |       "match": "\\blambda(?=\\s*[,)])"
1067 |     },
1068 |     "lambda-nested-incomplete": {
1069 |       "name": "storage.type.function.lambda.python",
1070 |       "match": "\\blambda(?=\\s*[:,)])"
1071 |     },
1072 |     "lambda-parameter-with-default": {
1073 |       "begin": "(?x)\n  \\b\n  ([[:alpha:]_]\\w*) \\s* (=)\n",
1074 |       "end": "(,)|(?=:|$)",
1075 |       "beginCaptures": {
1076 |         "1": {
1077 |           "name": "variable.parameter.function.language.python"
1078 |         },
1079 |         "2": {
1080 |           "name": "keyword.operator.python"
1081 |         }
1082 |       },
1083 |       "endCaptures": {
1084 |         "1": {
1085 |           "name": "punctuation.separator.parameters.python"
1086 |         }
1087 |       },
1088 |       "patterns": [
1089 |         {
1090 |           "include": "#expression"
1091 |         }
1092 |       ]
1093 |     },
1094 |     "generator": {
1095 |       "comment": "Match \"for ... in\" construct used in generators and for loops to\ncorrectly identify the \"in\" as a control flow keyword.\n",
1096 |       "begin": "\\bfor\\b",
1097 |       "beginCaptures": {
1098 |         "0": {
1099 |           "name": "keyword.control.flow.python"
1100 |         }
1101 |       },
1102 |       "end": "\\bin\\b",
1103 |       "endCaptures": {
1104 |         "0": {
1105 |           "name": "keyword.control.flow.python"
1106 |         }
1107 |       },
1108 |       "patterns": [
1109 |         {
1110 |           "include": "#expression"
1111 |         }
1112 |       ]
1113 |     },
1114 |     "function-declaration": {
1115 |       "name": "meta.function.python",
1116 |       "begin": "(?x)\n  \\s*\n  (?:\\b(async) \\s+)? \\b(def|fn)\\s+\n    (?=\n      [[:alpha:]_][[:word:]]* \\s* [\\(\\[]\n    )\n",
1117 |       "end": "(:|(?=[#'\"\\n]))",
1118 |       "beginCaptures": {
1119 |         "1": {
1120 |           "name": "storage.type.function.async.python"
1121 |         },
1122 |         "2": {
1123 |           "name": "storage.type.function.python"
1124 |         }
1125 |       },
1126 |       "endCaptures": {
1127 |         "1": {
1128 |           "name": "punctuation.section.function.begin.python"
1129 |         }
1130 |       },
1131 |       "patterns": [
1132 |         {
1133 |           "include": "#function-modifier"
1134 |         },
1135 |         {
1136 |           "include": "#function-def-name"
1137 |         },
1138 |         {
1139 |           "include": "#parameters"
1140 |         },
1141 |         {
1142 |           "include": "#meta_parameters"
1143 |         },
1144 |         {
1145 |           "include": "#line-continuation"
1146 |         },
1147 |         {
1148 |           "include": "#return-annotation"
1149 |         }
1150 |       ]
1151 |     },
1152 |     "function-def-name": {
1153 |       "patterns": [
1154 |         {
1155 |           "include": "#illegal-object-name"
1156 |         },
1157 |         {
1158 |           "include": "#builtin-possible-callables"
1159 |         },
1160 |         {
1161 |           "name": "entity.name.function.python",
1162 |           "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
1163 |         }
1164 |       ]
1165 |     },
1166 |     "function-modifier": {
1167 |       "name": "storage.modifier",
1168 |       "match": "(raises|capturing)"
1169 |     },
1170 |     "parameters": {
1171 |       "name": "meta.function.parameters.python",
1172 |       "begin": "(\\()",
1173 |       "end": "(\\))",
1174 |       "beginCaptures": {
1175 |         "1": {
1176 |           "name": "punctuation.definition.parameters.begin.python"
1177 |         }
1178 |       },
1179 |       "endCaptures": {
1180 |         "1": {
1181 |           "name": "punctuation.definition.parameters.end.python"
1182 |         }
1183 |       },
1184 |       "patterns": [
1185 |         {
1186 |           "name": "storage.modifier",
1187 |           "match": "\\b(owned|borrowed|inout)\\b"
1188 |         },
1189 |         {
1190 |           "name": "keyword.operator.positional.parameter.python",
1191 |           "match": "/"
1192 |         },
1193 |         {
1194 |           "name": "keyword.operator.unpacking.parameter.python",
1195 |           "match": "(\\*\\*|\\*)"
1196 |         },
1197 |         {
1198 |           "include": "#lambda-incomplete"
1199 |         },
1200 |         {
1201 |           "include": "#illegal-names"
1202 |         },
1203 |         {
1204 |           "include": "#illegal-object-name"
1205 |         },
1206 |         {
1207 |           "include": "#parameter-special"
1208 |         },
1209 |         {
1210 |           "match": "(?x)\n  ([[:alpha:]_]\\w*)\n    \\s* (?: (,) | (?=[)#\\n=]))\n",
1211 |           "captures": {
1212 |             "1": {
1213 |               "name": "variable.parameter.function.language.python"
1214 |             },
1215 |             "2": {
1216 |               "name": "punctuation.separator.parameters.python"
1217 |             }
1218 |           }
1219 |         },
1220 |         {
1221 |           "include": "#comments"
1222 |         },
1223 |         {
1224 |           "include": "#loose-default"
1225 |         },
1226 |         {
1227 |           "include": "#annotated-parameter"
1228 |         }
1229 |       ]
1230 |     },
1231 |     "meta_parameters": {
1232 |       "name": "meta.function.parameters.python",
1233 |       "begin": "(\\[)",
1234 |       "end": "(\\])",
1235 |       "beginCaptures": {
1236 |         "1": {
1237 |           "name": "punctuation.definition.parameters.begin.python"
1238 |         }
1239 |       },
1240 |       "endCaptures": {
1241 |         "1": {
1242 |           "name": "punctuation.definition.parameters.end.python"
1243 |         }
1244 |       },
1245 |       "patterns": [
1246 |         {
1247 |           "begin": "(?x)\n  \\b\n  ([[:alpha:]_]\\w*) \\s* (:)\n",
1248 |           "end": "(,)|(?=\\])",
1249 |           "beginCaptures": {
1250 |             "1": {
1251 |               "name": "variable.parameter.function.language.python"
1252 |             },
1253 |             "2": {
1254 |               "name": "punctuation.separator.annotation.python"
1255 |             }
1256 |           },
1257 |           "endCaptures": {
1258 |             "1": {
1259 |               "name": "punctuation.separator.parameters.python"
1260 |             }
1261 |           },
1262 |           "patterns": [
1263 |             {
1264 |               "include": "#expression"
1265 |             }
1266 |           ]
1267 |         },
1268 |         {
1269 |           "include": "#comments"
1270 |         }
1271 |       ]
1272 |     },
1273 |     "parameter-special": {
1274 |       "match": "(?x)\n  \\b ((self)|(cls)) \\b \\s*(?:(,)|(?=\\)))\n",
1275 |       "captures": {
1276 |         "1": {
1277 |           "name": "variable.parameter.function.language.python"
1278 |         },
1279 |         "2": {
1280 |           "name": "variable.parameter.function.language.special.self.python"
1281 |         },
1282 |         "3": {
1283 |           "name": "variable.parameter.function.language.special.cls.python"
1284 |         },
1285 |         "4": {
1286 |           "name": "punctuation.separator.parameters.python"
1287 |         }
1288 |       }
1289 |     },
1290 |     "loose-default": {
1291 |       "begin": "(=)",
1292 |       "end": "(,)|(?=\\))",
1293 |       "beginCaptures": {
1294 |         "1": {
1295 |           "name": "keyword.operator.python"
1296 |         }
1297 |       },
1298 |       "endCaptures": {
1299 |         "1": {
1300 |           "name": "punctuation.separator.parameters.python"
1301 |         }
1302 |       },
1303 |       "patterns": [
1304 |         {
1305 |           "include": "#expression"
1306 |         }
1307 |       ]
1308 |     },
1309 |     "annotated-parameter": {
1310 |       "begin": "(?x)\n  \\b\n  ([[:alpha:]_]\\w*) \\s* (:)\n",
1311 |       "end": "(,)|(?=\\))",
1312 |       "beginCaptures": {
1313 |         "1": {
1314 |           "name": "variable.parameter.function.language.python"
1315 |         },
1316 |         "2": {
1317 |           "name": "punctuation.separator.annotation.python"
1318 |         }
1319 |       },
1320 |       "endCaptures": {
1321 |         "1": {
1322 |           "name": "punctuation.separator.parameters.python"
1323 |         }
1324 |       },
1325 |       "patterns": [
1326 |         {
1327 |           "include": "#expression"
1328 |         },
1329 |         {
1330 |           "name": "keyword.operator.assignment.python",
1331 |           "match": "=(?!=)"
1332 |         }
1333 |       ]
1334 |     },
1335 |     "return-annotation": {
1336 |       "begin": "(->)",
1337 |       "end": "(?=:)",
1338 |       "beginCaptures": {
1339 |         "1": {
1340 |           "name": "punctuation.separator.annotation.result.python"
1341 |         }
1342 |       },
1343 |       "patterns": [
1344 |         {
1345 |           "include": "#expression"
1346 |         }
1347 |       ]
1348 |     },
1349 |     "item-access": {
1350 |       "patterns": [
1351 |         {
1352 |           "name": "meta.item-access.python",
1353 |           "begin": "(?x)\n  \\b(?=\n    [[:alpha:]_]\\w* \\s* \\[\n  )\n",
1354 |           "end": "(\\])",
1355 |           "endCaptures": {
1356 |             "1": {
1357 |               "name": "punctuation.definition.arguments.end.python"
1358 |             }
1359 |           },
1360 |           "patterns": [
1361 |             {
1362 |               "include": "#item-name"
1363 |             },
1364 |             {
1365 |               "include": "#item-index"
1366 |             },
1367 |             {
1368 |               "include": "#expression"
1369 |             }
1370 |           ]
1371 |         }
1372 |       ]
1373 |     },
1374 |     "item-name": {
1375 |       "patterns": [
1376 |         {
1377 |           "include": "#special-variables"
1378 |         },
1379 |         {
1380 |           "include": "#builtin-functions"
1381 |         },
1382 |         {
1383 |           "include": "#special-names"
1384 |         },
1385 |         {
1386 |           "name": "meta.indexed-name.python",
1387 |           "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
1388 |         }
1389 |       ]
1390 |     },
1391 |     "item-index": {
1392 |       "begin": "(\\[)",
1393 |       "end": "(?=\\])",
1394 |       "beginCaptures": {
1395 |         "1": {
1396 |           "name": "punctuation.definition.arguments.begin.python"
1397 |         }
1398 |       },
1399 |       "contentName": "meta.item-access.arguments.python",
1400 |       "patterns": [
1401 |         {
1402 |           "name": "punctuation.separator.slice.python",
1403 |           "match": ":"
1404 |         },
1405 |         {
1406 |           "include": "#expression"
1407 |         }
1408 |       ]
1409 |     },
1410 |     "decorator": {
1411 |       "name": "meta.function.decorator.python",
1412 |       "begin": "(?x)\n  ^\\s*\n  ((@)) \\s* (?=[[:alpha:]_]\\w*)\n",
1413 |       "end": "(?x)\n  ( \\) )\n    # trailing whitespace and comments are legal\n    (?: (.*?) (?=\\s*(?:\\#|$)) )\n  | (?=\\n|\\#)\n",
1414 |       "beginCaptures": {
1415 |         "1": {
1416 |           "name": "entity.name.function.decorator.python"
1417 |         },
1418 |         "2": {
1419 |           "name": "punctuation.definition.decorator.python"
1420 |         }
1421 |       },
1422 |       "endCaptures": {
1423 |         "1": {
1424 |           "name": "punctuation.definition.arguments.end.python"
1425 |         },
1426 |         "2": {
1427 |           "name": "invalid.illegal.decorator.python"
1428 |         }
1429 |       },
1430 |       "patterns": [
1431 |         {
1432 |           "include": "#decorator-name"
1433 |         },
1434 |         {
1435 |           "include": "#function-arguments"
1436 |         }
1437 |       ]
1438 |     },
1439 |     "decorator-name": {
1440 |       "patterns": [
1441 |         {
1442 |           "include": "#builtin-callables"
1443 |         },
1444 |         {
1445 |           "include": "#illegal-object-name"
1446 |         },
1447 |         {
1448 |           "name": "entity.name.function.decorator.python",
1449 |           "match": "(?x)\n  ([[:alpha:]_]\\w*) | (\\.)\n",
1450 |           "captures": {
1451 |             "2": {
1452 |               "name": "punctuation.separator.period.python"
1453 |             }
1454 |           }
1455 |         },
1456 |         {
1457 |           "include": "#line-continuation"
1458 |         },
1459 |         {
1460 |           "name": "invalid.illegal.decorator.python",
1461 |           "match": "(?x)\n  \\s* ([^([:alpha:]\\s_\\.#\\\\] .*?) (?=\\#|$)\n",
1462 |           "captures": {
1463 |             "1": {
1464 |               "name": "invalid.illegal.decorator.python"
1465 |             }
1466 |           }
1467 |         }
1468 |       ]
1469 |     },
1470 |     "call-wrapper-inheritance": {
1471 |       "comment": "same as a function call, but in inheritance context",
1472 |       "name": "meta.function-call.python",
1473 |       "begin": "(?x)\n  \\b(?=\n    ([[:alpha:]_]\\w*) \\s* (\\()\n  )\n",
1474 |       "end": "(\\))",
1475 |       "endCaptures": {
1476 |         "1": {
1477 |           "name": "punctuation.definition.arguments.end.python"
1478 |         }
1479 |       },
1480 |       "patterns": [
1481 |         {
1482 |           "include": "#inheritance-name"
1483 |         },
1484 |         {
1485 |           "include": "#function-arguments"
1486 |         }
1487 |       ]
1488 |     },
1489 |     "inheritance-name": {
1490 |       "patterns": [
1491 |         {
1492 |           "include": "#lambda-incomplete"
1493 |         },
1494 |         {
1495 |           "include": "#builtin-possible-callables"
1496 |         },
1497 |         {
1498 |           "include": "#inheritance-identifier"
1499 |         }
1500 |       ]
1501 |     },
1502 |     "function-call": {
1503 |       "name": "meta.function-call.python",
1504 |       "comment": "Regular function call of the type \"name(args)\"",
1505 |       "begin": "(?x)\n  \\b(?=\n    ([[:alpha:]_]\\w*) \\s* (\\()\n  )\n",
1506 |       "end": "(\\))",
1507 |       "endCaptures": {
1508 |         "1": {
1509 |           "name": "punctuation.definition.arguments.end.python"
1510 |         }
1511 |       },
1512 |       "patterns": [
1513 |         {
1514 |           "include": "#special-variables"
1515 |         },
1516 |         {
1517 |           "include": "#function-name"
1518 |         },
1519 |         {
1520 |           "include": "#function-arguments"
1521 |         }
1522 |       ]
1523 |     },
1524 |     "function-name": {
1525 |       "patterns": [
1526 |         {
1527 |           "include": "#builtin-possible-callables"
1528 |         },
1529 |         {
1530 |           "comment": "Some color schemas support meta.function-call.generic scope",
1531 |           "name": "meta.function-call.generic.python",
1532 |           "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
1533 |         }
1534 |       ]
1535 |     },
1536 |     "function-arguments": {
1537 |       "begin": "(\\()",
1538 |       "end": "(?=\\))(?!\\)\\s*\\()",
1539 |       "beginCaptures": {
1540 |         "1": {
1541 |           "name": "punctuation.definition.arguments.begin.python"
1542 |         }
1543 |       },
1544 |       "contentName": "meta.function-call.arguments.python",
1545 |       "patterns": [
1546 |         {
1547 |           "name": "punctuation.separator.arguments.python",
1548 |           "match": "(,)"
1549 |         },
1550 |         {
1551 |           "match": "(?x)\n  (?:(?<=[,(])|^) \\s* (\\*{1,2})\n",
1552 |           "captures": {
1553 |             "1": {
1554 |               "name": "keyword.operator.unpacking.arguments.python"
1555 |             }
1556 |           }
1557 |         },
1558 |         {
1559 |           "include": "#lambda-incomplete"
1560 |         },
1561 |         {
1562 |           "include": "#illegal-names"
1563 |         },
1564 |         {
1565 |           "match": "\\b([[:alpha:]_]\\w*)\\s*(=)(?!=)",
1566 |           "captures": {
1567 |             "1": {
1568 |               "name": "variable.parameter.function-call.python"
1569 |             },
1570 |             "2": {
1571 |               "name": "keyword.operator.assignment.python"
1572 |             }
1573 |           }
1574 |         },
1575 |         {
1576 |           "name": "keyword.operator.assignment.python",
1577 |           "match": "=(?!=)"
1578 |         },
1579 |         {
1580 |           "include": "#expression"
1581 |         },
1582 |         {
1583 |           "match": "\\s*(\\))\\s*(\\()",
1584 |           "captures": {
1585 |             "1": {
1586 |               "name": "punctuation.definition.arguments.end.python"
1587 |             },
1588 |             "2": {
1589 |               "name": "punctuation.definition.arguments.begin.python"
1590 |             }
1591 |           }
1592 |         }
1593 |       ]
1594 |     },
1595 |     "builtin-callables": {
1596 |       "patterns": [
1597 |         {
1598 |           "include": "#illegal-names"
1599 |         },
1600 |         {
1601 |           "include": "#illegal-object-name"
1602 |         },
1603 |         {
1604 |           "include": "#builtin-exceptions"
1605 |         },
1606 |         {
1607 |           "include": "#builtin-functions"
1608 |         },
1609 |         {
1610 |           "include": "#builtin-types"
1611 |         }
1612 |       ]
1613 |     },
1614 |     "builtin-possible-callables": {
1615 |       "patterns": [
1616 |         {
1617 |           "include": "#builtin-callables"
1618 |         },
1619 |         {
1620 |           "include": "#magic-names"
1621 |         }
1622 |       ]
1623 |     },
1624 |     "builtin-exceptions": {
1625 |       "name": "support.type.exception.python",
1626 |       "match": "(?x) (?<!\\.) \\b(\n  (\n    Arithmetic | 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|\n  SystemExit | Stop(Async)?Iteration\n  | KeyboardInterrupt\n  | GeneratorExit | (Base)?Exception\n)\\b\n"
1627 |     },
1628 |     "builtin-functions": {
1629 |       "patterns": [
1630 |         {
1631 |           "name": "support.function.builtin.python",
1632 |           "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"
1633 |         },
1634 |         {
1635 |           "name": "variable.legacy.builtin.python",
1636 |           "match": "(?x)\n  (?<!\\.) \\b(\n    file | reduce | intern | raw_input | unicode | cmp | basestring\n    | execfile | long | xrange\n  )\\b\n"
1637 |         }
1638 |       ]
1639 |     },
1640 |     "builtin-types": {
1641 |       "name": "support.type.python",
1642 |       "match": "(?x)\n  (?<!\\.) \\b(\n    __mlir_attr | __mlir_op | __mlir_type | bool | 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,\n        and is special enough to be highlighted differently from\n        other built-ins)\n    | super\n  )\\b\n"
1643 |     },
1644 |     "magic-function-names": {
1645 |       "comment": "these methods have magic interpretation by python and are generally called\nindirectly through syntactic constructs\n",
1646 |       "match": "(?x)\n  \\b(\n    __(?:\n      abs | 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",
1647 |       "captures": {
1648 |         "1": {
1649 |           "name": "support.function.magic.python"
1650 |         }
1651 |       }
1652 |     },
1653 |     "magic-variable-names": {
1654 |       "comment": "magic variables which a class/module may have.",
1655 |       "match": "(?x)\n  \\b(\n    __(?:\n      all | annotations | bases | builtins | class\n      | struct\n      | trait\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",
1656 |       "captures": {
1657 |         "1": {
1658 |           "name": "support.variable.magic.python"
1659 |         }
1660 |       }
1661 |     },
1662 |     "magic-names": {
1663 |       "patterns": [
1664 |         {
1665 |           "include": "#magic-function-names"
1666 |         },
1667 |         {
1668 |           "include": "#magic-variable-names"
1669 |         }
1670 |       ]
1671 |     },
1672 |     "illegal-names": {
1673 |       "match": "(?x)\n  \\b(?:\n    (\n      and | assert | async | await | break | class | struct | trait | continue | 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    ) | (def | fn | capturing | raises) | (\n      as | import\n    )\n  )\\b\n",
1674 |       "captures": {
1675 |         "1": {
1676 |           "name": "keyword.control.flow.python"
1677 |         },
1678 |         "2": {
1679 |           "name": "storage.type.function.python"
1680 |         },
1681 |         "3": {
1682 |           "name": "keyword.control.import.python"
1683 |         }
1684 |       }
1685 |     },
1686 |     "special-variables": {
1687 |       "match": "(?x)\n  \\b (?<!\\.) (?:\n    (self) | (cls)\n  )\\b\n",
1688 |       "captures": {
1689 |         "1": {
1690 |           "name": "variable.language.special.self.python"
1691 |         },
1692 |         "2": {
1693 |           "name": "variable.language.special.cls.python"
1694 |         }
1695 |       }
1696 |     },
1697 |     "ellipsis": {
1698 |       "name": "constant.other.ellipsis.python",
1699 |       "match": "\\.\\.\\."
1700 |     },
1701 |     "backticks": {
1702 |       "name": "string.quoted.single.python",
1703 |       "begin": "\\`",
1704 |       "end": "(?:\\`|(?<!\\\\)(\\n))"
1705 |     },
1706 |     "illegal-operator": {
1707 |       "patterns": [
1708 |         {
1709 |           "name": "invalid.illegal.operator.python",
1710 |           "match": "&&|\\|\\||--|\\+\\+"
1711 |         },
1712 |         {
1713 |           "name": "invalid.illegal.operator.python",
1714 |           "match": "[?$]"
1715 |         },
1716 |         {
1717 |           "name": "invalid.illegal.operator.python",
1718 |           "comment": "We don't want `!` to flash when we're typing `!=`",
1719 |           "match": "!\\b"
1720 |         }
1721 |       ]
1722 |     },
1723 |     "illegal-object-name": {
1724 |       "comment": "It's illegal to name class or function \"True\"",
1725 |       "name": "keyword.illegal.name.python",
1726 |       "match": "\\b(True|False|None)\\b"
1727 |     },
1728 |     "regexp-base-expression": {
1729 |       "patterns": [
1730 |         {
1731 |           "include": "#regexp-quantifier"
1732 |         },
1733 |         {
1734 |           "include": "#regexp-base-common"
1735 |         }
1736 |       ]
1737 |     },
1738 |     "fregexp-base-expression": {
1739 |       "patterns": [
1740 |         {
1741 |           "include": "#fregexp-quantifier"
1742 |         },
1743 |         {
1744 |           "include": "#fstring-formatting-braces"
1745 |         },
1746 |         {
1747 |           "match": "\\{.*?\\}"
1748 |         },
1749 |         {
1750 |           "include": "#regexp-base-common"
1751 |         }
1752 |       ]
1753 |     },
1754 |     "fstring-formatting-braces": {
1755 |       "patterns": [
1756 |         {
1757 |           "comment": "empty braces are illegal",
1758 |           "match": "({)(\\s*?)(})",
1759 |           "captures": {
1760 |             "1": {
1761 |               "name": "constant.character.format.placeholder.other.python"
1762 |             },
1763 |             "2": {
1764 |               "name": "invalid.illegal.brace.python"
1765 |             },
1766 |             "3": {
1767 |               "name": "constant.character.format.placeholder.other.python"
1768 |             }
1769 |           }
1770 |         },
1771 |         {
1772 |           "name": "constant.character.escape.python",
1773 |           "match": "({{|}})"
1774 |         }
1775 |       ]
1776 |     },
1777 |     "regexp-base-common": {
1778 |       "patterns": [
1779 |         {
1780 |           "name": "support.other.match.any.regexp",
1781 |           "match": "\\."
1782 |         },
1783 |         {
1784 |           "name": "support.other.match.begin.regexp",
1785 |           "match": "\\^"
1786 |         },
1787 |         {
1788 |           "name": "support.other.match.end.regexp",
1789 |           "match": "\\$"
1790 |         },
1791 |         {
1792 |           "name": "keyword.operator.quantifier.regexp",
1793 |           "match": "[+*?]\\??"
1794 |         },
1795 |         {
1796 |           "name": "keyword.operator.disjunction.regexp",
1797 |           "match": "\\|"
1798 |         },
1799 |         {
1800 |           "include": "#regexp-escape-sequence"
1801 |         }
1802 |       ]
1803 |     },
1804 |     "regexp-quantifier": {
1805 |       "name": "keyword.operator.quantifier.regexp",
1806 |       "match": "(?x)\n  \\{(\n    \\d+ | \\d+,(\\d+)? | ,\\d+\n  )\\}\n"
1807 |     },
1808 |     "fregexp-quantifier": {
1809 |       "name": "keyword.operator.quantifier.regexp",
1810 |       "match": "(?x)\n  \\{\\{(\n    \\d+ | \\d+,(\\d+)? | ,\\d+\n  )\\}\\}\n"
1811 |     },
1812 |     "regexp-backreference-number": {
1813 |       "name": "meta.backreference.regexp",
1814 |       "match": "(\\\\[1-9]\\d?)",
1815 |       "captures": {
1816 |         "1": {
1817 |           "name": "entity.name.tag.backreference.regexp"
1818 |         }
1819 |       }
1820 |     },
1821 |     "regexp-backreference": {
1822 |       "name": "meta.backreference.named.regexp",
1823 |       "match": "(?x)\n  (\\()  (\\?P= \\w+(?:\\s+[[:alnum:]]+)?)  (\\))\n",
1824 |       "captures": {
1825 |         "1": {
1826 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.backreference.named.begin.regexp"
1827 |         },
1828 |         "2": {
1829 |           "name": "entity.name.tag.named.backreference.regexp"
1830 |         },
1831 |         "3": {
1832 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.backreference.named.end.regexp"
1833 |         }
1834 |       }
1835 |     },
1836 |     "regexp-flags": {
1837 |       "name": "storage.modifier.flag.regexp",
1838 |       "match": "\\(\\?[aiLmsux]+\\)"
1839 |     },
1840 |     "regexp-escape-special": {
1841 |       "name": "support.other.escape.special.regexp",
1842 |       "match": "\\\\([AbBdDsSwWZ])"
1843 |     },
1844 |     "regexp-escape-character": {
1845 |       "name": "constant.character.escape.regexp",
1846 |       "match": "(?x)\n  \\\\ (\n        x[0-9A-Fa-f]{2}\n        | 0[0-7]{1,2}\n        | [0-7]{3}\n     )\n"
1847 |     },
1848 |     "regexp-escape-unicode": {
1849 |       "name": "constant.character.unicode.regexp",
1850 |       "match": "(?x)\n  \\\\ (\n        u[0-9A-Fa-f]{4}\n        | U[0-9A-Fa-f]{8}\n     )\n"
1851 |     },
1852 |     "regexp-escape-catchall": {
1853 |       "name": "constant.character.escape.regexp",
1854 |       "match": "\\\\(.|\\n)"
1855 |     },
1856 |     "regexp-escape-sequence": {
1857 |       "patterns": [
1858 |         {
1859 |           "include": "#regexp-escape-special"
1860 |         },
1861 |         {
1862 |           "include": "#regexp-escape-character"
1863 |         },
1864 |         {
1865 |           "include": "#regexp-escape-unicode"
1866 |         },
1867 |         {
1868 |           "include": "#regexp-backreference-number"
1869 |         },
1870 |         {
1871 |           "include": "#regexp-escape-catchall"
1872 |         }
1873 |       ]
1874 |     },
1875 |     "regexp-charecter-set-escapes": {
1876 |       "patterns": [
1877 |         {
1878 |           "name": "constant.character.escape.regexp",
1879 |           "match": "\\\\[abfnrtv\\\\]"
1880 |         },
1881 |         {
1882 |           "include": "#regexp-escape-special"
1883 |         },
1884 |         {
1885 |           "name": "constant.character.escape.regexp",
1886 |           "match": "\\\\([0-7]{1,3})"
1887 |         },
1888 |         {
1889 |           "include": "#regexp-escape-character"
1890 |         },
1891 |         {
1892 |           "include": "#regexp-escape-unicode"
1893 |         },
1894 |         {
1895 |           "include": "#regexp-escape-catchall"
1896 |         }
1897 |       ]
1898 |     },
1899 |     "codetags": {
1900 |       "match": "(?:\\b(NOTE|XXX|HACK|FIXME|BUG|TODO)\\b)",
1901 |       "captures": {
1902 |         "1": {
1903 |           "name": "keyword.codetag.notation.python"
1904 |         }
1905 |       }
1906 |     },
1907 |     "comments-base": {
1908 |       "name": "comment.line.number-sign.python",
1909 |       "begin": "(\\#)",
1910 |       "beginCaptures": {
1911 |         "1": {
1912 |           "name": "punctuation.definition.comment.python"
1913 |         }
1914 |       },
1915 |       "end": "($)",
1916 |       "patterns": [
1917 |         {
1918 |           "include": "#codetags"
1919 |         }
1920 |       ]
1921 |     },
1922 |     "comments-string-single-three": {
1923 |       "name": "comment.line.number-sign.python",
1924 |       "begin": "(\\#)",
1925 |       "beginCaptures": {
1926 |         "1": {
1927 |           "name": "punctuation.definition.comment.python"
1928 |         }
1929 |       },
1930 |       "end": "($|(?='''))",
1931 |       "patterns": [
1932 |         {
1933 |           "include": "#codetags"
1934 |         }
1935 |       ]
1936 |     },
1937 |     "comments-string-double-three": {
1938 |       "name": "comment.line.number-sign.python",
1939 |       "begin": "(\\#)",
1940 |       "beginCaptures": {
1941 |         "1": {
1942 |           "name": "punctuation.definition.comment.python"
1943 |         }
1944 |       },
1945 |       "end": "($|(?=\"\"\"))",
1946 |       "patterns": [
1947 |         {
1948 |           "include": "#codetags"
1949 |         }
1950 |       ]
1951 |     },
1952 |     "single-one-regexp-expression": {
1953 |       "patterns": [
1954 |         {
1955 |           "include": "#regexp-base-expression"
1956 |         },
1957 |         {
1958 |           "include": "#single-one-regexp-character-set"
1959 |         },
1960 |         {
1961 |           "include": "#single-one-regexp-comments"
1962 |         },
1963 |         {
1964 |           "include": "#regexp-flags"
1965 |         },
1966 |         {
1967 |           "include": "#single-one-regexp-named-group"
1968 |         },
1969 |         {
1970 |           "include": "#regexp-backreference"
1971 |         },
1972 |         {
1973 |           "include": "#single-one-regexp-lookahead"
1974 |         },
1975 |         {
1976 |           "include": "#single-one-regexp-lookahead-negative"
1977 |         },
1978 |         {
1979 |           "include": "#single-one-regexp-lookbehind"
1980 |         },
1981 |         {
1982 |           "include": "#single-one-regexp-lookbehind-negative"
1983 |         },
1984 |         {
1985 |           "include": "#single-one-regexp-conditional"
1986 |         },
1987 |         {
1988 |           "include": "#single-one-regexp-parentheses-non-capturing"
1989 |         },
1990 |         {
1991 |           "include": "#single-one-regexp-parentheses"
1992 |         }
1993 |       ]
1994 |     },
1995 |     "single-one-regexp-character-set": {
1996 |       "patterns": [
1997 |         {
1998 |           "match": "(?x)\n  \\[ \\^? \\] (?! .*?\\])\n"
1999 |         },
2000 |         {
2001 |           "name": "meta.character.set.regexp",
2002 |           "begin": "(\\[)(\\^)?(\\])?",
2003 |           "end": "(\\]|(?=\\'))|((?=(?<!\\\\)\\n))",
2004 |           "beginCaptures": {
2005 |             "1": {
2006 |               "name": "punctuation.character.set.begin.regexp constant.other.set.regexp"
2007 |             },
2008 |             "2": {
2009 |               "name": "keyword.operator.negation.regexp"
2010 |             },
2011 |             "3": {
2012 |               "name": "constant.character.set.regexp"
2013 |             }
2014 |           },
2015 |           "endCaptures": {
2016 |             "1": {
2017 |               "name": "punctuation.character.set.end.regexp constant.other.set.regexp"
2018 |             },
2019 |             "2": {
2020 |               "name": "invalid.illegal.newline.python"
2021 |             }
2022 |           },
2023 |           "patterns": [
2024 |             {
2025 |               "include": "#regexp-charecter-set-escapes"
2026 |             },
2027 |             {
2028 |               "name": "constant.character.set.regexp",
2029 |               "match": "[^\\n]"
2030 |             }
2031 |           ]
2032 |         }
2033 |       ]
2034 |     },
2035 |     "single-one-regexp-named-group": {
2036 |       "name": "meta.named.regexp",
2037 |       "begin": "(?x)\n  (\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
2038 |       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
2039 |       "beginCaptures": {
2040 |         "1": {
2041 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
2042 |         },
2043 |         "2": {
2044 |           "name": "entity.name.tag.named.group.regexp"
2045 |         }
2046 |       },
2047 |       "endCaptures": {
2048 |         "1": {
2049 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp"
2050 |         },
2051 |         "2": {
2052 |           "name": "invalid.illegal.newline.python"
2053 |         }
2054 |       },
2055 |       "patterns": [
2056 |         {
2057 |           "include": "#single-one-regexp-expression"
2058 |         }
2059 |       ]
2060 |     },
2061 |     "single-one-regexp-comments": {
2062 |       "name": "comment.regexp",
2063 |       "begin": "\\(\\?#",
2064 |       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
2065 |       "beginCaptures": {
2066 |         "0": {
2067 |           "name": "punctuation.comment.begin.regexp"
2068 |         }
2069 |       },
2070 |       "endCaptures": {
2071 |         "1": {
2072 |           "name": "punctuation.comment.end.regexp"
2073 |         },
2074 |         "2": {
2075 |           "name": "invalid.illegal.newline.python"
2076 |         }
2077 |       },
2078 |       "patterns": [
2079 |         {
2080 |           "include": "#codetags"
2081 |         }
2082 |       ]
2083 |     },
2084 |     "single-one-regexp-lookahead": {
2085 |       "begin": "(\\()\\?=",
2086 |       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
2087 |       "beginCaptures": {
2088 |         "0": {
2089 |           "name": "keyword.operator.lookahead.regexp"
2090 |         },
2091 |         "1": {
2092 |           "name": "punctuation.parenthesis.lookahead.begin.regexp"
2093 |         }
2094 |       },
2095 |       "endCaptures": {
2096 |         "1": {
2097 |           "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp"
2098 |         },
2099 |         "2": {
2100 |           "name": "invalid.illegal.newline.python"
2101 |         }
2102 |       },
2103 |       "patterns": [
2104 |         {
2105 |           "include": "#single-one-regexp-expression"
2106 |         }
2107 |       ]
2108 |     },
2109 |     "single-one-regexp-lookahead-negative": {
2110 |       "begin": "(\\()\\?!",
2111 |       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
2112 |       "beginCaptures": {
2113 |         "0": {
2114 |           "name": "keyword.operator.lookahead.negative.regexp"
2115 |         },
2116 |         "1": {
2117 |           "name": "punctuation.parenthesis.lookahead.begin.regexp"
2118 |         }
2119 |       },
2120 |       "endCaptures": {
2121 |         "1": {
2122 |           "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp"
2123 |         },
2124 |         "2": {
2125 |           "name": "invalid.illegal.newline.python"
2126 |         }
2127 |       },
2128 |       "patterns": [
2129 |         {
2130 |           "include": "#single-one-regexp-expression"
2131 |         }
2132 |       ]
2133 |     },
2134 |     "single-one-regexp-lookbehind": {
2135 |       "begin": "(\\()\\?<=",
2136 |       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
2137 |       "beginCaptures": {
2138 |         "0": {
2139 |           "name": "keyword.operator.lookbehind.regexp"
2140 |         },
2141 |         "1": {
2142 |           "name": "punctuation.parenthesis.lookbehind.begin.regexp"
2143 |         }
2144 |       },
2145 |       "endCaptures": {
2146 |         "1": {
2147 |           "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp"
2148 |         },
2149 |         "2": {
2150 |           "name": "invalid.illegal.newline.python"
2151 |         }
2152 |       },
2153 |       "patterns": [
2154 |         {
2155 |           "include": "#single-one-regexp-expression"
2156 |         }
2157 |       ]
2158 |     },
2159 |     "single-one-regexp-lookbehind-negative": {
2160 |       "begin": "(\\()\\?<!",
2161 |       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
2162 |       "beginCaptures": {
2163 |         "0": {
2164 |           "name": "keyword.operator.lookbehind.negative.regexp"
2165 |         },
2166 |         "1": {
2167 |           "name": "punctuation.parenthesis.lookbehind.begin.regexp"
2168 |         }
2169 |       },
2170 |       "endCaptures": {
2171 |         "1": {
2172 |           "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp"
2173 |         },
2174 |         "2": {
2175 |           "name": "invalid.illegal.newline.python"
2176 |         }
2177 |       },
2178 |       "patterns": [
2179 |         {
2180 |           "include": "#single-one-regexp-expression"
2181 |         }
2182 |       ]
2183 |     },
2184 |     "single-one-regexp-conditional": {
2185 |       "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
2186 |       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
2187 |       "beginCaptures": {
2188 |         "0": {
2189 |           "name": "keyword.operator.conditional.regexp"
2190 |         },
2191 |         "1": {
2192 |           "name": "punctuation.parenthesis.conditional.begin.regexp"
2193 |         }
2194 |       },
2195 |       "endCaptures": {
2196 |         "1": {
2197 |           "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp"
2198 |         },
2199 |         "2": {
2200 |           "name": "invalid.illegal.newline.python"
2201 |         }
2202 |       },
2203 |       "patterns": [
2204 |         {
2205 |           "include": "#single-one-regexp-expression"
2206 |         }
2207 |       ]
2208 |     },
2209 |     "single-one-regexp-parentheses-non-capturing": {
2210 |       "begin": "\\(\\?:",
2211 |       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
2212 |       "beginCaptures": {
2213 |         "0": {
2214 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp"
2215 |         }
2216 |       },
2217 |       "endCaptures": {
2218 |         "1": {
2219 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp"
2220 |         },
2221 |         "2": {
2222 |           "name": "invalid.illegal.newline.python"
2223 |         }
2224 |       },
2225 |       "patterns": [
2226 |         {
2227 |           "include": "#single-one-regexp-expression"
2228 |         }
2229 |       ]
2230 |     },
2231 |     "single-one-regexp-parentheses": {
2232 |       "begin": "\\(",
2233 |       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
2234 |       "beginCaptures": {
2235 |         "0": {
2236 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp"
2237 |         }
2238 |       },
2239 |       "endCaptures": {
2240 |         "1": {
2241 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.regexp"
2242 |         },
2243 |         "2": {
2244 |           "name": "invalid.illegal.newline.python"
2245 |         }
2246 |       },
2247 |       "patterns": [
2248 |         {
2249 |           "include": "#single-one-regexp-expression"
2250 |         }
2251 |       ]
2252 |     },
2253 |     "single-three-regexp-expression": {
2254 |       "patterns": [
2255 |         {
2256 |           "include": "#regexp-base-expression"
2257 |         },
2258 |         {
2259 |           "include": "#single-three-regexp-character-set"
2260 |         },
2261 |         {
2262 |           "include": "#single-three-regexp-comments"
2263 |         },
2264 |         {
2265 |           "include": "#regexp-flags"
2266 |         },
2267 |         {
2268 |           "include": "#single-three-regexp-named-group"
2269 |         },
2270 |         {
2271 |           "include": "#regexp-backreference"
2272 |         },
2273 |         {
2274 |           "include": "#single-three-regexp-lookahead"
2275 |         },
2276 |         {
2277 |           "include": "#single-three-regexp-lookahead-negative"
2278 |         },
2279 |         {
2280 |           "include": "#single-three-regexp-lookbehind"
2281 |         },
2282 |         {
2283 |           "include": "#single-three-regexp-lookbehind-negative"
2284 |         },
2285 |         {
2286 |           "include": "#single-three-regexp-conditional"
2287 |         },
2288 |         {
2289 |           "include": "#single-three-regexp-parentheses-non-capturing"
2290 |         },
2291 |         {
2292 |           "include": "#single-three-regexp-parentheses"
2293 |         },
2294 |         {
2295 |           "include": "#comments-string-single-three"
2296 |         }
2297 |       ]
2298 |     },
2299 |     "single-three-regexp-character-set": {
2300 |       "patterns": [
2301 |         {
2302 |           "match": "(?x)\n  \\[ \\^? \\] (?! .*?\\])\n"
2303 |         },
2304 |         {
2305 |           "name": "meta.character.set.regexp",
2306 |           "begin": "(\\[)(\\^)?(\\])?",
2307 |           "end": "(\\]|(?=\\'\\'\\'))",
2308 |           "beginCaptures": {
2309 |             "1": {
2310 |               "name": "punctuation.character.set.begin.regexp constant.other.set.regexp"
2311 |             },
2312 |             "2": {
2313 |               "name": "keyword.operator.negation.regexp"
2314 |             },
2315 |             "3": {
2316 |               "name": "constant.character.set.regexp"
2317 |             }
2318 |           },
2319 |           "endCaptures": {
2320 |             "1": {
2321 |               "name": "punctuation.character.set.end.regexp constant.other.set.regexp"
2322 |             },
2323 |             "2": {
2324 |               "name": "invalid.illegal.newline.python"
2325 |             }
2326 |           },
2327 |           "patterns": [
2328 |             {
2329 |               "include": "#regexp-charecter-set-escapes"
2330 |             },
2331 |             {
2332 |               "name": "constant.character.set.regexp",
2333 |               "match": "[^\\n]"
2334 |             }
2335 |           ]
2336 |         }
2337 |       ]
2338 |     },
2339 |     "single-three-regexp-named-group": {
2340 |       "name": "meta.named.regexp",
2341 |       "begin": "(?x)\n  (\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
2342 |       "end": "(\\)|(?=\\'\\'\\'))",
2343 |       "beginCaptures": {
2344 |         "1": {
2345 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
2346 |         },
2347 |         "2": {
2348 |           "name": "entity.name.tag.named.group.regexp"
2349 |         }
2350 |       },
2351 |       "endCaptures": {
2352 |         "1": {
2353 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp"
2354 |         },
2355 |         "2": {
2356 |           "name": "invalid.illegal.newline.python"
2357 |         }
2358 |       },
2359 |       "patterns": [
2360 |         {
2361 |           "include": "#single-three-regexp-expression"
2362 |         },
2363 |         {
2364 |           "include": "#comments-string-single-three"
2365 |         }
2366 |       ]
2367 |     },
2368 |     "single-three-regexp-comments": {
2369 |       "name": "comment.regexp",
2370 |       "begin": "\\(\\?#",
2371 |       "end": "(\\)|(?=\\'\\'\\'))",
2372 |       "beginCaptures": {
2373 |         "0": {
2374 |           "name": "punctuation.comment.begin.regexp"
2375 |         }
2376 |       },
2377 |       "endCaptures": {
2378 |         "1": {
2379 |           "name": "punctuation.comment.end.regexp"
2380 |         },
2381 |         "2": {
2382 |           "name": "invalid.illegal.newline.python"
2383 |         }
2384 |       },
2385 |       "patterns": [
2386 |         {
2387 |           "include": "#codetags"
2388 |         }
2389 |       ]
2390 |     },
2391 |     "single-three-regexp-lookahead": {
2392 |       "begin": "(\\()\\?=",
2393 |       "end": "(\\)|(?=\\'\\'\\'))",
2394 |       "beginCaptures": {
2395 |         "0": {
2396 |           "name": "keyword.operator.lookahead.regexp"
2397 |         },
2398 |         "1": {
2399 |           "name": "punctuation.parenthesis.lookahead.begin.regexp"
2400 |         }
2401 |       },
2402 |       "endCaptures": {
2403 |         "1": {
2404 |           "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp"
2405 |         },
2406 |         "2": {
2407 |           "name": "invalid.illegal.newline.python"
2408 |         }
2409 |       },
2410 |       "patterns": [
2411 |         {
2412 |           "include": "#single-three-regexp-expression"
2413 |         },
2414 |         {
2415 |           "include": "#comments-string-single-three"
2416 |         }
2417 |       ]
2418 |     },
2419 |     "single-three-regexp-lookahead-negative": {
2420 |       "begin": "(\\()\\?!",
2421 |       "end": "(\\)|(?=\\'\\'\\'))",
2422 |       "beginCaptures": {
2423 |         "0": {
2424 |           "name": "keyword.operator.lookahead.negative.regexp"
2425 |         },
2426 |         "1": {
2427 |           "name": "punctuation.parenthesis.lookahead.begin.regexp"
2428 |         }
2429 |       },
2430 |       "endCaptures": {
2431 |         "1": {
2432 |           "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp"
2433 |         },
2434 |         "2": {
2435 |           "name": "invalid.illegal.newline.python"
2436 |         }
2437 |       },
2438 |       "patterns": [
2439 |         {
2440 |           "include": "#single-three-regexp-expression"
2441 |         },
2442 |         {
2443 |           "include": "#comments-string-single-three"
2444 |         }
2445 |       ]
2446 |     },
2447 |     "single-three-regexp-lookbehind": {
2448 |       "begin": "(\\()\\?<=",
2449 |       "end": "(\\)|(?=\\'\\'\\'))",
2450 |       "beginCaptures": {
2451 |         "0": {
2452 |           "name": "keyword.operator.lookbehind.regexp"
2453 |         },
2454 |         "1": {
2455 |           "name": "punctuation.parenthesis.lookbehind.begin.regexp"
2456 |         }
2457 |       },
2458 |       "endCaptures": {
2459 |         "1": {
2460 |           "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp"
2461 |         },
2462 |         "2": {
2463 |           "name": "invalid.illegal.newline.python"
2464 |         }
2465 |       },
2466 |       "patterns": [
2467 |         {
2468 |           "include": "#single-three-regexp-expression"
2469 |         },
2470 |         {
2471 |           "include": "#comments-string-single-three"
2472 |         }
2473 |       ]
2474 |     },
2475 |     "single-three-regexp-lookbehind-negative": {
2476 |       "begin": "(\\()\\?<!",
2477 |       "end": "(\\)|(?=\\'\\'\\'))",
2478 |       "beginCaptures": {
2479 |         "0": {
2480 |           "name": "keyword.operator.lookbehind.negative.regexp"
2481 |         },
2482 |         "1": {
2483 |           "name": "punctuation.parenthesis.lookbehind.begin.regexp"
2484 |         }
2485 |       },
2486 |       "endCaptures": {
2487 |         "1": {
2488 |           "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp"
2489 |         },
2490 |         "2": {
2491 |           "name": "invalid.illegal.newline.python"
2492 |         }
2493 |       },
2494 |       "patterns": [
2495 |         {
2496 |           "include": "#single-three-regexp-expression"
2497 |         },
2498 |         {
2499 |           "include": "#comments-string-single-three"
2500 |         }
2501 |       ]
2502 |     },
2503 |     "single-three-regexp-conditional": {
2504 |       "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
2505 |       "end": "(\\)|(?=\\'\\'\\'))",
2506 |       "beginCaptures": {
2507 |         "0": {
2508 |           "name": "keyword.operator.conditional.regexp"
2509 |         },
2510 |         "1": {
2511 |           "name": "punctuation.parenthesis.conditional.begin.regexp"
2512 |         }
2513 |       },
2514 |       "endCaptures": {
2515 |         "1": {
2516 |           "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp"
2517 |         },
2518 |         "2": {
2519 |           "name": "invalid.illegal.newline.python"
2520 |         }
2521 |       },
2522 |       "patterns": [
2523 |         {
2524 |           "include": "#single-three-regexp-expression"
2525 |         },
2526 |         {
2527 |           "include": "#comments-string-single-three"
2528 |         }
2529 |       ]
2530 |     },
2531 |     "single-three-regexp-parentheses-non-capturing": {
2532 |       "begin": "\\(\\?:",
2533 |       "end": "(\\)|(?=\\'\\'\\'))",
2534 |       "beginCaptures": {
2535 |         "0": {
2536 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp"
2537 |         }
2538 |       },
2539 |       "endCaptures": {
2540 |         "1": {
2541 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp"
2542 |         },
2543 |         "2": {
2544 |           "name": "invalid.illegal.newline.python"
2545 |         }
2546 |       },
2547 |       "patterns": [
2548 |         {
2549 |           "include": "#single-three-regexp-expression"
2550 |         },
2551 |         {
2552 |           "include": "#comments-string-single-three"
2553 |         }
2554 |       ]
2555 |     },
2556 |     "single-three-regexp-parentheses": {
2557 |       "begin": "\\(",
2558 |       "end": "(\\)|(?=\\'\\'\\'))",
2559 |       "beginCaptures": {
2560 |         "0": {
2561 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp"
2562 |         }
2563 |       },
2564 |       "endCaptures": {
2565 |         "1": {
2566 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.regexp"
2567 |         },
2568 |         "2": {
2569 |           "name": "invalid.illegal.newline.python"
2570 |         }
2571 |       },
2572 |       "patterns": [
2573 |         {
2574 |           "include": "#single-three-regexp-expression"
2575 |         },
2576 |         {
2577 |           "include": "#comments-string-single-three"
2578 |         }
2579 |       ]
2580 |     },
2581 |     "double-one-regexp-expression": {
2582 |       "patterns": [
2583 |         {
2584 |           "include": "#regexp-base-expression"
2585 |         },
2586 |         {
2587 |           "include": "#double-one-regexp-character-set"
2588 |         },
2589 |         {
2590 |           "include": "#double-one-regexp-comments"
2591 |         },
2592 |         {
2593 |           "include": "#regexp-flags"
2594 |         },
2595 |         {
2596 |           "include": "#double-one-regexp-named-group"
2597 |         },
2598 |         {
2599 |           "include": "#regexp-backreference"
2600 |         },
2601 |         {
2602 |           "include": "#double-one-regexp-lookahead"
2603 |         },
2604 |         {
2605 |           "include": "#double-one-regexp-lookahead-negative"
2606 |         },
2607 |         {
2608 |           "include": "#double-one-regexp-lookbehind"
2609 |         },
2610 |         {
2611 |           "include": "#double-one-regexp-lookbehind-negative"
2612 |         },
2613 |         {
2614 |           "include": "#double-one-regexp-conditional"
2615 |         },
2616 |         {
2617 |           "include": "#double-one-regexp-parentheses-non-capturing"
2618 |         },
2619 |         {
2620 |           "include": "#double-one-regexp-parentheses"
2621 |         }
2622 |       ]
2623 |     },
2624 |     "double-one-regexp-character-set": {
2625 |       "patterns": [
2626 |         {
2627 |           "match": "(?x)\n  \\[ \\^? \\] (?! .*?\\])\n"
2628 |         },
2629 |         {
2630 |           "name": "meta.character.set.regexp",
2631 |           "begin": "(\\[)(\\^)?(\\])?",
2632 |           "end": "(\\]|(?=\"))|((?=(?<!\\\\)\\n))",
2633 |           "beginCaptures": {
2634 |             "1": {
2635 |               "name": "punctuation.character.set.begin.regexp constant.other.set.regexp"
2636 |             },
2637 |             "2": {
2638 |               "name": "keyword.operator.negation.regexp"
2639 |             },
2640 |             "3": {
2641 |               "name": "constant.character.set.regexp"
2642 |             }
2643 |           },
2644 |           "endCaptures": {
2645 |             "1": {
2646 |               "name": "punctuation.character.set.end.regexp constant.other.set.regexp"
2647 |             },
2648 |             "2": {
2649 |               "name": "invalid.illegal.newline.python"
2650 |             }
2651 |           },
2652 |           "patterns": [
2653 |             {
2654 |               "include": "#regexp-charecter-set-escapes"
2655 |             },
2656 |             {
2657 |               "name": "constant.character.set.regexp",
2658 |               "match": "[^\\n]"
2659 |             }
2660 |           ]
2661 |         }
2662 |       ]
2663 |     },
2664 |     "double-one-regexp-named-group": {
2665 |       "name": "meta.named.regexp",
2666 |       "begin": "(?x)\n  (\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
2667 |       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
2668 |       "beginCaptures": {
2669 |         "1": {
2670 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
2671 |         },
2672 |         "2": {
2673 |           "name": "entity.name.tag.named.group.regexp"
2674 |         }
2675 |       },
2676 |       "endCaptures": {
2677 |         "1": {
2678 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp"
2679 |         },
2680 |         "2": {
2681 |           "name": "invalid.illegal.newline.python"
2682 |         }
2683 |       },
2684 |       "patterns": [
2685 |         {
2686 |           "include": "#double-one-regexp-expression"
2687 |         }
2688 |       ]
2689 |     },
2690 |     "double-one-regexp-comments": {
2691 |       "name": "comment.regexp",
2692 |       "begin": "\\(\\?#",
2693 |       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
2694 |       "beginCaptures": {
2695 |         "0": {
2696 |           "name": "punctuation.comment.begin.regexp"
2697 |         }
2698 |       },
2699 |       "endCaptures": {
2700 |         "1": {
2701 |           "name": "punctuation.comment.end.regexp"
2702 |         },
2703 |         "2": {
2704 |           "name": "invalid.illegal.newline.python"
2705 |         }
2706 |       },
2707 |       "patterns": [
2708 |         {
2709 |           "include": "#codetags"
2710 |         }
2711 |       ]
2712 |     },
2713 |     "double-one-regexp-lookahead": {
2714 |       "begin": "(\\()\\?=",
2715 |       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
2716 |       "beginCaptures": {
2717 |         "0": {
2718 |           "name": "keyword.operator.lookahead.regexp"
2719 |         },
2720 |         "1": {
2721 |           "name": "punctuation.parenthesis.lookahead.begin.regexp"
2722 |         }
2723 |       },
2724 |       "endCaptures": {
2725 |         "1": {
2726 |           "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp"
2727 |         },
2728 |         "2": {
2729 |           "name": "invalid.illegal.newline.python"
2730 |         }
2731 |       },
2732 |       "patterns": [
2733 |         {
2734 |           "include": "#double-one-regexp-expression"
2735 |         }
2736 |       ]
2737 |     },
2738 |     "double-one-regexp-lookahead-negative": {
2739 |       "begin": "(\\()\\?!",
2740 |       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
2741 |       "beginCaptures": {
2742 |         "0": {
2743 |           "name": "keyword.operator.lookahead.negative.regexp"
2744 |         },
2745 |         "1": {
2746 |           "name": "punctuation.parenthesis.lookahead.begin.regexp"
2747 |         }
2748 |       },
2749 |       "endCaptures": {
2750 |         "1": {
2751 |           "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp"
2752 |         },
2753 |         "2": {
2754 |           "name": "invalid.illegal.newline.python"
2755 |         }
2756 |       },
2757 |       "patterns": [
2758 |         {
2759 |           "include": "#double-one-regexp-expression"
2760 |         }
2761 |       ]
2762 |     },
2763 |     "double-one-regexp-lookbehind": {
2764 |       "begin": "(\\()\\?<=",
2765 |       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
2766 |       "beginCaptures": {
2767 |         "0": {
2768 |           "name": "keyword.operator.lookbehind.regexp"
2769 |         },
2770 |         "1": {
2771 |           "name": "punctuation.parenthesis.lookbehind.begin.regexp"
2772 |         }
2773 |       },
2774 |       "endCaptures": {
2775 |         "1": {
2776 |           "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp"
2777 |         },
2778 |         "2": {
2779 |           "name": "invalid.illegal.newline.python"
2780 |         }
2781 |       },
2782 |       "patterns": [
2783 |         {
2784 |           "include": "#double-one-regexp-expression"
2785 |         }
2786 |       ]
2787 |     },
2788 |     "double-one-regexp-lookbehind-negative": {
2789 |       "begin": "(\\()\\?<!",
2790 |       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
2791 |       "beginCaptures": {
2792 |         "0": {
2793 |           "name": "keyword.operator.lookbehind.negative.regexp"
2794 |         },
2795 |         "1": {
2796 |           "name": "punctuation.parenthesis.lookbehind.begin.regexp"
2797 |         }
2798 |       },
2799 |       "endCaptures": {
2800 |         "1": {
2801 |           "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp"
2802 |         },
2803 |         "2": {
2804 |           "name": "invalid.illegal.newline.python"
2805 |         }
2806 |       },
2807 |       "patterns": [
2808 |         {
2809 |           "include": "#double-one-regexp-expression"
2810 |         }
2811 |       ]
2812 |     },
2813 |     "double-one-regexp-conditional": {
2814 |       "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
2815 |       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
2816 |       "beginCaptures": {
2817 |         "0": {
2818 |           "name": "keyword.operator.conditional.regexp"
2819 |         },
2820 |         "1": {
2821 |           "name": "punctuation.parenthesis.conditional.begin.regexp"
2822 |         }
2823 |       },
2824 |       "endCaptures": {
2825 |         "1": {
2826 |           "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp"
2827 |         },
2828 |         "2": {
2829 |           "name": "invalid.illegal.newline.python"
2830 |         }
2831 |       },
2832 |       "patterns": [
2833 |         {
2834 |           "include": "#double-one-regexp-expression"
2835 |         }
2836 |       ]
2837 |     },
2838 |     "double-one-regexp-parentheses-non-capturing": {
2839 |       "begin": "\\(\\?:",
2840 |       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
2841 |       "beginCaptures": {
2842 |         "0": {
2843 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp"
2844 |         }
2845 |       },
2846 |       "endCaptures": {
2847 |         "1": {
2848 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp"
2849 |         },
2850 |         "2": {
2851 |           "name": "invalid.illegal.newline.python"
2852 |         }
2853 |       },
2854 |       "patterns": [
2855 |         {
2856 |           "include": "#double-one-regexp-expression"
2857 |         }
2858 |       ]
2859 |     },
2860 |     "double-one-regexp-parentheses": {
2861 |       "begin": "\\(",
2862 |       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
2863 |       "beginCaptures": {
2864 |         "0": {
2865 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp"
2866 |         }
2867 |       },
2868 |       "endCaptures": {
2869 |         "1": {
2870 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.regexp"
2871 |         },
2872 |         "2": {
2873 |           "name": "invalid.illegal.newline.python"
2874 |         }
2875 |       },
2876 |       "patterns": [
2877 |         {
2878 |           "include": "#double-one-regexp-expression"
2879 |         }
2880 |       ]
2881 |     },
2882 |     "double-three-regexp-expression": {
2883 |       "patterns": [
2884 |         {
2885 |           "include": "#regexp-base-expression"
2886 |         },
2887 |         {
2888 |           "include": "#double-three-regexp-character-set"
2889 |         },
2890 |         {
2891 |           "include": "#double-three-regexp-comments"
2892 |         },
2893 |         {
2894 |           "include": "#regexp-flags"
2895 |         },
2896 |         {
2897 |           "include": "#double-three-regexp-named-group"
2898 |         },
2899 |         {
2900 |           "include": "#regexp-backreference"
2901 |         },
2902 |         {
2903 |           "include": "#double-three-regexp-lookahead"
2904 |         },
2905 |         {
2906 |           "include": "#double-three-regexp-lookahead-negative"
2907 |         },
2908 |         {
2909 |           "include": "#double-three-regexp-lookbehind"
2910 |         },
2911 |         {
2912 |           "include": "#double-three-regexp-lookbehind-negative"
2913 |         },
2914 |         {
2915 |           "include": "#double-three-regexp-conditional"
2916 |         },
2917 |         {
2918 |           "include": "#double-three-regexp-parentheses-non-capturing"
2919 |         },
2920 |         {
2921 |           "include": "#double-three-regexp-parentheses"
2922 |         },
2923 |         {
2924 |           "include": "#comments-string-double-three"
2925 |         }
2926 |       ]
2927 |     },
2928 |     "double-three-regexp-character-set": {
2929 |       "patterns": [
2930 |         {
2931 |           "match": "(?x)\n  \\[ \\^? \\] (?! .*?\\])\n"
2932 |         },
2933 |         {
2934 |           "name": "meta.character.set.regexp",
2935 |           "begin": "(\\[)(\\^)?(\\])?",
2936 |           "end": "(\\]|(?=\"\"\"))",
2937 |           "beginCaptures": {
2938 |             "1": {
2939 |               "name": "punctuation.character.set.begin.regexp constant.other.set.regexp"
2940 |             },
2941 |             "2": {
2942 |               "name": "keyword.operator.negation.regexp"
2943 |             },
2944 |             "3": {
2945 |               "name": "constant.character.set.regexp"
2946 |             }
2947 |           },
2948 |           "endCaptures": {
2949 |             "1": {
2950 |               "name": "punctuation.character.set.end.regexp constant.other.set.regexp"
2951 |             },
2952 |             "2": {
2953 |               "name": "invalid.illegal.newline.python"
2954 |             }
2955 |           },
2956 |           "patterns": [
2957 |             {
2958 |               "include": "#regexp-charecter-set-escapes"
2959 |             },
2960 |             {
2961 |               "name": "constant.character.set.regexp",
2962 |               "match": "[^\\n]"
2963 |             }
2964 |           ]
2965 |         }
2966 |       ]
2967 |     },
2968 |     "double-three-regexp-named-group": {
2969 |       "name": "meta.named.regexp",
2970 |       "begin": "(?x)\n  (\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
2971 |       "end": "(\\)|(?=\"\"\"))",
2972 |       "beginCaptures": {
2973 |         "1": {
2974 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp"
2975 |         },
2976 |         "2": {
2977 |           "name": "entity.name.tag.named.group.regexp"
2978 |         }
2979 |       },
2980 |       "endCaptures": {
2981 |         "1": {
2982 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp"
2983 |         },
2984 |         "2": {
2985 |           "name": "invalid.illegal.newline.python"
2986 |         }
2987 |       },
2988 |       "patterns": [
2989 |         {
2990 |           "include": "#double-three-regexp-expression"
2991 |         },
2992 |         {
2993 |           "include": "#comments-string-double-three"
2994 |         }
2995 |       ]
2996 |     },
2997 |     "double-three-regexp-comments": {
2998 |       "name": "comment.regexp",
2999 |       "begin": "\\(\\?#",
3000 |       "end": "(\\)|(?=\"\"\"))",
3001 |       "beginCaptures": {
3002 |         "0": {
3003 |           "name": "punctuation.comment.begin.regexp"
3004 |         }
3005 |       },
3006 |       "endCaptures": {
3007 |         "1": {
3008 |           "name": "punctuation.comment.end.regexp"
3009 |         },
3010 |         "2": {
3011 |           "name": "invalid.illegal.newline.python"
3012 |         }
3013 |       },
3014 |       "patterns": [
3015 |         {
3016 |           "include": "#codetags"
3017 |         }
3018 |       ]
3019 |     },
3020 |     "double-three-regexp-lookahead": {
3021 |       "begin": "(\\()\\?=",
3022 |       "end": "(\\)|(?=\"\"\"))",
3023 |       "beginCaptures": {
3024 |         "0": {
3025 |           "name": "keyword.operator.lookahead.regexp"
3026 |         },
3027 |         "1": {
3028 |           "name": "punctuation.parenthesis.lookahead.begin.regexp"
3029 |         }
3030 |       },
3031 |       "endCaptures": {
3032 |         "1": {
3033 |           "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp"
3034 |         },
3035 |         "2": {
3036 |           "name": "invalid.illegal.newline.python"
3037 |         }
3038 |       },
3039 |       "patterns": [
3040 |         {
3041 |           "include": "#double-three-regexp-expression"
3042 |         },
3043 |         {
3044 |           "include": "#comments-string-double-three"
3045 |         }
3046 |       ]
3047 |     },
3048 |     "double-three-regexp-lookahead-negative": {
3049 |       "begin": "(\\()\\?!",
3050 |       "end": "(\\)|(?=\"\"\"))",
3051 |       "beginCaptures": {
3052 |         "0": {
3053 |           "name": "keyword.operator.lookahead.negative.regexp"
3054 |         },
3055 |         "1": {
3056 |           "name": "punctuation.parenthesis.lookahead.begin.regexp"
3057 |         }
3058 |       },
3059 |       "endCaptures": {
3060 |         "1": {
3061 |           "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp"
3062 |         },
3063 |         "2": {
3064 |           "name": "invalid.illegal.newline.python"
3065 |         }
3066 |       },
3067 |       "patterns": [
3068 |         {
3069 |           "include": "#double-three-regexp-expression"
3070 |         },
3071 |         {
3072 |           "include": "#comments-string-double-three"
3073 |         }
3074 |       ]
3075 |     },
3076 |     "double-three-regexp-lookbehind": {
3077 |       "begin": "(\\()\\?<=",
3078 |       "end": "(\\)|(?=\"\"\"))",
3079 |       "beginCaptures": {
3080 |         "0": {
3081 |           "name": "keyword.operator.lookbehind.regexp"
3082 |         },
3083 |         "1": {
3084 |           "name": "punctuation.parenthesis.lookbehind.begin.regexp"
3085 |         }
3086 |       },
3087 |       "endCaptures": {
3088 |         "1": {
3089 |           "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp"
3090 |         },
3091 |         "2": {
3092 |           "name": "invalid.illegal.newline.python"
3093 |         }
3094 |       },
3095 |       "patterns": [
3096 |         {
3097 |           "include": "#double-three-regexp-expression"
3098 |         },
3099 |         {
3100 |           "include": "#comments-string-double-three"
3101 |         }
3102 |       ]
3103 |     },
3104 |     "double-three-regexp-lookbehind-negative": {
3105 |       "begin": "(\\()\\?<!",
3106 |       "end": "(\\)|(?=\"\"\"))",
3107 |       "beginCaptures": {
3108 |         "0": {
3109 |           "name": "keyword.operator.lookbehind.negative.regexp"
3110 |         },
3111 |         "1": {
3112 |           "name": "punctuation.parenthesis.lookbehind.begin.regexp"
3113 |         }
3114 |       },
3115 |       "endCaptures": {
3116 |         "1": {
3117 |           "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp"
3118 |         },
3119 |         "2": {
3120 |           "name": "invalid.illegal.newline.python"
3121 |         }
3122 |       },
3123 |       "patterns": [
3124 |         {
3125 |           "include": "#double-three-regexp-expression"
3126 |         },
3127 |         {
3128 |           "include": "#comments-string-double-three"
3129 |         }
3130 |       ]
3131 |     },
3132 |     "double-three-regexp-conditional": {
3133 |       "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
3134 |       "end": "(\\)|(?=\"\"\"))",
3135 |       "beginCaptures": {
3136 |         "0": {
3137 |           "name": "keyword.operator.conditional.regexp"
3138 |         },
3139 |         "1": {
3140 |           "name": "punctuation.parenthesis.conditional.begin.regexp"
3141 |         }
3142 |       },
3143 |       "endCaptures": {
3144 |         "1": {
3145 |           "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp"
3146 |         },
3147 |         "2": {
3148 |           "name": "invalid.illegal.newline.python"
3149 |         }
3150 |       },
3151 |       "patterns": [
3152 |         {
3153 |           "include": "#double-three-regexp-expression"
3154 |         },
3155 |         {
3156 |           "include": "#comments-string-double-three"
3157 |         }
3158 |       ]
3159 |     },
3160 |     "double-three-regexp-parentheses-non-capturing": {
3161 |       "begin": "\\(\\?:",
3162 |       "end": "(\\)|(?=\"\"\"))",
3163 |       "beginCaptures": {
3164 |         "0": {
3165 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp"
3166 |         }
3167 |       },
3168 |       "endCaptures": {
3169 |         "1": {
3170 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp"
3171 |         },
3172 |         "2": {
3173 |           "name": "invalid.illegal.newline.python"
3174 |         }
3175 |       },
3176 |       "patterns": [
3177 |         {
3178 |           "include": "#double-three-regexp-expression"
3179 |         },
3180 |         {
3181 |           "include": "#comments-string-double-three"
3182 |         }
3183 |       ]
3184 |     },
3185 |     "double-three-regexp-parentheses": {
3186 |       "begin": "\\(",
3187 |       "end": "(\\)|(?=\"\"\"))",
3188 |       "beginCaptures": {
3189 |         "0": {
3190 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp"
3191 |         }
3192 |       },
3193 |       "endCaptures": {
3194 |         "1": {
3195 |           "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.regexp"
3196 |         },
3197 |         "2": {
3198 |           "name": "invalid.illegal.newline.python"
3199 |         }
3200 |       },
3201 |       "patterns": [
3202 |         {
3203 |           "include": "#double-three-regexp-expression"
3204 |         },
3205 |         {
3206 |           "include": "#comments-string-double-three"
3207 |         }
3208 |       ]
3209 |     },
3210 |     "regexp-single-one-line": {
3211 |       "name": "string.regexp.quoted.single.python",
3212 |       "begin": "\\b(([uU]r)|([bB]r)|(r[bB]?))(\\')",
3213 |       "end": "(\\')|(?<!\\\\)(\\n)",
3214 |       "beginCaptures": {
3215 |         "2": {
3216 |           "name": "invalid.deprecated.prefix.python"
3217 |         },
3218 |         "3": {
3219 |           "name": "storage.type.string.python"
3220 |         },
3221 |         "4": {
3222 |           "name": "storage.type.string.python"
3223 |         },
3224 |         "5": {
3225 |           "name": "punctuation.definition.string.begin.python"
3226 |         }
3227 |       },
3228 |       "endCaptures": {
3229 |         "1": {
3230 |           "name": "punctuation.definition.string.end.python"
3231 |         },
3232 |         "2": {
3233 |           "name": "invalid.illegal.newline.python"
3234 |         }
3235 |       },
3236 |       "patterns": [
3237 |         {
3238 |           "include": "#single-one-regexp-expression"
3239 |         }
3240 |       ]
3241 |     },
3242 |     "regexp-single-three-line": {
3243 |       "name": "string.regexp.quoted.multi.python",
3244 |       "begin": "\\b(([uU]r)|([bB]r)|(r[bB]?))(\\'\\'\\')",
3245 |       "end": "(\\'\\'\\')",
3246 |       "beginCaptures": {
3247 |         "2": {
3248 |           "name": "invalid.deprecated.prefix.python"
3249 |         },
3250 |         "3": {
3251 |           "name": "storage.type.string.python"
3252 |         },
3253 |         "4": {
3254 |           "name": "storage.type.string.python"
3255 |         },
3256 |         "5": {
3257 |           "name": "punctuation.definition.string.begin.python"
3258 |         }
3259 |       },
3260 |       "endCaptures": {
3261 |         "1": {
3262 |           "name": "punctuation.definition.string.end.python"
3263 |         },
3264 |         "2": {
3265 |           "name": "invalid.illegal.newline.python"
3266 |         }
3267 |       },
3268 |       "patterns": [
3269 |         {
3270 |           "include": "#single-three-regexp-expression"
3271 |         }
3272 |       ]
3273 |     },
3274 |     "regexp-double-one-line": {
3275 |       "name": "string.regexp.quoted.single.python",
3276 |       "begin": "\\b(([uU]r)|([bB]r)|(r[bB]?))(\")",
3277 |       "end": "(\")|(?<!\\\\)(\\n)",
3278 |       "beginCaptures": {
3279 |         "2": {
3280 |           "name": "invalid.deprecated.prefix.python"
3281 |         },
3282 |         "3": {
3283 |           "name": "storage.type.string.python"
3284 |         },
3285 |         "4": {
3286 |           "name": "storage.type.string.python"
3287 |         },
3288 |         "5": {
3289 |           "name": "punctuation.definition.string.begin.python"
3290 |         }
3291 |       },
3292 |       "endCaptures": {
3293 |         "1": {
3294 |           "name": "punctuation.definition.string.end.python"
3295 |         },
3296 |         "2": {
3297 |           "name": "invalid.illegal.newline.python"
3298 |         }
3299 |       },
3300 |       "patterns": [
3301 |         {
3302 |           "include": "#double-one-regexp-expression"
3303 |         }
3304 |       ]
3305 |     },
3306 |     "regexp-double-three-line": {
3307 |       "name": "string.regexp.quoted.multi.python",
3308 |       "begin": "\\b(([uU]r)|([bB]r)|(r[bB]?))(\"\"\")",
3309 |       "end": "(\"\"\")",
3310 |       "beginCaptures": {
3311 |         "2": {
3312 |           "name": "invalid.deprecated.prefix.python"
3313 |         },
3314 |         "3": {
3315 |           "name": "storage.type.string.python"
3316 |         },
3317 |         "4": {
3318 |           "name": "storage.type.string.python"
3319 |         },
3320 |         "5": {
3321 |           "name": "punctuation.definition.string.begin.python"
3322 |         }
3323 |       },
3324 |       "endCaptures": {
3325 |         "1": {
3326 |           "name": "punctuation.definition.string.end.python"
3327 |         },
3328 |         "2": {
3329 |           "name": "invalid.illegal.newline.python"
3330 |         }
3331 |       },
3332 |       "patterns": [
3333 |         {
3334 |           "include": "#double-three-regexp-expression"
3335 |         }
3336 |       ]
3337 |     },
3338 |     "string-raw-quoted-single-line": {
3339 |       "name": "string.quoted.raw.single.python",
3340 |       "begin": "\\b(([uU]R)|(R))((['\"]))",
3341 |       "end": "(\\4)|((?<!\\\\)\\n)",
3342 |       "beginCaptures": {
3343 |         "2": {
3344 |           "name": "invalid.deprecated.prefix.python"
3345 |         },
3346 |         "3": {
3347 |           "name": "storage.type.string.python"
3348 |         },
3349 |         "4": {
3350 |           "name": "punctuation.definition.string.begin.python"
3351 |         }
3352 |       },
3353 |       "endCaptures": {
3354 |         "1": {
3355 |           "name": "punctuation.definition.string.end.python"
3356 |         },
3357 |         "2": {
3358 |           "name": "invalid.illegal.newline.python"
3359 |         }
3360 |       },
3361 |       "patterns": [
3362 |         {
3363 |           "include": "#string-single-bad-brace1-formatting-raw"
3364 |         },
3365 |         {
3366 |           "include": "#string-single-bad-brace2-formatting-raw"
3367 |         },
3368 |         {
3369 |           "include": "#string-raw-guts"
3370 |         }
3371 |       ]
3372 |     },
3373 |     "string-bin-quoted-single-line": {
3374 |       "name": "string.quoted.binary.single.python",
3375 |       "begin": "(\\b[bB])((['\"]))",
3376 |       "end": "(\\2)|((?<!\\\\)\\n)",
3377 |       "beginCaptures": {
3378 |         "1": {
3379 |           "name": "storage.type.string.python"
3380 |         },
3381 |         "2": {
3382 |           "name": "punctuation.definition.string.begin.python"
3383 |         }
3384 |       },
3385 |       "endCaptures": {
3386 |         "1": {
3387 |           "name": "punctuation.definition.string.end.python"
3388 |         },
3389 |         "2": {
3390 |           "name": "invalid.illegal.newline.python"
3391 |         }
3392 |       },
3393 |       "patterns": [
3394 |         {
3395 |           "include": "#string-entity"
3396 |         }
3397 |       ]
3398 |     },
3399 |     "string-raw-bin-quoted-single-line": {
3400 |       "name": "string.quoted.raw.binary.single.python",
3401 |       "begin": "(\\b(?:R[bB]|[bB]R))((['\"]))",
3402 |       "end": "(\\2)|((?<!\\\\)\\n)",
3403 |       "beginCaptures": {
3404 |         "1": {
3405 |           "name": "storage.type.string.python"
3406 |         },
3407 |         "2": {
3408 |           "name": "punctuation.definition.string.begin.python"
3409 |         }
3410 |       },
3411 |       "endCaptures": {
3412 |         "1": {
3413 |           "name": "punctuation.definition.string.end.python"
3414 |         },
3415 |         "2": {
3416 |           "name": "invalid.illegal.newline.python"
3417 |         }
3418 |       },
3419 |       "patterns": [
3420 |         {
3421 |           "include": "#string-raw-bin-guts"
3422 |         }
3423 |       ]
3424 |     },
3425 |     "string-quoted-single-line": {
3426 |       "name": "string.quoted.single.python",
3427 |       "begin": "(?:\\b([rR])(?=[uU]))?([uU])?((['\"]))",
3428 |       "end": "(\\3)|((?<!\\\\)\\n)",
3429 |       "beginCaptures": {
3430 |         "1": {
3431 |           "name": "invalid.illegal.prefix.python"
3432 |         },
3433 |         "2": {
3434 |           "name": "storage.type.string.python"
3435 |         },
3436 |         "3": {
3437 |           "name": "punctuation.definition.string.begin.python"
3438 |         }
3439 |       },
3440 |       "endCaptures": {
3441 |         "1": {
3442 |           "name": "punctuation.definition.string.end.python"
3443 |         },
3444 |         "2": {
3445 |           "name": "invalid.illegal.newline.python"
3446 |         }
3447 |       },
3448 |       "patterns": [
3449 |         {
3450 |           "include": "#string-single-bad-brace1-formatting-unicode"
3451 |         },
3452 |         {
3453 |           "include": "#string-single-bad-brace2-formatting-unicode"
3454 |         },
3455 |         {
3456 |           "include": "#string-unicode-guts"
3457 |         }
3458 |       ]
3459 |     },
3460 |     "string-single-bad-brace1-formatting-unicode": {
3461 |       "comment": "template using {% ... %}",
3462 |       "begin": "(?x)\n    (?= \\{%\n          ( .*? (?!(['\"])|((?<!\\\\)\\n)) )\n        %\\}\n    )\n",
3463 |       "end": "(?=(['\"])|((?<!\\\\)\\n))",
3464 |       "patterns": [
3465 |         {
3466 |           "include": "#escape-sequence-unicode"
3467 |         },
3468 |         {
3469 |           "include": "#escape-sequence"
3470 |         },
3471 |         {
3472 |           "include": "#string-line-continuation"
3473 |         }
3474 |       ]
3475 |     },
3476 |     "string-single-bad-brace1-formatting-raw": {
3477 |       "comment": "template using {% ... %}",
3478 |       "begin": "(?x)\n    (?= \\{%\n          ( .*? (?!(['\"])|((?<!\\\\)\\n)) )\n        %\\}\n    )\n",
3479 |       "end": "(?=(['\"])|((?<!\\\\)\\n))",
3480 |       "patterns": [
3481 |         {
3482 |           "include": "#string-consume-escape"
3483 |         }
3484 |       ]
3485 |     },
3486 |     "string-single-bad-brace2-formatting-unicode": {
3487 |       "comment": "odd format or format-like syntax",
3488 |       "begin": "(?x)\n    (?!\\{\\{)\n    (?= \\{ (\n              \\w*? (?!(['\"])|((?<!\\\\)\\n)) [^!:\\.\\[}\\w]\n           )\n        .*?(?!(['\"])|((?<!\\\\)\\n))\n        \\}\n    )\n",
3489 |       "end": "(?=(['\"])|((?<!\\\\)\\n))",
3490 |       "patterns": [
3491 |         {
3492 |           "include": "#escape-sequence-unicode"
3493 |         },
3494 |         {
3495 |           "include": "#string-entity"
3496 |         }
3497 |       ]
3498 |     },
3499 |     "string-single-bad-brace2-formatting-raw": {
3500 |       "comment": "odd format or format-like syntax",
3501 |       "begin": "(?x)\n    (?!\\{\\{)\n    (?= \\{ (\n              \\w*? (?!(['\"])|((?<!\\\\)\\n)) [^!:\\.\\[}\\w]\n           )\n        .*?(?!(['\"])|((?<!\\\\)\\n))\n        \\}\n    )\n",
3502 |       "end": "(?=(['\"])|((?<!\\\\)\\n))",
3503 |       "patterns": [
3504 |         {
3505 |           "include": "#string-consume-escape"
3506 |         },
3507 |         {
3508 |           "include": "#string-formatting"
3509 |         }
3510 |       ]
3511 |     },
3512 |     "string-raw-quoted-multi-line": {
3513 |       "name": "string.quoted.raw.multi.python",
3514 |       "begin": "\\b(([uU]R)|(R))('''|\"\"\")",
3515 |       "end": "(\\4)",
3516 |       "beginCaptures": {
3517 |         "2": {
3518 |           "name": "invalid.deprecated.prefix.python"
3519 |         },
3520 |         "3": {
3521 |           "name": "storage.type.string.python"
3522 |         },
3523 |         "4": {
3524 |           "name": "punctuation.definition.string.begin.python"
3525 |         }
3526 |       },
3527 |       "endCaptures": {
3528 |         "1": {
3529 |           "name": "punctuation.definition.string.end.python"
3530 |         },
3531 |         "2": {
3532 |           "name": "invalid.illegal.newline.python"
3533 |         }
3534 |       },
3535 |       "patterns": [
3536 |         {
3537 |           "include": "#string-multi-bad-brace1-formatting-raw"
3538 |         },
3539 |         {
3540 |           "include": "#string-multi-bad-brace2-formatting-raw"
3541 |         },
3542 |         {
3543 |           "include": "#string-raw-guts"
3544 |         }
3545 |       ]
3546 |     },
3547 |     "string-bin-quoted-multi-line": {
3548 |       "name": "string.quoted.binary.multi.python",
3549 |       "begin": "(\\b[bB])('''|\"\"\")",
3550 |       "end": "(\\2)",
3551 |       "beginCaptures": {
3552 |         "1": {
3553 |           "name": "storage.type.string.python"
3554 |         },
3555 |         "2": {
3556 |           "name": "punctuation.definition.string.begin.python"
3557 |         }
3558 |       },
3559 |       "endCaptures": {
3560 |         "1": {
3561 |           "name": "punctuation.definition.string.end.python"
3562 |         },
3563 |         "2": {
3564 |           "name": "invalid.illegal.newline.python"
3565 |         }
3566 |       },
3567 |       "patterns": [
3568 |         {
3569 |           "include": "#string-entity"
3570 |         }
3571 |       ]
3572 |     },
3573 |     "string-raw-bin-quoted-multi-line": {
3574 |       "name": "string.quoted.raw.binary.multi.python",
3575 |       "begin": "(\\b(?:R[bB]|[bB]R))('''|\"\"\")",
3576 |       "end": "(\\2)",
3577 |       "beginCaptures": {
3578 |         "1": {
3579 |           "name": "storage.type.string.python"
3580 |         },
3581 |         "2": {
3582 |           "name": "punctuation.definition.string.begin.python"
3583 |         }
3584 |       },
3585 |       "endCaptures": {
3586 |         "1": {
3587 |           "name": "punctuation.definition.string.end.python"
3588 |         },
3589 |         "2": {
3590 |           "name": "invalid.illegal.newline.python"
3591 |         }
3592 |       },
3593 |       "patterns": [
3594 |         {
3595 |           "include": "#string-raw-bin-guts"
3596 |         }
3597 |       ]
3598 |     },
3599 |     "string-quoted-multi-line": {
3600 |       "name": "string.quoted.multi.python",
3601 |       "begin": "(?:\\b([rR])(?=[uU]))?([uU])?('''|\"\"\")",
3602 |       "end": "(\\3)",
3603 |       "beginCaptures": {
3604 |         "1": {
3605 |           "name": "invalid.illegal.prefix.python"
3606 |         },
3607 |         "2": {
3608 |           "name": "storage.type.string.python"
3609 |         },
3610 |         "3": {
3611 |           "name": "punctuation.definition.string.begin.python"
3612 |         }
3613 |       },
3614 |       "endCaptures": {
3615 |         "1": {
3616 |           "name": "punctuation.definition.string.end.python"
3617 |         },
3618 |         "2": {
3619 |           "name": "invalid.illegal.newline.python"
3620 |         }
3621 |       },
3622 |       "patterns": [
3623 |         {
3624 |           "include": "#string-multi-bad-brace1-formatting-unicode"
3625 |         },
3626 |         {
3627 |           "include": "#string-multi-bad-brace2-formatting-unicode"
3628 |         },
3629 |         {
3630 |           "include": "#string-unicode-guts"
3631 |         }
3632 |       ]
3633 |     },
3634 |     "string-mojo-code-block": {
3635 |       "name": "meta.embedded.block.mojo",
3636 |       "begin": "^(\\s*\\`{3,})(mojo)$",
3637 |       "end": "^(\\1)$",
3638 |       "contentName": "source.mojo",
3639 |       "beginCaptures": {
3640 |         "1": {
3641 |           "name": "string.quoted.single.python"
3642 |         },
3643 |         "2": {
3644 |           "name": "string.quoted.single.python"
3645 |         }
3646 |       },
3647 |       "endCaptures": {
3648 |         "1": {
3649 |           "name": "string.quoted.single.python"
3650 |         }
3651 |       },
3652 |       "patterns": [
3653 |         {
3654 |           "include": "source.mojo"
3655 |         }
3656 |       ]
3657 |     },
3658 |     "string-multi-bad-brace1-formatting-unicode": {
3659 |       "comment": "template using {% ... %}",
3660 |       "begin": "(?x)\n    (?= \\{%\n          ( .*? (?!'''|\"\"\") )\n        %\\}\n    )\n",
3661 |       "end": "(?='''|\"\"\")",
3662 |       "patterns": [
3663 |         {
3664 |           "include": "#escape-sequence-unicode"
3665 |         },
3666 |         {
3667 |           "include": "#escape-sequence"
3668 |         },
3669 |         {
3670 |           "include": "#string-line-continuation"
3671 |         }
3672 |       ]
3673 |     },
3674 |     "string-multi-bad-brace1-formatting-raw": {
3675 |       "comment": "template using {% ... %}",
3676 |       "begin": "(?x)\n    (?= \\{%\n          ( .*? (?!'''|\"\"\") )\n        %\\}\n    )\n",
3677 |       "end": "(?='''|\"\"\")",
3678 |       "patterns": [
3679 |         {
3680 |           "include": "#string-consume-escape"
3681 |         }
3682 |       ]
3683 |     },
3684 |     "string-multi-bad-brace2-formatting-unicode": {
3685 |       "comment": "odd format or format-like syntax",
3686 |       "begin": "(?x)\n    (?!\\{\\{)\n    (?= \\{ (\n              \\w*? (?!'''|\"\"\") [^!:\\.\\[}\\w]\n           )\n        .*?(?!'''|\"\"\")\n        \\}\n    )\n",
3687 |       "end": "(?='''|\"\"\")",
3688 |       "patterns": [
3689 |         {
3690 |           "include": "#escape-sequence-unicode"
3691 |         },
3692 |         {
3693 |           "include": "#string-entity"
3694 |         }
3695 |       ]
3696 |     },
3697 |     "string-multi-bad-brace2-formatting-raw": {
3698 |       "comment": "odd format or format-like syntax",
3699 |       "begin": "(?x)\n    (?!\\{\\{)\n    (?= \\{ (\n              \\w*? (?!'''|\"\"\") [^!:\\.\\[}\\w]\n           )\n        .*?(?!'''|\"\"\")\n        \\}\n    )\n",
3700 |       "end": "(?='''|\"\"\")",
3701 |       "patterns": [
3702 |         {
3703 |           "include": "#string-consume-escape"
3704 |         },
3705 |         {
3706 |           "include": "#string-formatting"
3707 |         }
3708 |       ]
3709 |     },
3710 |     "fstring-fnorm-quoted-single-line": {
3711 |       "name": "meta.fstring.python",
3712 |       "begin": "(\\b[fF])([bBuU])?((['\"]))",
3713 |       "end": "(\\3)|((?<!\\\\)\\n)",
3714 |       "beginCaptures": {
3715 |         "1": {
3716 |           "name": "string.interpolated.python string.quoted.single.python storage.type.string.python"
3717 |         },
3718 |         "2": {
3719 |           "name": "invalid.illegal.prefix.python"
3720 |         },
3721 |         "3": {
3722 |           "name": "punctuation.definition.string.begin.python string.interpolated.python string.quoted.single.python"
3723 |         }
3724 |       },
3725 |       "endCaptures": {
3726 |         "1": {
3727 |           "name": "punctuation.definition.string.end.python string.interpolated.python string.quoted.single.python"
3728 |         },
3729 |         "2": {
3730 |           "name": "invalid.illegal.newline.python"
3731 |         }
3732 |       },
3733 |       "patterns": [
3734 |         {
3735 |           "include": "#fstring-guts"
3736 |         },
3737 |         {
3738 |           "include": "#fstring-illegal-single-brace"
3739 |         },
3740 |         {
3741 |           "include": "#fstring-single-brace"
3742 |         },
3743 |         {
3744 |           "include": "#fstring-single-core"
3745 |         }
3746 |       ]
3747 |     },
3748 |     "fstring-normf-quoted-single-line": {
3749 |       "name": "meta.fstring.python",
3750 |       "begin": "(\\b[bBuU])([fF])((['\"]))",
3751 |       "end": "(\\3)|((?<!\\\\)\\n)",
3752 |       "beginCaptures": {
3753 |         "1": {
3754 |           "name": "invalid.illegal.prefix.python"
3755 |         },
3756 |         "2": {
3757 |           "name": "string.interpolated.python string.quoted.single.python storage.type.string.python"
3758 |         },
3759 |         "3": {
3760 |           "name": "punctuation.definition.string.begin.python string.quoted.single.python"
3761 |         }
3762 |       },
3763 |       "endCaptures": {
3764 |         "1": {
3765 |           "name": "punctuation.definition.string.end.python string.interpolated.python string.quoted.single.python"
3766 |         },
3767 |         "2": {
3768 |           "name": "invalid.illegal.newline.python"
3769 |         }
3770 |       },
3771 |       "patterns": [
3772 |         {
3773 |           "include": "#fstring-guts"
3774 |         },
3775 |         {
3776 |           "include": "#fstring-illegal-single-brace"
3777 |         },
3778 |         {
3779 |           "include": "#fstring-single-brace"
3780 |         },
3781 |         {
3782 |           "include": "#fstring-single-core"
3783 |         }
3784 |       ]
3785 |     },
3786 |     "fstring-raw-quoted-single-line": {
3787 |       "name": "meta.fstring.python",
3788 |       "begin": "(\\b(?:[rR][fF]|[fF][rR]))((['\"]))",
3789 |       "end": "(\\2)|((?<!\\\\)\\n)",
3790 |       "beginCaptures": {
3791 |         "1": {
3792 |           "name": "string.interpolated.python string.quoted.raw.single.python storage.type.string.python"
3793 |         },
3794 |         "2": {
3795 |           "name": "punctuation.definition.string.begin.python string.quoted.raw.single.python"
3796 |         }
3797 |       },
3798 |       "endCaptures": {
3799 |         "1": {
3800 |           "name": "punctuation.definition.string.end.python string.interpolated.python string.quoted.raw.single.python"
3801 |         },
3802 |         "2": {
3803 |           "name": "invalid.illegal.newline.python"
3804 |         }
3805 |       },
3806 |       "patterns": [
3807 |         {
3808 |           "include": "#fstring-raw-guts"
3809 |         },
3810 |         {
3811 |           "include": "#fstring-illegal-single-brace"
3812 |         },
3813 |         {
3814 |           "include": "#fstring-single-brace"
3815 |         },
3816 |         {
3817 |           "include": "#fstring-raw-single-core"
3818 |         }
3819 |       ]
3820 |     },
3821 |     "fstring-single-core": {
3822 |       "name": "string.interpolated.python string.quoted.single.python",
3823 |       "match": "(?x)\n  (.+?)\n    (\n      (?# .* and .*? in multi-line match need special handling of\n        newlines otherwise SublimeText and Atom will match slightly\n        differently.\n\n        The guard for newlines has to be separate from the\n        lookahead because of special $ matching rule.)\n      ($\\n?)\n      |\n      (?=[\\\\\\}\\{]|(['\"])|((?<!\\\\)\\n))\n    )\n  (?# due to how multiline regexps are matched we need a special case\n    for matching a newline character)\n  | \\n\n"
3824 |     },
3825 |     "fstring-raw-single-core": {
3826 |       "name": "string.interpolated.python string.quoted.raw.single.python",
3827 |       "match": "(?x)\n  (.+?)\n    (\n      (?# .* and .*? in multi-line match need special handling of\n        newlines otherwise SublimeText and Atom will match slightly\n        differently.\n\n        The guard for newlines has to be separate from the\n        lookahead because of special $ matching rule.)\n      ($\\n?)\n      |\n      (?=[\\\\\\}\\{]|(['\"])|((?<!\\\\)\\n))\n    )\n  (?# due to how multiline regexps are matched we need a special case\n    for matching a newline character)\n  | \\n\n"
3828 |     },
3829 |     "fstring-single-brace": {
3830 |       "comment": "value interpolation using { ... }",
3831 |       "begin": "(\\{)",
3832 |       "end": "(?x)\n  (\\})|(?=\\n)\n",
3833 |       "beginCaptures": {
3834 |         "1": {
3835 |           "name": "constant.character.format.placeholder.other.python"
3836 |         }
3837 |       },
3838 |       "endCaptures": {
3839 |         "1": {
3840 |           "name": "constant.character.format.placeholder.other.python"
3841 |         }
3842 |       },
3843 |       "patterns": [
3844 |         {
3845 |           "include": "#fstring-terminator-single"
3846 |         },
3847 |         {
3848 |           "include": "#f-expression"
3849 |         }
3850 |       ]
3851 |     },
3852 |     "fstring-terminator-single": {
3853 |       "patterns": [
3854 |         {
3855 |           "name": "storage.type.format.python",
3856 |           "match": "(=(![rsa])?)(?=})"
3857 |         },
3858 |         {
3859 |           "name": "storage.type.format.python",
3860 |           "match": "(=?![rsa])(?=})"
3861 |         },
3862 |         {
3863 |           "match": "(?x)\n  ( (?: =?) (?: ![rsa])? )\n    ( : \\w? [<>=^]? [-+ ]? \\#?\n      \\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )(?=})\n",
3864 |           "captures": {
3865 |             "1": {
3866 |               "name": "storage.type.format.python"
3867 |             },
3868 |             "2": {
3869 |               "name": "storage.type.format.python"
3870 |             }
3871 |           }
3872 |         },
3873 |         {
3874 |           "include": "#fstring-terminator-single-tail"
3875 |         }
3876 |       ]
3877 |     },
3878 |     "fstring-terminator-single-tail": {
3879 |       "begin": "((?:=?)(?:![rsa])?)(:)(?=.*?{)",
3880 |       "end": "(?=})|(?=\\n)",
3881 |       "beginCaptures": {
3882 |         "1": {
3883 |           "name": "storage.type.format.python"
3884 |         },
3885 |         "2": {
3886 |           "name": "storage.type.format.python"
3887 |         }
3888 |       },
3889 |       "patterns": [
3890 |         {
3891 |           "include": "#fstring-illegal-single-brace"
3892 |         },
3893 |         {
3894 |           "include": "#fstring-single-brace"
3895 |         },
3896 |         {
3897 |           "name": "storage.type.format.python",
3898 |           "match": "([bcdeEfFgGnosxX%])(?=})"
3899 |         },
3900 |         {
3901 |           "name": "storage.type.format.python",
3902 |           "match": "(\\.\\d+)"
3903 |         },
3904 |         {
3905 |           "name": "storage.type.format.python",
3906 |           "match": "(,)"
3907 |         },
3908 |         {
3909 |           "name": "storage.type.format.python",
3910 |           "match": "(\\d+)"
3911 |         },
3912 |         {
3913 |           "name": "storage.type.format.python",
3914 |           "match": "(\\#)"
3915 |         },
3916 |         {
3917 |           "name": "storage.type.format.python",
3918 |           "match": "([-+ ])"
3919 |         },
3920 |         {
3921 |           "name": "storage.type.format.python",
3922 |           "match": "([<>=^])"
3923 |         },
3924 |         {
3925 |           "name": "storage.type.format.python",
3926 |           "match": "(\\w)"
3927 |         }
3928 |       ]
3929 |     },
3930 |     "fstring-fnorm-quoted-multi-line": {
3931 |       "name": "meta.fstring.python",
3932 |       "begin": "(\\b[fF])([bBuU])?('''|\"\"\")",
3933 |       "end": "(\\3)",
3934 |       "beginCaptures": {
3935 |         "1": {
3936 |           "name": "string.interpolated.python string.quoted.multi.python storage.type.string.python"
3937 |         },
3938 |         "2": {
3939 |           "name": "invalid.illegal.prefix.python"
3940 |         },
3941 |         "3": {
3942 |           "name": "punctuation.definition.string.begin.python string.interpolated.python string.quoted.multi.python"
3943 |         }
3944 |       },
3945 |       "endCaptures": {
3946 |         "1": {
3947 |           "name": "punctuation.definition.string.end.python string.interpolated.python string.quoted.multi.python"
3948 |         },
3949 |         "2": {
3950 |           "name": "invalid.illegal.newline.python"
3951 |         }
3952 |       },
3953 |       "patterns": [
3954 |         {
3955 |           "include": "#fstring-guts"
3956 |         },
3957 |         {
3958 |           "include": "#fstring-illegal-multi-brace"
3959 |         },
3960 |         {
3961 |           "include": "#fstring-multi-brace"
3962 |         },
3963 |         {
3964 |           "include": "#fstring-multi-core"
3965 |         }
3966 |       ]
3967 |     },
3968 |     "fstring-normf-quoted-multi-line": {
3969 |       "name": "meta.fstring.python",
3970 |       "begin": "(\\b[bBuU])([fF])('''|\"\"\")",
3971 |       "end": "(\\3)",
3972 |       "beginCaptures": {
3973 |         "1": {
3974 |           "name": "invalid.illegal.prefix.python"
3975 |         },
3976 |         "2": {
3977 |           "name": "string.interpolated.python string.quoted.multi.python storage.type.string.python"
3978 |         },
3979 |         "3": {
3980 |           "name": "punctuation.definition.string.begin.python string.quoted.multi.python"
3981 |         }
3982 |       },
3983 |       "endCaptures": {
3984 |         "1": {
3985 |           "name": "punctuation.definition.string.end.python string.interpolated.python string.quoted.multi.python"
3986 |         },
3987 |         "2": {
3988 |           "name": "invalid.illegal.newline.python"
3989 |         }
3990 |       },
3991 |       "patterns": [
3992 |         {
3993 |           "include": "#fstring-guts"
3994 |         },
3995 |         {
3996 |           "include": "#fstring-illegal-multi-brace"
3997 |         },
3998 |         {
3999 |           "include": "#fstring-multi-brace"
4000 |         },
4001 |         {
4002 |           "include": "#fstring-multi-core"
4003 |         }
4004 |       ]
4005 |     },
4006 |     "fstring-raw-quoted-multi-line": {
4007 |       "name": "meta.fstring.python",
4008 |       "begin": "(\\b(?:[rR][fF]|[fF][rR]))('''|\"\"\")",
4009 |       "end": "(\\2)",
4010 |       "beginCaptures": {
4011 |         "1": {
4012 |           "name": "string.interpolated.python string.quoted.raw.multi.python storage.type.string.python"
4013 |         },
4014 |         "2": {
4015 |           "name": "punctuation.definition.string.begin.python string.quoted.raw.multi.python"
4016 |         }
4017 |       },
4018 |       "endCaptures": {
4019 |         "1": {
4020 |           "name": "punctuation.definition.string.end.python string.interpolated.python string.quoted.raw.multi.python"
4021 |         },
4022 |         "2": {
4023 |           "name": "invalid.illegal.newline.python"
4024 |         }
4025 |       },
4026 |       "patterns": [
4027 |         {
4028 |           "include": "#fstring-raw-guts"
4029 |         },
4030 |         {
4031 |           "include": "#fstring-illegal-multi-brace"
4032 |         },
4033 |         {
4034 |           "include": "#fstring-multi-brace"
4035 |         },
4036 |         {
4037 |           "include": "#fstring-raw-multi-core"
4038 |         }
4039 |       ]
4040 |     },
4041 |     "fstring-multi-core": {
4042 |       "name": "string.interpolated.python string.quoted.multi.python",
4043 |       "match": "(?x)\n  (.+?)\n    (\n      (?# .* and .*? in multi-line match need special handling of\n        newlines otherwise SublimeText and Atom will match slightly\n        differently.\n\n        The guard for newlines has to be separate from the\n        lookahead because of special $ matching rule.)\n      ($\\n?)\n      |\n      (?=[\\\\\\}\\{]|'''|\"\"\")\n    )\n  (?# due to how multiline regexps are matched we need a special case\n    for matching a newline character)\n  | \\n\n"
4044 |     },
4045 |     "fstring-raw-multi-core": {
4046 |       "name": "string.interpolated.python string.quoted.raw.multi.python",
4047 |       "match": "(?x)\n  (.+?)\n    (\n      (?# .* and .*? in multi-line match need special handling of\n        newlines otherwise SublimeText and Atom will match slightly\n        differently.\n\n        The guard for newlines has to be separate from the\n        lookahead because of special $ matching rule.)\n      ($\\n?)\n      |\n      (?=[\\\\\\}\\{]|'''|\"\"\")\n    )\n  (?# due to how multiline regexps are matched we need a special case\n    for matching a newline character)\n  | \\n\n"
4048 |     },
4049 |     "fstring-multi-brace": {
4050 |       "comment": "value interpolation using { ... }",
4051 |       "begin": "(\\{)",
4052 |       "end": "(?x)\n  (\\})\n",
4053 |       "beginCaptures": {
4054 |         "1": {
4055 |           "name": "constant.character.format.placeholder.other.python"
4056 |         }
4057 |       },
4058 |       "endCaptures": {
4059 |         "1": {
4060 |           "name": "constant.character.format.placeholder.other.python"
4061 |         }
4062 |       },
4063 |       "patterns": [
4064 |         {
4065 |           "include": "#fstring-terminator-multi"
4066 |         },
4067 |         {
4068 |           "include": "#f-expression"
4069 |         }
4070 |       ]
4071 |     },
4072 |     "fstring-terminator-multi": {
4073 |       "patterns": [
4074 |         {
4075 |           "name": "storage.type.format.python",
4076 |           "match": "(=(![rsa])?)(?=})"
4077 |         },
4078 |         {
4079 |           "name": "storage.type.format.python",
4080 |           "match": "(=?![rsa])(?=})"
4081 |         },
4082 |         {
4083 |           "match": "(?x)\n  ( (?: =?) (?: ![rsa])? )\n    ( : \\w? [<>=^]? [-+ ]? \\#?\n      \\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )(?=})\n",
4084 |           "captures": {
4085 |             "1": {
4086 |               "name": "storage.type.format.python"
4087 |             },
4088 |             "2": {
4089 |               "name": "storage.type.format.python"
4090 |             }
4091 |           }
4092 |         },
4093 |         {
4094 |           "include": "#fstring-terminator-multi-tail"
4095 |         }
4096 |       ]
4097 |     },
4098 |     "fstring-terminator-multi-tail": {
4099 |       "begin": "((?:=?)(?:![rsa])?)(:)(?=.*?{)",
4100 |       "end": "(?=})",
4101 |       "beginCaptures": {
4102 |         "1": {
4103 |           "name": "storage.type.format.python"
4104 |         },
4105 |         "2": {
4106 |           "name": "storage.type.format.python"
4107 |         }
4108 |       },
4109 |       "patterns": [
4110 |         {
4111 |           "include": "#fstring-illegal-multi-brace"
4112 |         },
4113 |         {
4114 |           "include": "#fstring-multi-brace"
4115 |         },
4116 |         {
4117 |           "name": "storage.type.format.python",
4118 |           "match": "([bcdeEfFgGnosxX%])(?=})"
4119 |         },
4120 |         {
4121 |           "name": "storage.type.format.python",
4122 |           "match": "(\\.\\d+)"
4123 |         },
4124 |         {
4125 |           "name": "storage.type.format.python",
4126 |           "match": "(,)"
4127 |         },
4128 |         {
4129 |           "name": "storage.type.format.python",
4130 |           "match": "(\\d+)"
4131 |         },
4132 |         {
4133 |           "name": "storage.type.format.python",
4134 |           "match": "(\\#)"
4135 |         },
4136 |         {
4137 |           "name": "storage.type.format.python",
4138 |           "match": "([-+ ])"
4139 |         },
4140 |         {
4141 |           "name": "storage.type.format.python",
4142 |           "match": "([<>=^])"
4143 |         },
4144 |         {
4145 |           "name": "storage.type.format.python",
4146 |           "match": "(\\w)"
4147 |         }
4148 |       ]
4149 |     }
4150 |   }
4151 | }
4152 | 


--------------------------------------------------------------------------------