github-linguist 4.7.6 → 4.8.0

data/grammars/source.python.django.json

@@ -0,0 +1,34 @@
+{
+  "fileTypes": [
+
+  ],
+  "keyEquivalent": "^~P",
+  "name": "Python Django",
+  "patterns": [
+    {
+      "match": "(meta|models)\\.(Admin|AutoField|BooleanField|CharField|CommaSeparatedIntegerField|DateField|DateTimeField|DecimalField|EmailField|FileField|FilePathField|FloatField|ForeignKey|ImageField|IntegerField|IPAddressField|ManyToManyField|NullBooleanField|OneToOneField|PhoneNumberField|PositiveIntegerField|PositiveSmallIntegerField|SlugField|SmallIntegerField|TextField|TimeField|URLField|USStateField|XMLField)",
+      "name": "support.type.django.model"
+    },
+    {
+      "match": "django(\\.[a-z]+){1,} ",
+      "name": "support.other.django.module"
+    },
+    {
+      "match": "(ABSOLUTE_URL_OVERRIDES|ADMIN_FOR|ADMIN_MEDIA_PREFIX|ADMINS|ALLOWED_INCLUDE_ROOTS|APPEND_SLASH|AUTHENTICATION_BACKENDS|AUTH_PROFILE_MODULE|CACHE_BACKEND|CACHE_MIDDLEWARE_KEY_PREFIX|CACHE_MIDDLEWARE_SECONDS|DATABASE_ENGINE|DATABASE_HOST|DATABASE_NAME|DATABASE_OPTIONS|DATABASE_PASSWORD|DATABASE_PORT|DATABASE_USER|DATE_FORMAT|DATETIME_FORMAT|DEBUG|DEFAULT_CHARSET|DEFAULT_CONTENT_TYPE|DEFAULT_FROM_EMAIL|DEFAULT_TABLESPACE|DEFAULT_INDEX_TABLESPACE|DISALLOWED_USER_AGENTS|EMAIL_HOST_PASSWORD|EMAIL_HOST_USER|EMAIL_HOST|EMAIL_PORT|EMAIL_SUBJECT_PREFIX|EMAIL_USE_TLS|FILE_CHARSET|FIXTURE_DIRS|IGNORABLE_404_ENDS|IGNORABLE_404_STARTS|INSTALLED_APPS|INTERNAL_IPS|JING_PATH|LANGUAGE_CODE|LANGUAGE_COOKIE_NAME|LANGUAGES|LOCALE_PATHS|LOGIN_REDIRECT_URL|LOGIN_URL|LOGOUT_URL|MANAGERS|MEDIA_ROOT|MEDIA_URL|MIDDLEWARE_CLASSES|MONTH_DAY_FORMAT|PREPEND_WWW|PROFANITIES_LIST|ROOT_URLCONF|SECRET_KEY|SEND_BROKEN_LINK_EMAILS|SERIALIZATION_MODULES|SERVER_EMAIL|SESSION_ENGINE|SESSION_COOKIE_AGE|SESSION_COOKIE_DOMAIN|SESSION_COOKIE_NAME|SESSION_COOKIE_PATH|SESSION_COOKIE_SECURE|SESSION_EXPIRE_AT_BROWSER_CLOSE|SESSION_FILE_PATH|SESSION_SAVE_EVERY_REQUEST|SITE_ID|TEMPLATE_CONTEXT_PROCESSORS|TEMPLATE_DEBUG|TEMPLATE_DIRS|TEMPLATE_LOADERS|TEMPLATE_STRING_IF_INVALID|TEST_DATABASE_CHARSET|TEST_DATABASE_COLLATION|TEST_DATABASE_NAME|TEST_RUNNER|TIME_FORMAT|TIME_ZONE|URL_VALIDATOR_USER_AGENT|USE_ETAGS|USE_I18N|YEAR_MONTH_FORMAT)",
+      "name": "variable.other.django.settings"
+    },
+    {
+      "match": "(get_list_or_404|get_object_or_404|load_and_render|loader|render_to_response)",
+      "name": "support.function.django.view"
+    },
+    {
+      "match": "[a-z_]+\\.get_(object|list|iterator|count|values|values_iterator|in_bulk)",
+      "name": "support.function.django.model"
+    },
+    {
+      "include": "source.python"
+    }
+  ],
+  "scopeName": "source.python.django",
+  "uuid": "5326D56C-6F76-4758-8DB7-D818527919AC"
+}

data/grammars/source.python.json

@@ -0,0 +1,3435 @@
+{
+  "name": "MagicPython",
+  "scopeName": "source.python",
+  "fileTypes": [
+    "py",
+    "py3",
+    "rpy",
+    "pyw",
+    "cpy",
+    "SConstruct",
+    "Sconstruct",
+    "sconstruct",
+    "SConscript"
+  ],
+  "first_line_match": "^#!/.*\\bpython[\\d\\.]*\\b",
+  "firstLineMatch": "^#!/.*\\bpython[\\d\\.]*\\b",
+  "uuid": "742deb57-6e38-4192-bed6-410746efd85d",
+  "patterns": [
+    {
+      "include": "#statement"
+    },
+    {
+      "include": "#expression"
+    }
+  ],
+  "repository": {
+    "statement": {
+      "patterns": [
+        {
+          "include": "#import"
+        },
+        {
+          "include": "#class-declaration"
+        },
+        {
+          "include": "#function-declaration"
+        },
+        {
+          "include": "#statement-keyword"
+        },
+        {
+          "include": "#assignment-operator"
+        },
+        {
+          "include": "#decorator"
+        },
+        {
+          "include": "#docstring-statement"
+        },
+        {
+          "include": "#semicolon"
+        }
+      ]
+    },
+    "semicolon": {
+      "patterns": [
+        {
+          "name": "invalid.deprecated.semicolon.python",
+          "match": "\\;$"
+        }
+      ]
+    },
+    "comments": {
+      "patterns": [
+        {
+          "name": "comment.line.number-sign.python",
+          "contentName": "meta.typehint.comment.python",
+          "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",
+          "end": "(?:$|(?=\\#))",
+          "beginCaptures": {
+            "0": {
+              "name": "meta.typehint.comment.python"
+            },
+            "1": {
+              "name": "comment.typehint.directive.notation.python"
+            }
+          },
+          "patterns": [
+            {
+              "name": "comment.typehint.ignore.notation.python",
+              "match": "(?x)\n  \\G ignore\n  (?= \\s* (?: $ | \\#))\n"
+            },
+            {
+              "name": "comment.typehint.type.notation.python",
+              "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"
+            },
+            {
+              "name": "comment.typehint.punctuation.notation.python",
+              "match": "([\\[\\]\\(\\),\\.\\=\\*]|(->))"
+            },
+            {
+              "name": "comment.typehint.variable.notation.python",
+              "match": "([[:alpha:]_]\\w*)"
+            }
+          ]
+        },
+        {
+          "include": "#comments-base"
+        }
+      ]
+    },
+    "docstring-statement": {
+      "begin": "^(?=\\s*[rR]?(\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\"))",
+      "end": "(?<=\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\")",
+      "patterns": [
+        {
+          "include": "#docstring"
+        }
+      ]
+    },
+    "docstring": {
+      "patterns": [
+        {
+          "name": "string.quoted.docstring.multi.python",
+          "begin": "(\\'\\'\\'|\\\"\\\"\\\")",
+          "end": "(\\1)",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.definition.string.begin.python"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.definition.string.end.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#docstring-prompt"
+            },
+            {
+              "include": "#codetags"
+            },
+            {
+              "include": "#docstring-guts-unicode"
+            }
+          ]
+        },
+        {
+          "name": "string.quoted.docstring.raw.multi.python",
+          "begin": "([rR])(\\'\\'\\'|\\\"\\\"\\\")",
+          "end": "(\\2)",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.type.string.python"
+            },
+            "2": {
+              "name": "punctuation.definition.string.begin.python"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.definition.string.end.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#string-consume-escape"
+            },
+            {
+              "include": "#docstring-prompt"
+            },
+            {
+              "include": "#codetags"
+            }
+          ]
+        },
+        {
+          "name": "string.quoted.docstring.single.python",
+          "begin": "(\\'|\\\")",
+          "end": "(\\1)|((?<!\\\\)\\n)",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.definition.string.begin.python"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.definition.string.end.python"
+            },
+            "2": {
+              "name": "invalid.illegal.newline.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#codetags"
+            },
+            {
+              "include": "#docstring-guts-unicode"
+            }
+          ]
+        },
+        {
+          "name": "string.quoted.docstring.raw.single.python",
+          "begin": "([rR])(\\'|\\\")",
+          "end": "(\\2)|((?<!\\\\)\\n)",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.type.string.python"
+            },
+            "2": {
+              "name": "punctuation.definition.string.begin.python"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.definition.string.end.python"
+            },
+            "2": {
+              "name": "invalid.illegal.newline.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#string-consume-escape"
+            },
+            {
+              "include": "#codetags"
+            }
+          ]
+        }
+      ]
+    },
+    "docstring-guts-unicode": {
+      "patterns": [
+        {
+          "include": "#escape-sequence-unicode"
+        },
+        {
+          "include": "#escape-sequence"
+        },
+        {
+          "include": "#string-line-continuation"
+        }
+      ]
+    },
+    "docstring-prompt": {
+      "match": "(?x)\n  (?:\n    (?:^|\\G) \\s* (?# '\\G' is necessary for ST)\n    ((?:>>>|\\.\\.\\.) \\s) (?=\\s*\\S)\n  )\n",
+      "captures": {
+        "1": {
+          "name": "keyword.control.flow.python"
+        }
+      }
+    },
+    "codetags": {
+      "match": "(?:\\b(NOTE|XXX|HACK|FIXME|BUG|TODO)\\b)",
+      "captures": {
+        "1": {
+          "name": "keyword.codetag.notation.python"
+        }
+      }
+    },
+    "statement-keyword": {
+      "patterns": [
+        {
+          "name": "storage.type.function.python",
+          "match": "\\b((async\\s+)?\\s*def)\\b"
+        },
+        {
+          "name": "keyword.control.flow.python",
+          "match": "(?x)\n  \\b(?<!\\.)(\n    as | async | continue | del | assert | break | finally | for\n    | from | elif | else | if | except | pass | raise\n    | return | try | while | with\n  )\\b\n"
+        },
+        {
+          "name": "storage.modifier.declaration.python",
+          "match": "(?x)\n  \\b(?<!\\.)(\n    global | nonlocal\n  )\\b\n"
+        },
+        {
+          "name": "storage.type.class.python",
+          "match": "\\b(?<!\\.)(class)\\b"
+        }
+      ]
+    },
+    "expression-base": {
+      "comment": "All valid Python expressions",
+      "patterns": [
+        {
+          "include": "#backticks"
+        },
+        {
+          "include": "#illegal-anno"
+        },
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#literal"
+        },
+        {
+          "include": "#regexp"
+        },
+        {
+          "include": "#string"
+        },
+        {
+          "include": "#lambda"
+        },
+        {
+          "include": "#illegal-operator"
+        },
+        {
+          "include": "#operator"
+        },
+        {
+          "include": "#curly-braces"
+        },
+        {
+          "include": "#item-access"
+        },
+        {
+          "include": "#list"
+        },
+        {
+          "include": "#round-braces"
+        },
+        {
+          "include": "#function-call"
+        },
+        {
+          "include": "#builtin-functions"
+        },
+        {
+          "include": "#builtin-types"
+        },
+        {
+          "include": "#builtin-exceptions"
+        },
+        {
+          "include": "#magic-names"
+        },
+        {
+          "include": "#special-names"
+        },
+        {
+          "include": "#illegal-names"
+        },
+        {
+          "include": "#special-variables"
+        },
+        {
+          "include": "#line-continuation"
+        },
+        {
+          "include": "#ellipsis"
+        }
+      ]
+    },
+    "expression": {
+      "comment": "All valid Python expressions",
+      "patterns": [
+        {
+          "include": "#expression-base"
+        },
+        {
+          "include": "#member-access"
+        },
+        {
+          "comment": "Tokenize identifiers to help linters",
+          "match": "(?x) \\b ([[:alpha:]_]\\w*) \\b"
+        }
+      ]
+    },
+    "member-access": {
+      "begin": "\\.\\s*(?!\\.)",
+      "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",
+      "patterns": [
+        {
+          "include": "#function-call"
+        },
+        {
+          "include": "#member-access-base"
+        }
+      ]
+    },
+    "member-access-base": {
+      "patterns": [
+        {
+          "include": "#magic-names"
+        },
+        {
+          "include": "#illegal-names"
+        },
+        {
+          "include": "#illegal-object-name"
+        },
+        {
+          "include": "#special-names"
+        },
+        {
+          "include": "#line-continuation"
+        },
+        {
+          "include": "#item-access"
+        }
+      ]
+    },
+    "special-names": {
+      "name": "constant.other.caps.python",
+      "match": "(?x)\n  \\b\n    (\n      _* [[:upper:]]\n    )\n    [[:upper:]\\d]* (_\\w*)?\n  \\b\n"
+    },
+    "curly-braces": {
+      "begin": "\\{",
+      "end": "\\}",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.dict.begin.python"
+        }
+      },
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.dict.end.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#expression"
+        }
+      ]
+    },
+    "list": {
+      "begin": "\\[",
+      "end": "\\]",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.list.begin.python"
+        }
+      },
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.list.end.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#expression"
+        }
+      ]
+    },
+    "round-braces": {
+      "begin": "\\(",
+      "end": "\\)",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.parenthesis.begin.python"
+        }
+      },
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.parenthesis.end.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#expression"
+        }
+      ]
+    },
+    "line-continuation": {
+      "patterns": [
+        {
+          "match": "(\\\\)\\s*(\\S.*$\\n?)",
+          "captures": {
+            "1": {
+              "name": "separator.continuation.line.python"
+            },
+            "2": {
+              "name": "invalid.illegal.line.continuation.python"
+            }
+          }
+        },
+        {
+          "begin": "(\\\\)\\s*$\\n?",
+          "end": "(?x)\n  (?=^\\s*$)\n  |\n  (?! (\\s* [rR]? (\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\"))\n      |\n      (\\G $)  (?# '\\G' is necessary for ST)\n  )\n",
+          "beginCaptures": {
+            "1": {
+              "name": "separator.continuation.line.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#regexp"
+            },
+            {
+              "include": "#string"
+            }
+          ]
+        }
+      ]
+    },
+    "assignment-operator": {
+      "name": "keyword.operator.assignment.python",
+      "match": "(?x)\n     <<= | >>= | //= | \\*\\*=\n    | \\+= | -= | /= | @=\n    | \\*= | %= | ~= | \\^= | &= | \\|=\n    | =\n"
+    },
+    "operator": {
+      "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",
+      "captures": {
+        "1": {
+          "name": "keyword.operator.logical.python"
+        },
+        "2": {
+          "name": "keyword.control.flow.python"
+        },
+        "3": {
+          "name": "keyword.operator.bitwise.python"
+        },
+        "4": {
+          "name": "keyword.operator.arithmetic.python"
+        },
+        "5": {
+          "name": "keyword.operator.comparison.python"
+        }
+      }
+    },
+    "literal": {
+      "patterns": [
+        {
+          "name": "constant.language.python",
+          "match": "\\b(True|False|None|NotImplemented|Ellipsis)\\b"
+        },
+        {
+          "include": "#number"
+        }
+      ]
+    },
+    "number": {
+      "name": "constant.numeric.python",
+      "patterns": [
+        {
+          "include": "#number-float"
+        },
+        {
+          "include": "#number-dec"
+        },
+        {
+          "include": "#number-hex"
+        },
+        {
+          "include": "#number-oct"
+        },
+        {
+          "include": "#number-bin"
+        },
+        {
+          "include": "#number-long"
+        },
+        {
+          "name": "invalid.illegal.name.python",
+          "match": "\\b[0-9]+\\w+"
+        }
+      ]
+    },
+    "number-float": {
+      "name": "constant.numeric.float.python",
+      "match": "(?x)\n  (?<! \\w)(?:\n    [0-9]*\\.[0-9]+ ([eE][+-]?[0-9]+)?\n    | [0-9]+\\. ([eE][+-]?[0-9]+)?\n    | [0-9]+ ([eE][+-]?[0-9]+)\n  )([jJ])?\\b\n",
+      "captures": {
+        "4": {
+          "name": "storage.type.imaginary.number.python"
+        }
+      }
+    },
+    "number-dec": {
+      "name": "constant.numeric.dec.python",
+      "match": "(?x)\n  (?<![\\w\\.])(?:\n      [1-9][0-9]*\n      |\n      0+\n      |\n      [0-9]+ ([jJ])\n      |\n      0 ([0-9]+)(?![eE\\.])\n  )\\b\n",
+      "captures": {
+        "1": {
+          "name": "storage.type.imaginary.number.python"
+        },
+        "2": {
+          "name": "invalid.illegal.dec.python"
+        },
+        "3": {
+          "name": "invalid.illegal.dec.python"
+        }
+      }
+    },
+    "number-hex": {
+      "name": "constant.numeric.hex.python",
+      "match": "(?x)\n  (?<![\\w\\.])\n    (0[xX]) [0-9a-fA-F]+\n  \\b\n",
+      "captures": {
+        "1": {
+          "name": "storage.type.number.python"
+        }
+      }
+    },
+    "number-oct": {
+      "name": "constant.numeric.oct.python",
+      "match": "(?x)\n  (?<![\\w\\.])\n    (0[oO]) [0-7]+\n  \\b\n",
+      "captures": {
+        "1": {
+          "name": "storage.type.number.python"
+        }
+      }
+    },
+    "number-bin": {
+      "name": "constant.numeric.bin.python",
+      "match": "(?x)\n  (?<![\\w\\.])\n    (0[bB]) [01]+\n  \\b\n",
+      "captures": {
+        "1": {
+          "name": "storage.type.number.python"
+        }
+      }
+    },
+    "number-long": {
+      "name": "constant.numeric.bin.python",
+      "comment": "this is to support python2 syntax for long ints",
+      "match": "(?x)\n  (?<![\\w\\.])\n    ([1-9][0-9]* | 0) ([lL])\n  \\b\n",
+      "captures": {
+        "2": {
+          "name": "storage.type.number.python"
+        }
+      }
+    },
+    "regexp": {
+      "patterns": [
+        {
+          "include": "#regexp-single-quoted-multi-line"
+        },
+        {
+          "include": "#regexp-double-quoted-multi-line"
+        },
+        {
+          "include": "#regexp-single-quoted-single-line"
+        },
+        {
+          "include": "#regexp-double-quoted-single-line"
+        }
+      ]
+    },
+    "regexp-single-quoted-single-line": {
+      "name": "string.regexp.quoted.single.python",
+      "begin": "\\b(([uU]r)|([bB]r)|(r[bB]?))(\\')",
+      "end": "(\\')|(?<!\\\\)(\\n)",
+      "beginCaptures": {
+        "2": {
+          "name": "invalid.deprecated.prefix.python"
+        },
+        "3": {
+          "name": "storage.type.string.python"
+        },
+        "4": {
+          "name": "storage.type.string.python"
+        },
+        "5": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-one-regexp-expression"
+        }
+      ]
+    },
+    "regexp-double-quoted-single-line": {
+      "name": "string.regexp.quoted.single.python",
+      "begin": "\\b(([uU]r)|([bB]r)|(r[bB]?))(\\\")",
+      "end": "(\\\")|(?<!\\\\)(\\n)",
+      "beginCaptures": {
+        "2": {
+          "name": "invalid.deprecated.prefix.python"
+        },
+        "3": {
+          "name": "storage.type.string.python"
+        },
+        "4": {
+          "name": "storage.type.string.python"
+        },
+        "5": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-one-regexp-expression"
+        }
+      ]
+    },
+    "regexp-single-quoted-multi-line": {
+      "name": "string.regexp.quoted.multi.python",
+      "begin": "\\b(([uU]r)|([bB]r)|(r[bB]?))(\\'\\'\\')",
+      "end": "\\'\\'\\'",
+      "beginCaptures": {
+        "2": {
+          "name": "invalid.deprecated.prefix.python"
+        },
+        "3": {
+          "name": "storage.type.string.python"
+        },
+        "4": {
+          "name": "storage.type.string.python"
+        },
+        "5": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-three-regexp-expression"
+        }
+      ]
+    },
+    "regexp-double-quoted-multi-line": {
+      "name": "string.regexp.quoted.multi.python",
+      "begin": "\\b(([uU]r)|([bB]r)|(r[bB]?))(\\\"\\\"\\\")",
+      "end": "\\\"\\\"\\\"",
+      "beginCaptures": {
+        "2": {
+          "name": "invalid.deprecated.prefix.python"
+        },
+        "3": {
+          "name": "storage.type.string.python"
+        },
+        "4": {
+          "name": "storage.type.string.python"
+        },
+        "5": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-three-regexp-expression"
+        }
+      ]
+    },
+    "string": {
+      "patterns": [
+        {
+          "include": "#string-quoted-multi-line"
+        },
+        {
+          "include": "#string-quoted-single-line"
+        },
+        {
+          "include": "#string-bin-quoted-multi-line"
+        },
+        {
+          "include": "#string-bin-quoted-single-line"
+        },
+        {
+          "include": "#string-raw-quoted-multi-line"
+        },
+        {
+          "include": "#string-raw-quoted-single-line"
+        },
+        {
+          "include": "#string-raw-bin-quoted-multi-line"
+        },
+        {
+          "include": "#string-raw-bin-quoted-single-line"
+        }
+      ]
+    },
+    "string-unicode-guts": {
+      "patterns": [
+        {
+          "include": "#escape-sequence-unicode"
+        },
+        {
+          "include": "#string-entity"
+        },
+        {
+          "include": "#string-brace-formatting"
+        }
+      ]
+    },
+    "string-consume-escape": {
+      "match": "\\\\['\"\\n\\\\]"
+    },
+    "string-raw-guts": {
+      "patterns": [
+        {
+          "include": "#string-consume-escape"
+        },
+        {
+          "include": "#string-formatting"
+        },
+        {
+          "include": "#string-brace-formatting"
+        }
+      ]
+    },
+    "string-raw-bin-guts": {
+      "patterns": [
+        {
+          "include": "#string-consume-escape"
+        },
+        {
+          "include": "#string-formatting"
+        }
+      ]
+    },
+    "string-entity": {
+      "patterns": [
+        {
+          "include": "#escape-sequence"
+        },
+        {
+          "include": "#string-line-continuation"
+        },
+        {
+          "include": "#string-formatting"
+        }
+      ]
+    },
+    "escape-sequence-unicode": {
+      "patterns": [
+        {
+          "name": "constant.character.escape.python",
+          "match": "(?x)\n  \\\\ (\n        u[0-9A-Fa-f]{4}\n        | U[0-9A-Fa-f]{8}\n        | N\\{[\\w\\s]+?\\}\n     )\n"
+        }
+      ]
+    },
+    "escape-sequence": {
+      "name": "constant.character.escape.python",
+      "match": "(?x)\n  \\\\ (\n        x[0-9A-Fa-f]{2}\n        | [0-7]{1,3}\n        | [\\\\\"'abfnrtv]\n     )\n"
+    },
+    "string-line-continuation": {
+      "name": "constant.language.python",
+      "match": "\\\\$"
+    },
+    "string-formatting": {
+      "name": "constant.character.format.placeholder.other.python",
+      "match": "(?x)\n  % (\\([\\w\\s]*\\))?\n    [-+#0 ]*\n    (\\d+|\\*)? (\\.(\\d+|\\*))?\n    ([hlL])?\n    [diouxXeEfFgGcrsa%]\n"
+    },
+    "string-brace-formatting": {
+      "patterns": [
+        {
+          "name": "constant.character.format.placeholder.other.python",
+          "match": "(?x)\n  (?:\n    {{ | }}\n    | (?:\n      {\n        \\w*? (\\.[[:alpha:]_]\\w*? | \\[[^\\]'\"]+\\])*?\n        (![rsa])?\n        ( : \\w? [<>=^]? [-+ ]? \\#?\n          \\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )?\n      })\n  )\n",
+          "captures": {
+            "2": {
+              "name": "storage.type.format.python"
+            },
+            "3": {
+              "name": "support.other.format.python"
+            }
+          }
+        },
+        {
+          "name": "constant.character.format.placeholder.other.python",
+          "begin": "(?x)\n    \\{\n      \\w*? (\\.[[:alpha:]_]\\w*? | \\[[^\\]'\"]+\\])*?\n      (![rsa])?\n      (:)\n        (?=[^'\"}\\n]*\\})\n",
+          "end": "\\}",
+          "beginCaptures": {
+            "2": {
+              "name": "storage.type.format.python"
+            },
+            "3": {
+              "name": "support.other.format.python"
+            }
+          },
+          "patterns": [
+            {
+              "match": "(?x) \\{ [^'\"}\\n]*? \\} (?=.*?\\})\n"
+            }
+          ]
+        }
+      ]
+    },
+    "import": {
+      "comment": "Import statements\n",
+      "patterns": [
+        {
+          "match": "(?x)\n  \\s* \\b(from)\\b (\\s*\\.+\\s*) (import)?\n",
+          "captures": {
+            "1": {
+              "name": "keyword.control.import.python"
+            },
+            "3": {
+              "name": "keyword.control.import.python"
+            }
+          }
+        },
+        {
+          "name": "keyword.control.import.python",
+          "match": "\\b(?<!\\.)import\\b"
+        }
+      ]
+    },
+    "class-declaration": {
+      "patterns": [
+        {
+          "name": "meta.class.python",
+          "begin": "(?x)\n  \\s*(class)\\s+\n    (?=\n      [[:alpha:]_]\\w* \\s* (:|\\()\n    )\n",
+          "end": "(:)",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.type.class.python"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.section.class.begin.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#class-name"
+            },
+            {
+              "include": "#class-inheritance"
+            }
+          ]
+        }
+      ]
+    },
+    "class-name": {
+      "patterns": [
+        {
+          "include": "#illegal-object-name"
+        },
+        {
+          "include": "#builtin-possible-callables"
+        },
+        {
+          "name": "entity.name.type.class.python",
+          "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
+        }
+      ]
+    },
+    "class-inheritance": {
+      "name": "meta.class.inheritance.python",
+      "begin": "(\\()",
+      "end": "(\\))",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.definition.inheritance.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.inheritance.end.python"
+        }
+      },
+      "patterns": [
+        {
+          "name": "keyword.operator.unpacking.arguments.python",
+          "match": "(\\*\\*|\\*)"
+        },
+        {
+          "name": "punctuation.separator.inheritance.python",
+          "match": ","
+        },
+        {
+          "name": "keyword.operator.assignment.python",
+          "match": "\\="
+        },
+        {
+          "include": "#expression-class"
+        },
+        {
+          "name": "support.type.metaclass.python",
+          "match": "\\bmetaclass\\b"
+        },
+        {
+          "include": "#inheritance-identifier"
+        }
+      ]
+    },
+    "inheritance-identifier": {
+      "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n",
+      "captures": {
+        "1": {
+          "name": "entity.other.inherited-class.python"
+        }
+      }
+    },
+    "expression-class": {
+      "patterns": [
+        {
+          "include": "#call-wrapper-inheritance"
+        },
+        {
+          "include": "#expression-base"
+        },
+        {
+          "include": "#member-access-class"
+        }
+      ]
+    },
+    "member-access-class": {
+      "begin": "\\.\\s*(?!\\.)",
+      "end": "(?<=\\S)(?=\\W)|$",
+      "patterns": [
+        {
+          "include": "#call-wrapper-inheritance"
+        },
+        {
+          "include": "#member-access-base"
+        },
+        {
+          "include": "#inheritance-identifier"
+        }
+      ]
+    },
+    "lambda": {
+      "patterns": [
+        {
+          "match": "((?<=\\.)lambda|lambda(?=\\s*[\\.=]))",
+          "captures": {
+            "1": {
+              "name": "keyword.control.flow.python"
+            }
+          }
+        },
+        {
+          "match": "\\b(lambda)\\s*?([,\\n]|$)",
+          "captures": {
+            "1": {
+              "name": "storage.type.function.lambda.python"
+            }
+          }
+        },
+        {
+          "name": "meta.lambda-function.python",
+          "begin": "(?x)\n  \\b (lambda) \\b\n",
+          "end": "(:)|(\\n)",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.type.function.lambda.python"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.section.function.lambda.begin.python"
+            }
+          },
+          "contentName": "meta.function.lambda.parameters.python",
+          "patterns": [
+            {
+              "name": "keyword.operator.unpacking.parameter.python",
+              "match": "(\\*\\*|\\*)"
+            },
+            {
+              "include": "#lambda-incomplete"
+            },
+            {
+              "include": "#illegal-names"
+            },
+            {
+              "match": "([[:alpha:]_]\\w*)\\s*(?:(,)|(?=:|$))",
+              "captures": {
+                "1": {
+                  "name": "variable.parameter.function.language.python"
+                },
+                "2": {
+                  "name": "punctuation.separator.parameters.python"
+                }
+              }
+            },
+            {
+              "include": "#comments"
+            },
+            {
+              "include": "#backticks"
+            },
+            {
+              "include": "#illegal-anno"
+            },
+            {
+              "include": "#lambda-parameter-with-default"
+            },
+            {
+              "include": "#line-continuation"
+            },
+            {
+              "include": "#illegal-operator"
+            }
+          ]
+        }
+      ]
+    },
+    "lambda-incomplete": {
+      "name": "storage.type.function.lambda.python",
+      "match": "\\blambda(?=\\s*[:,)])"
+    },
+    "lambda-parameter-with-default": {
+      "begin": "(?x)\n  \\b\n  ([[:alpha:]_]\\w*) \\s* (=)\n",
+      "end": "(,)|(?=:|$)",
+      "beginCaptures": {
+        "1": {
+          "name": "variable.parameter.function.language.python"
+        },
+        "2": {
+          "name": "keyword.operator.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.separator.parameters.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#expression"
+        }
+      ]
+    },
+    "function-declaration": {
+      "name": "meta.function.python",
+      "begin": "(?x)\n  \\s*\n  (?:\\b(async) \\s+)? \\b(def)\\s+\n    (?=\n      [[:alpha:]_][[:word:]]* \\s* \\(\n    )\n",
+      "end": "(:)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.function.async.python"
+        },
+        "2": {
+          "name": "storage.type.function.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.section.function.begin.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#function-def-name"
+        },
+        {
+          "include": "#parameters"
+        },
+        {
+          "include": "#return-annotation"
+        }
+      ]
+    },
+    "function-def-name": {
+      "patterns": [
+        {
+          "include": "#illegal-object-name"
+        },
+        {
+          "include": "#builtin-possible-callables"
+        },
+        {
+          "name": "entity.name.function.python",
+          "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
+        }
+      ]
+    },
+    "parameters": {
+      "name": "meta.function.parameters.python",
+      "begin": "(\\()",
+      "end": "(\\))",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.definition.parameters.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.parameters.end.python"
+        }
+      },
+      "patterns": [
+        {
+          "name": "keyword.operator.unpacking.parameter.python",
+          "match": "(\\*\\*|\\*)"
+        },
+        {
+          "include": "#lambda-incomplete"
+        },
+        {
+          "include": "#illegal-names"
+        },
+        {
+          "include": "#illegal-object-name"
+        },
+        {
+          "include": "#parameter-special"
+        },
+        {
+          "match": "([[:alpha:]_]\\w*)\\s*(?:(,)|(?=\\)))",
+          "captures": {
+            "1": {
+              "name": "variable.parameter.function.language.python"
+            },
+            "2": {
+              "name": "punctuation.separator.parameters.python"
+            }
+          }
+        },
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#parameter-with-default"
+        },
+        {
+          "include": "#annotated-parameter"
+        }
+      ]
+    },
+    "parameter-special": {
+      "match": "(?x)\n  \\b ((self)|(cls)) \\b \\s*(?:(,)|(?=\\)))\n",
+      "captures": {
+        "1": {
+          "name": "variable.parameter.function.language.python"
+        },
+        "2": {
+          "name": "variable.parameter.function.language.special.self.python"
+        },
+        "3": {
+          "name": "variable.parameter.function.language.special.cls.python"
+        },
+        "4": {
+          "name": "punctuation.separator.parameters.python"
+        }
+      }
+    },
+    "parameter-with-default": {
+      "begin": "(?x)\n  \\b\n  ([[:alpha:]_]\\w*) \\s* (=)\n",
+      "end": "(,)|(?=\\))",
+      "beginCaptures": {
+        "1": {
+          "name": "variable.parameter.function.language.python"
+        },
+        "2": {
+          "name": "keyword.operator.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.separator.parameters.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#expression"
+        }
+      ]
+    },
+    "annotated-parameter": {
+      "begin": "(?x)\n  \\b\n  ([[:alpha:]_]\\w*) \\s* (:)\n",
+      "end": "(,)|(?=\\))",
+      "beginCaptures": {
+        "1": {
+          "name": "variable.parameter.function.language.python"
+        },
+        "2": {
+          "name": "punctuation.separator.annotation.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.separator.parameters.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#expression"
+        },
+        {
+          "name": "keyword.operator.assignment.python",
+          "match": "\\="
+        }
+      ]
+    },
+    "return-annotation": {
+      "begin": "(->)",
+      "end": "(?=:)",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.separator.annotation.result.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#expression"
+        }
+      ]
+    },
+    "item-access": {
+      "patterns": [
+        {
+          "name": "meta.item-access.python",
+          "begin": "(?x)\n  \\b(?=\n    [[:alpha:]_]\\w* \\s* \\[\n  )\n",
+          "end": "(\\])",
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.definition.arguments.end.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#item-name"
+            },
+            {
+              "include": "#item-index"
+            },
+            {
+              "include": "#expression"
+            }
+          ]
+        }
+      ]
+    },
+    "item-name": {
+      "patterns": [
+        {
+          "include": "#special-variables"
+        },
+        {
+          "include": "#builtin-functions"
+        },
+        {
+          "include": "#special-names"
+        },
+        {
+          "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
+        }
+      ]
+    },
+    "item-index": {
+      "begin": "(\\[)",
+      "end": "(?=\\])",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.definition.arguments.begin.python"
+        }
+      },
+      "contentName": "meta.item-access.arguments.python",
+      "patterns": [
+        {
+          "include": "#expression"
+        }
+      ]
+    },
+    "decorator": {
+      "name": "meta.function.decorator.python",
+      "begin": "(?x)\n  ^\\s*\n  (@) \\s* (?=[[:alpha:]_]\\w*)\n",
+      "end": "(?x)\n  ( \\) ) (?: (?=\\s*\\#|$) | (.*$) )\n  | (?=\\n|\\#)\n",
+      "beginCaptures": {
+        "1": {
+          "name": "entity.name.function.decorator.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.arguments.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.decorator.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#decorator-name"
+        },
+        {
+          "include": "#function-arguments"
+        }
+      ]
+    },
+    "decorator-name": {
+      "patterns": [
+        {
+          "include": "#builtin-callables"
+        },
+        {
+          "include": "#illegal-object-name"
+        },
+        {
+          "name": "entity.name.function.decorator.python",
+          "match": "(?x)\n  ([[:alpha:]_]\\w*) | \\.\n"
+        },
+        {
+          "include": "#line-continuation"
+        },
+        {
+          "name": "invalid.illegal.decorator.python",
+          "match": "(?x)\n  \\s* ([^([:alpha:]\\s_\\.#\\\\] .*?) (?=\\#|$)\n",
+          "captures": {
+            "1": {
+              "name": "invalid.illegal.decorator.python"
+            }
+          }
+        }
+      ]
+    },
+    "call-wrapper-inheritance": {
+      "comment": "same as a funciton call, but in inheritance context",
+      "name": "meta.function-call.python",
+      "begin": "(?x)\n  \\b(?=\n    ([[:alpha:]_]\\w*) \\s* (\\()\n  )\n",
+      "end": "(\\))",
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.arguments.end.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#inheritance-name"
+        },
+        {
+          "include": "#function-arguments"
+        }
+      ]
+    },
+    "inheritance-name": {
+      "patterns": [
+        {
+          "include": "#lambda-incomplete"
+        },
+        {
+          "include": "#builtin-possible-callables"
+        },
+        {
+          "include": "#inheritance-identifier"
+        }
+      ]
+    },
+    "function-call": {
+      "name": "meta.function-call.python",
+      "begin": "(?x)\n  \\b(?=\n    ([[:alpha:]_]\\w*) \\s* (\\()\n  )\n",
+      "end": "(\\))",
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.arguments.end.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#special-variables"
+        },
+        {
+          "include": "#function-name"
+        },
+        {
+          "include": "#function-arguments"
+        }
+      ]
+    },
+    "function-name": {
+      "patterns": [
+        {
+          "include": "#builtin-possible-callables"
+        },
+        {
+          "comment": "Some color schemas support meta.function-call.generic scope",
+          "name": "meta.function-call.generic.python",
+          "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
+        }
+      ]
+    },
+    "function-arguments": {
+      "begin": "(?x)\n  (?:\n    (\\()\n    (?:\\s*(\\*\\*|\\*))?\n  )\n",
+      "end": "(?=\\))(?!\\)\\s*\\()",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.definition.arguments.begin.python"
+        },
+        "2": {
+          "name": "keyword.operator.unpacking.arguments.python"
+        }
+      },
+      "contentName": "meta.function-call.arguments.python",
+      "patterns": [
+        {
+          "match": "(?x)\n  (?:\n    (,)\n    (?:\\s*(\\*\\*|\\*))?\n  )\n",
+          "captures": {
+            "1": {
+              "name": "punctuation.separator.arguments.python"
+            },
+            "2": {
+              "name": "keyword.operator.unpacking.arguments.python"
+            }
+          }
+        },
+        {
+          "include": "#lambda-incomplete"
+        },
+        {
+          "include": "#illegal-names"
+        },
+        {
+          "match": "\\b([[:alpha:]_]\\w*)\\s*(=)(?!=)",
+          "captures": {
+            "1": {
+              "name": "variable.parameter.function-call.python"
+            },
+            "2": {
+              "name": "keyword.operator.assignment.python"
+            }
+          }
+        },
+        {
+          "name": "keyword.operator.assignment.python",
+          "match": "\\="
+        },
+        {
+          "include": "#expression"
+        },
+        {
+          "match": "\\s*(\\))\\s*(\\()",
+          "captures": {
+            "1": {
+              "name": "punctuation.definition.arguments.end.python"
+            },
+            "2": {
+              "name": "punctuation.definition.arguments.begin.python"
+            }
+          }
+        }
+      ]
+    },
+    "builtin-callables": {
+      "patterns": [
+        {
+          "include": "#illegal-names"
+        },
+        {
+          "include": "#illegal-object-name"
+        },
+        {
+          "include": "#builtin-exceptions"
+        },
+        {
+          "include": "#builtin-functions"
+        },
+        {
+          "include": "#builtin-types"
+        }
+      ]
+    },
+    "builtin-possible-callables": {
+      "patterns": [
+        {
+          "include": "#builtin-callables"
+        },
+        {
+          "include": "#magic-names"
+        }
+      ]
+    },
+    "builtin-exceptions": {
+      "name": "support.type.exception.python",
+      "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\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"
+    },
+    "builtin-functions": {
+      "patterns": [
+        {
+          "name": "support.function.builtin.python",
+          "match": "(?x)\n  (?<!\\.) \\b(\n    __import__ | abs | all | any | ascii | bin | callable\n    | chr | compile | copyright | credits | delattr | dir | divmod\n    | enumerate | eval | exec | exit | filter | format | getattr\n    | globals | hasattr | hash | help | hex | id | input\n    | isinstance | issubclass | iter | len | license | locals | map\n    | max | memoryview | min | next | oct | open | ord | pow | print\n    | quit | range | reload | repr | reversed | round\n    | setattr | sorted | sum | vars | zip\n  )\\b\n"
+        },
+        {
+          "name": "variable.legacy.builtin.python",
+          "match": "(?x)\n  (?<!\\.) \\b(\n    file | reduce | intern | raw_input | unicode | cmp | basestring\n    | execfile | long | xrange\n  )\\b\n"
+        }
+      ]
+    },
+    "builtin-types": {
+      "name": "support.type.python",
+      "match": "(?x)\n  (?<!\\.) \\b(\n    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"
+    },
+    "magic-function-names": {
+      "comment": "these methods have magic interpretation by python and are generally called\nindirectly through syntactic constructs\n",
+      "match": "(?x)\n  \\b(\n    __(?:\n      abs | add | aenter | aexit | aiter | and | anext | await\n      | bool | call | ceil | cmp | coerce | complex | contains\n      | copy | deepcopy | del | delattr | delete | delitem\n      | delslice | dir | div | divmod | enter | eq | exit | float\n      | floor | floordiv | format | ge | get | getattr\n      | getattribute | getinitargs | getitem | getnewargs\n      | getslice | getstate | gt | hash | hex | iadd | iand | idiv\n      | ifloordiv | ilshift | imod | imul | index | init\n      | instancecheck | int | invert | ior | ipow | irshift | isub\n      | iter | itruediv | ixor | le | len | long | lshift | lt\n      | missing | mod | mul | ne | neg | new | next | nonzero | oct | or\n      | pos | pow | radd | rand | rdiv | rdivmod | reduce\n      | reduce_ex | repr | reversed | rfloordiv | rlshift | rmod\n      | rmul | ror | round | rpow | rrshift | rshift | rsub\n      | rtruediv | rxor | set | setattr | setitem | setslice\n      | setstate | sizeof | str | sub | subclasscheck | truediv\n      | trunc | unicode | xor\n    )__\n  )\\b\n",
+      "captures": {
+        "1": {
+          "name": "support.function.magic.python"
+        }
+      }
+    },
+    "magic-variable-names": {
+      "comment": "magic variables which a class/module may have.",
+      "match": "(?x)\n  \\b(\n    __(?:\n      all | bases | builtins | class | code | debug | defaults | dict\n      | doc | file | func | kwdefaults | members\n      | metaclass | methods | module | mro | name\n      | qualname | self | signature | slots | subclasses\n      | version | weakref | wrapped\n    )__\n  )\\b\n",
+      "captures": {
+        "1": {
+          "name": "support.variable.magic.python"
+        }
+      }
+    },
+    "magic-names": {
+      "patterns": [
+        {
+          "include": "#magic-function-names"
+        },
+        {
+          "include": "#magic-variable-names"
+        }
+      ]
+    },
+    "illegal-names": {
+      "name": "keyword.control.flow.python",
+      "match": "(?x)\n  \\b(\n    and | as | assert | async | await | break | class | continue | def\n    | del | elif | else | except | exec | finally | for | from | global\n    | if | import | in | is | (?<=\\.)lambda | lambda(?=\\s*[\\.=])\n    | nonlocal | not | or | pass | raise | return | try | while | with\n    | yield\n  )\\b\n"
+    },
+    "special-variables": {
+      "match": "(?x)\n  \\b (?<!\\.) (?:\n    (self) | (cls)\n  )\\b\n",
+      "captures": {
+        "1": {
+          "name": "variable.language.special.self.python"
+        },
+        "2": {
+          "name": "variable.language.special.cls.python"
+        }
+      }
+    },
+    "ellipsis": {
+      "name": "constant.other.ellipsis.python",
+      "match": "\\.\\.\\."
+    },
+    "backticks": {
+      "name": "invalid.deprecated.backtick.python",
+      "begin": "\\`",
+      "end": "(?:\\`|(?<!\\\\)(\\n))",
+      "patterns": [
+        {
+          "include": "#expression"
+        }
+      ]
+    },
+    "illegal-operator": {
+      "patterns": [
+        {
+          "name": "invalid.illegal.operator.python",
+          "match": "&&|\\|\\||--|\\+\\+"
+        },
+        {
+          "name": "invalid.illegal.operator.python",
+          "match": "[?$]"
+        },
+        {
+          "name": "invalid.illegal.operator.python",
+          "comment": "We don't want `!` to flash when we're typing `!=`",
+          "match": "!\\b"
+        }
+      ]
+    },
+    "illegal-object-name": {
+      "comment": "It's illegal to name class or function \"True\"",
+      "name": "keyword.illegal.name.python",
+      "match": "\\b(True|False|None)\\b"
+    },
+    "illegal-anno": {
+      "name": "invalid.illegal.annotation.python",
+      "match": "->"
+    },
+    "regexp-base-expression": {
+      "patterns": [
+        {
+          "name": "support.other.match.any.regexp",
+          "match": "\\."
+        },
+        {
+          "name": "support.other.match.begin.regexp",
+          "match": "\\^"
+        },
+        {
+          "name": "support.other.match.end.regexp",
+          "match": "\\$"
+        },
+        {
+          "name": "keyword.operator.quantifier.regexp",
+          "match": "[+*?]\\??"
+        },
+        {
+          "name": "keyword.operator.disjunction.regexp",
+          "match": "\\|"
+        },
+        {
+          "name": "keyword.operator.quantifier.regexp",
+          "match": "(?x)\n  \\{(\n    \\d+ | \\d+,(\\d+)? | ,\\d+\n  )\\}\n"
+        },
+        {
+          "include": "#regexp-escape-sequence"
+        }
+      ]
+    },
+    "regexp-backreference-number": {
+      "name": "meta.backreference.regexp",
+      "match": "(\\\\[1-9]\\d?)",
+      "captures": {
+        "1": {
+          "name": "entity.name.tag.backreference.regexp"
+        }
+      }
+    },
+    "regexp-backreference": {
+      "name": "meta.backreference.named.regexp",
+      "match": "(?x)\n  (\\()  (\\?P= \\w+(?:\\s+[[:alnum:]]+)?)  (\\))\n",
+      "captures": {
+        "1": {
+          "name": "punctuation.parenthesis.backreference.named.begin.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "entity.name.tag.named.backreference.regexp"
+        },
+        "3": {
+          "name": "punctuation.parenthesis.backreference.named.end.regexp support.other.parenthesis.regexp"
+        }
+      }
+    },
+    "regexp-flags": {
+      "name": "storage.modifier.flag.regexp",
+      "match": "\\(\\?[aiLmsux]+\\)"
+    },
+    "regexp-escape-special": {
+      "name": "support.other.escape.special.regexp",
+      "match": "\\\\([AbBdDsSwWZ])"
+    },
+    "regexp-escape-character": {
+      "name": "constant.character.escape.regexp",
+      "match": "(?x)\n  \\\\ (\n        x[0-9A-Fa-f]{2}\n        | 0[0-7]{1,2}\n        | [0-7]{3}\n     )\n"
+    },
+    "regexp-escape-unicode": {
+      "name": "constant.character.unicode.regexp",
+      "match": "(?x)\n  \\\\ (\n        u[0-9A-Fa-f]{4}\n        | U[0-9A-Fa-f]{8}\n     )\n"
+    },
+    "regexp-escape-catchall": {
+      "name": "constant.character.escape.regexp",
+      "match": "\\\\(.|\\n)"
+    },
+    "regexp-escape-sequence": {
+      "patterns": [
+        {
+          "include": "#regexp-escape-special"
+        },
+        {
+          "include": "#regexp-escape-character"
+        },
+        {
+          "include": "#regexp-escape-unicode"
+        },
+        {
+          "include": "#regexp-backreference-number"
+        },
+        {
+          "include": "#regexp-escape-catchall"
+        }
+      ]
+    },
+    "regexp-charecter-set-escapes": {
+      "patterns": [
+        {
+          "name": "constant.character.escape.regexp",
+          "match": "\\\\[abfnrtv\\\\]"
+        },
+        {
+          "include": "#regexp-escape-special"
+        },
+        {
+          "name": "constant.character.escape.regexp",
+          "match": "\\\\([0-7]{1,3})"
+        },
+        {
+          "include": "#regexp-escape-character"
+        },
+        {
+          "include": "#regexp-escape-unicode"
+        },
+        {
+          "include": "#regexp-escape-catchall"
+        }
+      ]
+    },
+    "comments-base": {
+      "name": "comment.line.number-sign.python",
+      "begin": "(\\#)",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.definition.comment.python"
+        }
+      },
+      "end": "($)",
+      "patterns": [
+        {
+          "include": "#codetags"
+        }
+      ]
+    },
+    "comments-string-single-three": {
+      "name": "comment.line.number-sign.python",
+      "begin": "(\\#)",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.definition.comment.python"
+        }
+      },
+      "end": "($|(?='''))",
+      "patterns": [
+        {
+          "include": "#codetags"
+        }
+      ]
+    },
+    "comments-string-double-three": {
+      "name": "comment.line.number-sign.python",
+      "begin": "(\\#)",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.definition.comment.python"
+        }
+      },
+      "end": "($|(?=\"\"\"))",
+      "patterns": [
+        {
+          "include": "#codetags"
+        }
+      ]
+    },
+    "single-one-regexp-expression": {
+      "patterns": [
+        {
+          "include": "#regexp-base-expression"
+        },
+        {
+          "include": "#single-one-regexp-character-set"
+        },
+        {
+          "include": "#single-one-regexp-comments"
+        },
+        {
+          "include": "#regexp-flags"
+        },
+        {
+          "include": "#single-one-regexp-named-group"
+        },
+        {
+          "include": "#regexp-backreference"
+        },
+        {
+          "include": "#single-one-regexp-lookahead"
+        },
+        {
+          "include": "#single-one-regexp-lookahead-negative"
+        },
+        {
+          "include": "#single-one-regexp-lookbehind"
+        },
+        {
+          "include": "#single-one-regexp-lookbehind-negative"
+        },
+        {
+          "include": "#single-one-regexp-conditional"
+        },
+        {
+          "include": "#single-one-regexp-parentheses-non-capturing"
+        },
+        {
+          "include": "#single-one-regexp-parentheses"
+        }
+      ]
+    },
+    "single-one-regexp-character-set": {
+      "patterns": [
+        {
+          "match": "(?x)\n  \\[ \\^? \\] (?! .*?\\])\n"
+        },
+        {
+          "name": "meta.character.set.regexp",
+          "begin": "(\\[)(\\^)?(\\])?",
+          "end": "(\\]|(?=\\'))|((?=(?<!\\\\)\\n))",
+          "beginCaptures": {
+            "1": {
+              "name": "constant.other.set.regexp punctuation.character.set.begin.regexp"
+            },
+            "2": {
+              "name": "keyword.operator.negation.regexp"
+            },
+            "3": {
+              "name": "constant.character.set.regexp"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "constant.other.set.regexp punctuation.character.set.end.regexp"
+            },
+            "2": {
+              "name": "invalid.illegal.newline.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#regexp-charecter-set-escapes"
+            },
+            {
+              "name": "constant.character.set.regexp",
+              "match": "[^\\n]"
+            }
+          ]
+        }
+      ]
+    },
+    "single-one-regexp-named-group": {
+      "name": "meta.named.regexp",
+      "begin": "(?x)\n  (\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.named.begin.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "entity.name.tag.named.group.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.named.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-one-regexp-expression"
+        }
+      ]
+    },
+    "single-one-regexp-comments": {
+      "name": "comment.regexp",
+      "begin": "\\(\\?#",
+      "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.comment.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.comment.end.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#codetags"
+        }
+      ]
+    },
+    "single-one-regexp-lookahead": {
+      "begin": "(\\()\\?=",
+      "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookahead.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.end.regexp keyword.operator.lookahead.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-one-regexp-expression"
+        }
+      ]
+    },
+    "single-one-regexp-lookahead-negative": {
+      "begin": "(\\()\\?!",
+      "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookahead.negative.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.end.regexp keyword.operator.lookahead.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-one-regexp-expression"
+        }
+      ]
+    },
+    "single-one-regexp-lookbehind": {
+      "begin": "(\\()\\?<=",
+      "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookbehind.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.end.regexp keyword.operator.lookbehind.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-one-regexp-expression"
+        }
+      ]
+    },
+    "single-one-regexp-lookbehind-negative": {
+      "begin": "(\\()\\?<!",
+      "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookbehind.negative.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.end.regexp keyword.operator.lookbehind.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-one-regexp-expression"
+        }
+      ]
+    },
+    "single-one-regexp-conditional": {
+      "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
+      "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.conditional.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.conditional.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.conditional.end.regexp keyword.operator.conditional.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-one-regexp-expression"
+        }
+      ]
+    },
+    "single-one-regexp-parentheses-non-capturing": {
+      "begin": "\\(\\?:",
+      "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.parenthesis.non-capturing.begin.regexp support.other.parenthesis.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.non-capturing.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-one-regexp-expression"
+        }
+      ]
+    },
+    "single-one-regexp-parentheses": {
+      "begin": "\\(",
+      "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.parenthesis.begin.regexp support.other.parenthesis.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-one-regexp-expression"
+        }
+      ]
+    },
+    "single-three-regexp-expression": {
+      "patterns": [
+        {
+          "include": "#regexp-base-expression"
+        },
+        {
+          "include": "#single-three-regexp-character-set"
+        },
+        {
+          "include": "#single-three-regexp-comments"
+        },
+        {
+          "include": "#regexp-flags"
+        },
+        {
+          "include": "#single-three-regexp-named-group"
+        },
+        {
+          "include": "#regexp-backreference"
+        },
+        {
+          "include": "#single-three-regexp-lookahead"
+        },
+        {
+          "include": "#single-three-regexp-lookahead-negative"
+        },
+        {
+          "include": "#single-three-regexp-lookbehind"
+        },
+        {
+          "include": "#single-three-regexp-lookbehind-negative"
+        },
+        {
+          "include": "#single-three-regexp-conditional"
+        },
+        {
+          "include": "#single-three-regexp-parentheses-non-capturing"
+        },
+        {
+          "include": "#single-three-regexp-parentheses"
+        },
+        {
+          "include": "#comments-string-single-three"
+        }
+      ]
+    },
+    "single-three-regexp-character-set": {
+      "patterns": [
+        {
+          "match": "(?x)\n  \\[ \\^? \\] (?! .*?\\])\n"
+        },
+        {
+          "name": "meta.character.set.regexp",
+          "begin": "(\\[)(\\^)?(\\])?",
+          "end": "(\\]|(?=\\'\\'\\'))",
+          "beginCaptures": {
+            "1": {
+              "name": "constant.other.set.regexp punctuation.character.set.begin.regexp"
+            },
+            "2": {
+              "name": "keyword.operator.negation.regexp"
+            },
+            "3": {
+              "name": "constant.character.set.regexp"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "constant.other.set.regexp punctuation.character.set.end.regexp"
+            },
+            "2": {
+              "name": "invalid.illegal.newline.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#regexp-charecter-set-escapes"
+            },
+            {
+              "name": "constant.character.set.regexp",
+              "match": "[^\\n]"
+            }
+          ]
+        }
+      ]
+    },
+    "single-three-regexp-named-group": {
+      "name": "meta.named.regexp",
+      "begin": "(?x)\n  (\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "end": "(\\)|(?=\\'\\'\\'))",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.named.begin.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "entity.name.tag.named.group.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.named.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-single-three"
+        }
+      ]
+    },
+    "single-three-regexp-comments": {
+      "name": "comment.regexp",
+      "begin": "\\(\\?#",
+      "end": "(\\)|(?=\\'\\'\\'))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.comment.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.comment.end.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#codetags"
+        }
+      ]
+    },
+    "single-three-regexp-lookahead": {
+      "begin": "(\\()\\?=",
+      "end": "(\\)|(?=\\'\\'\\'))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookahead.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.end.regexp keyword.operator.lookahead.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-single-three"
+        }
+      ]
+    },
+    "single-three-regexp-lookahead-negative": {
+      "begin": "(\\()\\?!",
+      "end": "(\\)|(?=\\'\\'\\'))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookahead.negative.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.end.regexp keyword.operator.lookahead.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-single-three"
+        }
+      ]
+    },
+    "single-three-regexp-lookbehind": {
+      "begin": "(\\()\\?<=",
+      "end": "(\\)|(?=\\'\\'\\'))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookbehind.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.end.regexp keyword.operator.lookbehind.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-single-three"
+        }
+      ]
+    },
+    "single-three-regexp-lookbehind-negative": {
+      "begin": "(\\()\\?<!",
+      "end": "(\\)|(?=\\'\\'\\'))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookbehind.negative.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.end.regexp keyword.operator.lookbehind.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-single-three"
+        }
+      ]
+    },
+    "single-three-regexp-conditional": {
+      "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
+      "end": "(\\)|(?=\\'\\'\\'))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.conditional.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.conditional.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.conditional.end.regexp keyword.operator.conditional.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-single-three"
+        }
+      ]
+    },
+    "single-three-regexp-parentheses-non-capturing": {
+      "begin": "\\(\\?:",
+      "end": "(\\)|(?=\\'\\'\\'))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.parenthesis.non-capturing.begin.regexp support.other.parenthesis.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.non-capturing.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-single-three"
+        }
+      ]
+    },
+    "single-three-regexp-parentheses": {
+      "begin": "\\(",
+      "end": "(\\)|(?=\\'\\'\\'))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.parenthesis.begin.regexp support.other.parenthesis.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#single-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-single-three"
+        }
+      ]
+    },
+    "double-one-regexp-expression": {
+      "patterns": [
+        {
+          "include": "#regexp-base-expression"
+        },
+        {
+          "include": "#double-one-regexp-character-set"
+        },
+        {
+          "include": "#double-one-regexp-comments"
+        },
+        {
+          "include": "#regexp-flags"
+        },
+        {
+          "include": "#double-one-regexp-named-group"
+        },
+        {
+          "include": "#regexp-backreference"
+        },
+        {
+          "include": "#double-one-regexp-lookahead"
+        },
+        {
+          "include": "#double-one-regexp-lookahead-negative"
+        },
+        {
+          "include": "#double-one-regexp-lookbehind"
+        },
+        {
+          "include": "#double-one-regexp-lookbehind-negative"
+        },
+        {
+          "include": "#double-one-regexp-conditional"
+        },
+        {
+          "include": "#double-one-regexp-parentheses-non-capturing"
+        },
+        {
+          "include": "#double-one-regexp-parentheses"
+        }
+      ]
+    },
+    "double-one-regexp-character-set": {
+      "patterns": [
+        {
+          "match": "(?x)\n  \\[ \\^? \\] (?! .*?\\])\n"
+        },
+        {
+          "name": "meta.character.set.regexp",
+          "begin": "(\\[)(\\^)?(\\])?",
+          "end": "(\\]|(?=\"))|((?=(?<!\\\\)\\n))",
+          "beginCaptures": {
+            "1": {
+              "name": "constant.other.set.regexp punctuation.character.set.begin.regexp"
+            },
+            "2": {
+              "name": "keyword.operator.negation.regexp"
+            },
+            "3": {
+              "name": "constant.character.set.regexp"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "constant.other.set.regexp punctuation.character.set.end.regexp"
+            },
+            "2": {
+              "name": "invalid.illegal.newline.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#regexp-charecter-set-escapes"
+            },
+            {
+              "name": "constant.character.set.regexp",
+              "match": "[^\\n]"
+            }
+          ]
+        }
+      ]
+    },
+    "double-one-regexp-named-group": {
+      "name": "meta.named.regexp",
+      "begin": "(?x)\n  (\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.named.begin.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "entity.name.tag.named.group.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.named.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-one-regexp-expression"
+        }
+      ]
+    },
+    "double-one-regexp-comments": {
+      "name": "comment.regexp",
+      "begin": "\\(\\?#",
+      "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.comment.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.comment.end.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#codetags"
+        }
+      ]
+    },
+    "double-one-regexp-lookahead": {
+      "begin": "(\\()\\?=",
+      "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookahead.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.end.regexp keyword.operator.lookahead.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-one-regexp-expression"
+        }
+      ]
+    },
+    "double-one-regexp-lookahead-negative": {
+      "begin": "(\\()\\?!",
+      "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookahead.negative.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.end.regexp keyword.operator.lookahead.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-one-regexp-expression"
+        }
+      ]
+    },
+    "double-one-regexp-lookbehind": {
+      "begin": "(\\()\\?<=",
+      "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookbehind.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.end.regexp keyword.operator.lookbehind.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-one-regexp-expression"
+        }
+      ]
+    },
+    "double-one-regexp-lookbehind-negative": {
+      "begin": "(\\()\\?<!",
+      "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookbehind.negative.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.end.regexp keyword.operator.lookbehind.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-one-regexp-expression"
+        }
+      ]
+    },
+    "double-one-regexp-conditional": {
+      "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
+      "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.conditional.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.conditional.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.conditional.end.regexp keyword.operator.conditional.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-one-regexp-expression"
+        }
+      ]
+    },
+    "double-one-regexp-parentheses-non-capturing": {
+      "begin": "\\(\\?:",
+      "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.parenthesis.non-capturing.begin.regexp support.other.parenthesis.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.non-capturing.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-one-regexp-expression"
+        }
+      ]
+    },
+    "double-one-regexp-parentheses": {
+      "begin": "\\(",
+      "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.parenthesis.begin.regexp support.other.parenthesis.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-one-regexp-expression"
+        }
+      ]
+    },
+    "double-three-regexp-expression": {
+      "patterns": [
+        {
+          "include": "#regexp-base-expression"
+        },
+        {
+          "include": "#double-three-regexp-character-set"
+        },
+        {
+          "include": "#double-three-regexp-comments"
+        },
+        {
+          "include": "#regexp-flags"
+        },
+        {
+          "include": "#double-three-regexp-named-group"
+        },
+        {
+          "include": "#regexp-backreference"
+        },
+        {
+          "include": "#double-three-regexp-lookahead"
+        },
+        {
+          "include": "#double-three-regexp-lookahead-negative"
+        },
+        {
+          "include": "#double-three-regexp-lookbehind"
+        },
+        {
+          "include": "#double-three-regexp-lookbehind-negative"
+        },
+        {
+          "include": "#double-three-regexp-conditional"
+        },
+        {
+          "include": "#double-three-regexp-parentheses-non-capturing"
+        },
+        {
+          "include": "#double-three-regexp-parentheses"
+        },
+        {
+          "include": "#comments-string-double-three"
+        }
+      ]
+    },
+    "double-three-regexp-character-set": {
+      "patterns": [
+        {
+          "match": "(?x)\n  \\[ \\^? \\] (?! .*?\\])\n"
+        },
+        {
+          "name": "meta.character.set.regexp",
+          "begin": "(\\[)(\\^)?(\\])?",
+          "end": "(\\]|(?=\"\"\"))",
+          "beginCaptures": {
+            "1": {
+              "name": "constant.other.set.regexp punctuation.character.set.begin.regexp"
+            },
+            "2": {
+              "name": "keyword.operator.negation.regexp"
+            },
+            "3": {
+              "name": "constant.character.set.regexp"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "constant.other.set.regexp punctuation.character.set.end.regexp"
+            },
+            "2": {
+              "name": "invalid.illegal.newline.python"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#regexp-charecter-set-escapes"
+            },
+            {
+              "name": "constant.character.set.regexp",
+              "match": "[^\\n]"
+            }
+          ]
+        }
+      ]
+    },
+    "double-three-regexp-named-group": {
+      "name": "meta.named.regexp",
+      "begin": "(?x)\n  (\\()  (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n",
+      "end": "(\\)|(?=\"\"\"))",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.named.begin.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "entity.name.tag.named.group.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.named.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-double-three"
+        }
+      ]
+    },
+    "double-three-regexp-comments": {
+      "name": "comment.regexp",
+      "begin": "\\(\\?#",
+      "end": "(\\)|(?=\"\"\"))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.comment.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.comment.end.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#codetags"
+        }
+      ]
+    },
+    "double-three-regexp-lookahead": {
+      "begin": "(\\()\\?=",
+      "end": "(\\)|(?=\"\"\"))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookahead.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.end.regexp keyword.operator.lookahead.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-double-three"
+        }
+      ]
+    },
+    "double-three-regexp-lookahead-negative": {
+      "begin": "(\\()\\?!",
+      "end": "(\\)|(?=\"\"\"))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookahead.negative.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookahead.end.regexp keyword.operator.lookahead.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-double-three"
+        }
+      ]
+    },
+    "double-three-regexp-lookbehind": {
+      "begin": "(\\()\\?<=",
+      "end": "(\\)|(?=\"\"\"))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookbehind.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.end.regexp keyword.operator.lookbehind.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-double-three"
+        }
+      ]
+    },
+    "double-three-regexp-lookbehind-negative": {
+      "begin": "(\\()\\?<!",
+      "end": "(\\)|(?=\"\"\"))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.lookbehind.negative.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.lookbehind.end.regexp keyword.operator.lookbehind.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-double-three"
+        }
+      ]
+    },
+    "double-three-regexp-conditional": {
+      "begin": "(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)",
+      "end": "(\\)|(?=\"\"\"))",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.operator.conditional.regexp"
+        },
+        "1": {
+          "name": "punctuation.parenthesis.conditional.begin.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.conditional.end.regexp keyword.operator.conditional.negative.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-double-three"
+        }
+      ]
+    },
+    "double-three-regexp-parentheses-non-capturing": {
+      "begin": "\\(\\?:",
+      "end": "(\\)|(?=\"\"\"))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.parenthesis.non-capturing.begin.regexp support.other.parenthesis.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.non-capturing.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-double-three"
+        }
+      ]
+    },
+    "double-three-regexp-parentheses": {
+      "begin": "\\(",
+      "end": "(\\)|(?=\"\"\"))",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.parenthesis.begin.regexp support.other.parenthesis.regexp"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.end.regexp support.other.parenthesis.regexp"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#double-three-regexp-expression"
+        },
+        {
+          "include": "#comments-string-double-three"
+        }
+      ]
+    },
+    "string-raw-quoted-single-line": {
+      "name": "string.quoted.raw.single.python",
+      "begin": "\\b(([uU]R)|(R))((['\"]))",
+      "end": "(\\4)|((?<!\\\\)\\n)",
+      "beginCaptures": {
+        "2": {
+          "name": "invalid.deprecated.prefix.python"
+        },
+        "3": {
+          "name": "storage.type.string.python"
+        },
+        "4": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#string-single-bad-brace1-formatting-raw"
+        },
+        {
+          "include": "#string-single-bad-brace2-formatting-raw"
+        },
+        {
+          "include": "#string-raw-guts"
+        }
+      ]
+    },
+    "string-bin-quoted-single-line": {
+      "name": "string.quoted.binary.single.python",
+      "begin": "(\\b[bB])((['\"]))",
+      "end": "(\\2)|((?<!\\\\)\\n)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.string.python"
+        },
+        "2": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#string-entity"
+        }
+      ]
+    },
+    "string-raw-bin-quoted-single-line": {
+      "name": "string.quoted.raw.binary.single.python",
+      "begin": "(\\b(?:R[bB]|[bB]R))((['\"]))",
+      "end": "(\\2)|((?<!\\\\)\\n)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.string.python"
+        },
+        "2": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#string-raw-bin-guts"
+        }
+      ]
+    },
+    "string-quoted-single-line": {
+      "name": "string.quoted.single.python",
+      "begin": "(\\b[rR](?=[uU]))?([uU])?((['\"]))",
+      "end": "(\\3)|((?<!\\\\)\\n)",
+      "beginCaptures": {
+        "1": {
+          "name": "invalid.illegal.prefix.python"
+        },
+        "2": {
+          "name": "storage.type.string.python"
+        },
+        "3": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#string-single-bad-brace1-formatting-unicode"
+        },
+        {
+          "include": "#string-single-bad-brace2-formatting-unicode"
+        },
+        {
+          "include": "#string-unicode-guts"
+        }
+      ]
+    },
+    "string-single-bad-brace1-formatting-unicode": {
+      "comment": "template using {% ... %}",
+      "begin": "(?x)\n    (?= \\{%\n          ( .*? (?!(['\"])|((?<!\\\\)\\n)) )\n        %\\}\n    )\n",
+      "end": "(?=(['\"])|((?<!\\\\)\\n))",
+      "patterns": [
+        {
+          "include": "#escape-sequence-unicode"
+        },
+        {
+          "include": "#escape-sequence"
+        },
+        {
+          "include": "#string-line-continuation"
+        }
+      ]
+    },
+    "string-single-bad-brace1-formatting-raw": {
+      "comment": "template using {% ... %}",
+      "begin": "(?x)\n    (?= \\{%\n          ( .*? (?!(['\"])|((?<!\\\\)\\n)) )\n        %\\}\n    )\n",
+      "end": "(?=(['\"])|((?<!\\\\)\\n))",
+      "patterns": [
+        {
+          "include": "#string-consume-escape"
+        }
+      ]
+    },
+    "string-single-bad-brace2-formatting-unicode": {
+      "comment": "odd format or format-like syntax",
+      "begin": "(?x)\n    (?!\\{\\{)\n    (?= \\{ (\n              \\w*? (?!(['\"])|((?<!\\\\)\\n)) [^!:\\.\\[}\\w]\n           )\n        .*?(?!(['\"])|((?<!\\\\)\\n))\n        \\}\n    )\n",
+      "end": "(?=(['\"])|((?<!\\\\)\\n))",
+      "patterns": [
+        {
+          "include": "#escape-sequence-unicode"
+        },
+        {
+          "include": "#string-entity"
+        }
+      ]
+    },
+    "string-single-bad-brace2-formatting-raw": {
+      "comment": "odd format or format-like syntax",
+      "begin": "(?x)\n    (?!\\{\\{)\n    (?= \\{ (\n              \\w*? (?!(['\"])|((?<!\\\\)\\n)) [^!:\\.\\[}\\w]\n           )\n        .*?(?!(['\"])|((?<!\\\\)\\n))\n        \\}\n    )\n",
+      "end": "(?=(['\"])|((?<!\\\\)\\n))",
+      "patterns": [
+        {
+          "include": "#string-consume-escape"
+        },
+        {
+          "include": "#string-formatting"
+        }
+      ]
+    },
+    "string-raw-quoted-multi-line": {
+      "name": "string.quoted.raw.multi.python",
+      "begin": "\\b(([uU]R)|(R))('''|\"\"\")",
+      "end": "(\\4)",
+      "beginCaptures": {
+        "2": {
+          "name": "invalid.deprecated.prefix.python"
+        },
+        "3": {
+          "name": "storage.type.string.python"
+        },
+        "4": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#string-multi-bad-brace1-formatting-raw"
+        },
+        {
+          "include": "#string-multi-bad-brace2-formatting-raw"
+        },
+        {
+          "include": "#string-raw-guts"
+        }
+      ]
+    },
+    "string-bin-quoted-multi-line": {
+      "name": "string.quoted.binary.multi.python",
+      "begin": "(\\b[bB])('''|\"\"\")",
+      "end": "(\\2)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.string.python"
+        },
+        "2": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#string-entity"
+        }
+      ]
+    },
+    "string-raw-bin-quoted-multi-line": {
+      "name": "string.quoted.raw.binary.multi.python",
+      "begin": "(\\b(?:R[bB]|[bB]R))('''|\"\"\")",
+      "end": "(\\2)",
+      "beginCaptures": {
+        "1": {
+          "name": "storage.type.string.python"
+        },
+        "2": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#string-raw-bin-guts"
+        }
+      ]
+    },
+    "string-quoted-multi-line": {
+      "name": "string.quoted.multi.python",
+      "begin": "(\\b[rR](?=[uU]))?([uU])?('''|\"\"\")",
+      "end": "(\\3)",
+      "beginCaptures": {
+        "1": {
+          "name": "invalid.illegal.prefix.python"
+        },
+        "2": {
+          "name": "storage.type.string.python"
+        },
+        "3": {
+          "name": "punctuation.definition.string.begin.python"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.python"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.python"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#string-multi-bad-brace1-formatting-unicode"
+        },
+        {
+          "include": "#string-multi-bad-brace2-formatting-unicode"
+        },
+        {
+          "include": "#string-unicode-guts"
+        }
+      ]
+    },
+    "string-multi-bad-brace1-formatting-unicode": {
+      "comment": "template using {% ... %}",
+      "begin": "(?x)\n    (?= \\{%\n          ( .*? (?!'''|\"\"\") )\n        %\\}\n    )\n",
+      "end": "(?='''|\"\"\")",
+      "patterns": [
+        {
+          "include": "#escape-sequence-unicode"
+        },
+        {
+          "include": "#escape-sequence"
+        },
+        {
+          "include": "#string-line-continuation"
+        }
+      ]
+    },
+    "string-multi-bad-brace1-formatting-raw": {
+      "comment": "template using {% ... %}",
+      "begin": "(?x)\n    (?= \\{%\n          ( .*? (?!'''|\"\"\") )\n        %\\}\n    )\n",
+      "end": "(?='''|\"\"\")",
+      "patterns": [
+        {
+          "include": "#string-consume-escape"
+        }
+      ]
+    },
+    "string-multi-bad-brace2-formatting-unicode": {
+      "comment": "odd format or format-like syntax",
+      "begin": "(?x)\n    (?!\\{\\{)\n    (?= \\{ (\n              \\w*? (?!'''|\"\"\") [^!:\\.\\[}\\w]\n           )\n        .*?(?!'''|\"\"\")\n        \\}\n    )\n",
+      "end": "(?='''|\"\"\")",
+      "patterns": [
+        {
+          "include": "#escape-sequence-unicode"
+        },
+        {
+          "include": "#string-entity"
+        }
+      ]
+    },
+    "string-multi-bad-brace2-formatting-raw": {
+      "comment": "odd format or format-like syntax",
+      "begin": "(?x)\n    (?!\\{\\{)\n    (?= \\{ (\n              \\w*? (?!'''|\"\"\") [^!:\\.\\[}\\w]\n           )\n        .*?(?!'''|\"\"\")\n        \\}\n    )\n",
+      "end": "(?='''|\"\"\")",
+      "patterns": [
+        {
+          "include": "#string-consume-escape"
+        },
+        {
+          "include": "#string-formatting"
+        }
+      ]
+    }
+  }
+}