diff --git a/.prettierignore b/.prettierignore
index fc48334..0c84c50 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -3,4 +3,7 @@
 **/dist
 
 # Ignore all markdown files:
-*.md
\ No newline at end of file
+*.md
+
+# Ignore all generated typescript files:
+*.g.ts
\ No newline at end of file
diff --git a/examples/tokenizer_tests.rpy b/examples/tokenizer_tests.rpy
new file mode 100644
index 0000000..0007513
--- /dev/null
+++ b/examples/tokenizer_tests.rpy
@@ -0,0 +1,24 @@
+init python hide early in Namespace:
+
+    def sampleFunction(name, delay, position=(0,0)):
+        """
+        This is a sample function.
+        """
+# test
+        renpy.pause(delay)
+        return name
+
+    class Inventory:
+        """
+        This is a fake inventory class.
+        """
+
+        def __init__(self):
+            self.items = []
+
+        def add(self, item):
+            """Add an item to the inventory."""
+            self.items.append(item);
+            return
+
+        
\ No newline at end of file
diff --git a/examples/unit_test.rpy b/examples/unit_test.rpy
index c165657..fe4a663 100644
--- a/examples/unit_test.rpy
+++ b/examples/unit_test.rpy
@@ -837,7 +837,7 @@
         queue sound "woof.mp3" volume 0.75
         queue sound "woof.mp3" volume 1.0
 
-        define audio.woof = "woof.mp23
+        define audio.woof = "woof.mp3"
 
         # ...
 
@@ -1853,7 +1853,7 @@
         image big hello world = Text("Hello World", style="big")
 
         screen hello_world:
-            text "Hello, World" style "big"
+            text "Hello, World" style "big" at 0# Comment
 
         style my_text is text:
             size 40
@@ -3555,9 +3555,9 @@
     #region Customizing the Keymap
         # see https://www.renpy.org/doc/html/keymap.html
         
-        init:
-            $ config.keymap['dismiss'].append('t')
-            $ config.keymap['dismiss'].remove('K_SPACE')
+        init python:
+            config.keymap['dismiss'].append('t')
+            config.keymap['dismiss'].remove('K_SPACE')
 
             config.keymap = dict(
 
@@ -3678,59 +3678,59 @@
 
             )
 
-        config.pad_bindings = {
-            "pad_leftshoulder_press" : [ "rollback", ],
-            "pad_lefttrigger_pos" : [ "rollback", ],
-            "pad_back_press" : [ "rollback", ],
+            config.pad_bindings = {
+                "pad_leftshoulder_press" : [ "rollback", ],
+                "pad_lefttrigger_pos" : [ "rollback", ],
+                "pad_back_press" : [ "rollback", ],
 
-            "repeat_pad_leftshoulder_press" : [ "rollback", ],
-            "repeat_pad_lefttrigger_pos" : [ "rollback", ],
-            "repeat_pad_back_press" : [ "rollback", ],
+                "repeat_pad_leftshoulder_press" : [ "rollback", ],
+                "repeat_pad_lefttrigger_pos" : [ "rollback", ],
+                "repeat_pad_back_press" : [ "rollback", ],
 
-            "pad_guide_press" : [ "game_menu", ],
-            "pad_start_press" : [ "game_menu", ],
+                "pad_guide_press" : [ "game_menu", ],
+                "pad_start_press" : [ "game_menu", ],
 
-            "pad_y_press" : [ "hide_windows", ],
+                "pad_y_press" : [ "hide_windows", ],
 
-            "pad_rightshoulder_press" : [ "rollforward", ],
-            "repeat_pad_rightshoulder_press" : [ "rollforward", ],
+                "pad_rightshoulder_press" : [ "rollforward", ],
+                "repeat_pad_rightshoulder_press" : [ "rollforward", ],
 
-            "pad_righttrigger_pos" : [ "dismiss", "button_select", "bar_activate", "bar_deactivate" ],
-            "pad_a_press" : [ "dismiss", "button_select", "bar_activate", "bar_deactivate"],
-            "pad_b_press" : [ "button_alternate" ],
+                "pad_righttrigger_pos" : [ "dismiss", "button_select", "bar_activate", "bar_deactivate" ],
+                "pad_a_press" : [ "dismiss", "button_select", "bar_activate", "bar_deactivate"],
+                "pad_b_press" : [ "button_alternate" ],
 
-            "pad_dpleft_press" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
-            "pad_leftx_neg" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
-            "pad_rightx_neg" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
+                "pad_dpleft_press" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
+                "pad_leftx_neg" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
+                "pad_rightx_neg" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
 
-            "pad_dpright_press" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
-            "pad_leftx_pos" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
-            "pad_rightx_pos" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
+                "pad_dpright_press" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
+                "pad_leftx_pos" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
+                "pad_rightx_pos" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
 
-            "pad_dpup_press" : [ "focus_up", "bar_up", "viewport_uparrow" ],
-            "pad_lefty_neg" : [ "focus_up", "bar_up", "viewport_uparrow" ],
-            "pad_righty_neg" : [ "focus_up", "bar_up", "viewport_uparrow" ],
+                "pad_dpup_press" : [ "focus_up", "bar_up", "viewport_uparrow" ],
+                "pad_lefty_neg" : [ "focus_up", "bar_up", "viewport_uparrow" ],
+                "pad_righty_neg" : [ "focus_up", "bar_up", "viewport_uparrow" ],
 
-            "pad_dpdown_press" : [ "focus_down", "bar_down", "viewport_downarrow" ],
-            "pad_lefty_pos" : [ "focus_down", "bar_down", "viewport_downarrow" ],
-            "pad_righty_pos" : [ "focus_down", "bar_down", "viewport_downarrow" ],
+                "pad_dpdown_press" : [ "focus_down", "bar_down", "viewport_downarrow" ],
+                "pad_lefty_pos" : [ "focus_down", "bar_down", "viewport_downarrow" ],
+                "pad_righty_pos" : [ "focus_down", "bar_down", "viewport_downarrow" ],
 
-            "repeat_pad_dpleft_press" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
-            "repeat_pad_leftx_neg" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
-            "repeat_pad_rightx_neg" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
+                "repeat_pad_dpleft_press" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
+                "repeat_pad_leftx_neg" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
+                "repeat_pad_rightx_neg" : [ "focus_left", "bar_left", "viewport_leftarrow" ],
 
-            "repeat_pad_dpright_press" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
-            "repeat_pad_leftx_pos" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
-            "repeat_pad_rightx_pos" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
+                "repeat_pad_dpright_press" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
+                "repeat_pad_leftx_pos" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
+                "repeat_pad_rightx_pos" : [ "focus_right", "bar_right", "viewport_rightarrow" ],
 
-            "repeat_pad_dpup_press" : [ "focus_up", "bar_up", "viewport_uparrow" ],
-            "repeat_pad_lefty_neg" : [ "focus_up", "bar_up", "viewport_uparrow" ],
-            "repeat_pad_righty_neg" : [ "focus_up", "bar_up", "viewport_uparrow" ],
+                "repeat_pad_dpup_press" : [ "focus_up", "bar_up", "viewport_uparrow" ],
+                "repeat_pad_lefty_neg" : [ "focus_up", "bar_up", "viewport_uparrow" ],
+                "repeat_pad_righty_neg" : [ "focus_up", "bar_up", "viewport_uparrow" ],
 
-            "repeat_pad_dpdown_press" : [ "focus_down", "bar_down", "viewport_downarrow" ],
-            "repeat_pad_lefty_pos" : [ "focus_down", "bar_down", "viewport_downarrow" ],
-            "repeat_pad_righty_pos" : [ "focus_down", "bar_down", "viewport_downarrow" ],
-        }
+                "repeat_pad_dpdown_press" : [ "focus_down", "bar_down", "viewport_downarrow" ],
+                "repeat_pad_lefty_pos" : [ "focus_down", "bar_down", "viewport_downarrow" ],
+                "repeat_pad_righty_pos" : [ "focus_down", "bar_down", "viewport_downarrow" ],
+            }
 
     #endregion Customizing the Keymap
 
diff --git a/package.json b/package.json
index 9e701c9..6741b33 100644
--- a/package.json
+++ b/package.json
@@ -71,6 +71,10 @@
       {
         "scopeName": "source.renpy.python",
         "path": "./syntaxes/renpy.python.tmLanguage.json"
+      },
+      {
+        "scopeName": "source.renpy.atl",
+        "path": "./syntaxes/renpy.atl.tmLanguage.json"
       }
     ],
     "snippets": [
diff --git a/src/color.ts b/src/color.ts
index 86dcd0e..4f21263 100644
--- a/src/color.ts
+++ b/src/color.ts
@@ -1,9 +1,13 @@
 // Color conversion methods for Color provider
 import { CancellationToken, Color, ColorInformation, ColorPresentation, DocumentColorProvider, Range, TextDocument, TextEdit } from "vscode";
+import { ValueEqualsSet } from "./utilities/hashset";
+import { tokenizeDocument } from "./tokenizer/tokenizer";
+import { LiteralTokenType } from "./tokenizer/renpy-tokens";
+import { TextMateRule, injectCustomTextmateTokens } from "./decorator";
+/*import { tokenizeDocument } from "./tokenizer/tokenizer";
 import { injectCustomTextmateTokens, TextMateRule } from "./decorator";
 import { LiteralTokenType } from "./tokenizer/renpy-tokens";
-import { tokenizeDocument } from "./tokenizer/tokenizer";
-import { ValueEqualsSet } from "./utilities/hashset";
+import { ValueEqualsSet } from "./utilities/hashset";*/
 
 export class RenpyColorProvider implements DocumentColorProvider {
     public provideDocumentColors(document: TextDocument, token: CancellationToken): Thenable<ColorInformation[]> {
@@ -112,15 +116,15 @@ export function getColorPresentations(color: Color, document: TextDocument, rang
 }
 
 export function injectCustomColorStyles(document: TextDocument) {
+    // Disabled until filter is added to the tree class
     const documentTokens = tokenizeDocument(document);
-
     // TODO: Should probably make sure this constant is actually part of a tag, but for now this is fine.
-    const colorTags = documentTokens.filter((x) => x.tokenType === LiteralTokenType.Color);
+    const colorTags = documentTokens.filter((x) => x.token?.tokenType === LiteralTokenType.Color);
     const colorRules = new ValueEqualsSet<TextMateRule>();
 
     // Build the new rules for this file
-    colorTags.forEach((color) => {
-        const lowerColor = document.getText(color.getRange()).toLowerCase();
+    colorTags.forEach((colorNode) => {
+        const lowerColor = document.getText(colorNode.token?.getVSCodeRange()).toLowerCase();
         const newRule = new TextMateRule(`renpy.meta.color.${lowerColor}`, { foreground: lowerColor });
         colorRules.add(newRule);
     });
diff --git a/src/tokenizer/atl-token-patterns.g.ts b/src/tokenizer/atl-token-patterns.g.ts
new file mode 100644
index 0000000..acbad44
--- /dev/null
+++ b/src/tokenizer/atl-token-patterns.g.ts
@@ -0,0 +1,399 @@
+/* eslint-disable no-useless-escape */
+/* eslint-disable no-useless-backreference */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+// THIS FILE HAS BEEN GENERATED BY THE `syntax-to-token-pattern.py` GENERATOR
+// DO NOT EDIT THIS FILE DIRECTLY! INSTEAD RUN THE PYTHON SCRIPT.
+// ANY MANUAL EDITS MADE TO THIS FILE WILL BE OVERWRITTEN. YOU HAVE BEEN WARNED.
+// Last generated: 01/06/2023 14:57:48 (UTC+0)
+
+import { KeywordTokenType, EntityTokenType, MetaTokenType, CharacterTokenType } from "./renpy-tokens";
+import { TokenPattern } from "./token-pattern-types";
+
+export const atl: TokenPattern = {
+    // https://www.renpy.org/doc/html/atl.html#atl-syntax-and-semantics
+    patterns: [
+    ]
+};
+
+export const atlBuildInProperties: TokenPattern = {
+    // https://www.renpy.org/doc/html/atl.html#list-of-transform-properties
+    patterns: [
+        {
+            debugName: "atlBuildInProperties.patterns![0]",
+
+            // Special manipulation keywords
+            match: /\b(?<!\.)(?:(warp)|(circles)|(clockwise)|(counterclockwise))\b/dg,
+            captures: {
+                1: { token: KeywordTokenType.Warp, /*keyword.warp.renpy*/ },
+                2: { token: KeywordTokenType.Circles, /*keyword.circles.renpy*/ },
+                3: { token: KeywordTokenType.Clockwise, /*keyword.clockwise.renpy*/ },
+                4: { token: KeywordTokenType.Counterclockwise, /*keyword.counterclockwise.renpy*/ },
+            },
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![1]",
+
+            // position props (int, absolute, or a float)
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:xpos|ypos|xanchor|yanchor|xcenter|ycenter|radius)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![2]",
+
+            // position pair props
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:pos|anchor|xycenter|around|alignaround|matrixanchor)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![3]",
+
+            // float props
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:xalign|yalign|zoom|xzoom|yzoom|alpha|additive|angle|delay|events|zpos)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![4]",
+
+            // float pair props
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:align|knot)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![5]",
+
+            // int props
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:xoffset|yoffset|xtile|ytile)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![6]",
+
+            // int pair props
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:offset)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![7]",
+
+            // boolean props
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:rotate_pad|transform_anchor|nearest|crop_relative|subpixel|zzoom)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![8]",
+
+            // ('#float' | None)
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:rotate|xpan|ypan|blur)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![9]",
+
+            // ('#position' | None)
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:xsize|ysize)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![10]",
+
+            // ('\(int, int, int, int\)' | '\(float, float, float, float\)' | None)
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:crop)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![11]",
+
+            // ('\(int, int\)' | None)
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:corner1|corner2)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![12]",
+
+            // ('\(position, position\)' | None)
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:xysize)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![13]",
+
+            // ('#string' | None)
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:fit)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![14]",
+
+            // ('\(int, int\)' | None)
+            token: MetaTokenType.Deprecated, /*invalid.deprecated.renpy*/
+            match: /\b(?<!\.)(?:size|maxsize)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![15]",
+
+            // ('#Matrix' | '#MatrixColor' | None)
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:matrixcolor)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![16]",
+
+            // ('#Matrix' | '#TransformMatrix' | None)
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:matrixtransform)\b/g,
+        },
+        {
+            debugName: "atlBuildInProperties.patterns![17]",
+
+            // ('#bool' | '#float' | '\(float, float, float\)')
+            token: EntityTokenType.PropertyName, /*support.type.property-name.transform.renpy*/
+            match: /\b(?<!\.)(?:perspective)\b/g,
+        },
+    ]
+};
+
+export const atlSimpleExpression: TokenPattern = {
+    patterns: [atlBuildInProperties]
+};
+
+export const atlExpression: TokenPattern = {
+    // https://www.renpy.org/doc/html/atl.html#expression-statement
+    patterns: [
+        atlSimpleExpression,
+        {
+            debugName: "atlExpression.patterns![1]",
+
+            begin: /\b(with)\b[ \t]*/dg,
+            beginCaptures: {
+                1: { token: KeywordTokenType.With, /*keyword.with.renpy*/ },
+            },
+            end: /$/gm,
+            patterns: [atlSimpleExpression]
+        },
+    ]
+};
+
+export const atlKeywords: TokenPattern = {
+    patterns: [
+        {
+            debugName: "atlKeywords.patterns![0]",
+
+            // https://www.renpy.org/doc/html/atl.html#animation-statement
+            match: /^[ \t]*(animation)\b/dgm,
+            captures: {
+                1: { token: KeywordTokenType.Animation, /*keyword.animation.renpy*/ },
+            },
+        },
+        {
+            debugName: "atlKeywords.patterns![1]",
+
+            // https://www.renpy.org/doc/html/atl.html#pass-statement
+            match: /^[ \t]*(pass)\b/dgm,
+            captures: {
+                1: { token: KeywordTokenType.Pass, /*keyword.control.flow.pass.renpy*/ },
+            },
+        },
+        {
+            debugName: "atlKeywords.patterns![2]",
+
+            // https://www.renpy.org/doc/html/atl.html#repeat-statement and https://www.renpy.org/doc/html/atl.html#time-statement
+            begin: /^[ \t]*(?:(repeat)|(time)|(pause))\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Repeat, /*keyword.control.flow.repeat.renpy*/ },
+                2: { token: KeywordTokenType.Time, /*keyword.control.flow.time.renpy*/ },
+                3: { token: KeywordTokenType.Pause, /*keyword.control.flow.pause.renpy*/ },
+            },
+            end: /$/gm,
+            patterns: [atlSimpleExpression]
+        },
+        {
+            debugName: "atlKeywords.patterns![3]",
+
+            // https://www.renpy.org/doc/html/atl.html#expression-statement
+            contentToken: MetaTokenType.ATLWith, /*meta.atl.with.renpy*/
+            begin: /^[ \t]*(with)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.With, /*keyword.with.renpy*/ },
+            },
+            end: /$/gm,
+            patterns: [atlSimpleExpression]
+        },
+        {
+            debugName: "atlKeywords.patterns![4]",
+
+            // https://www.renpy.org/doc/html/atl.html#contains-statement
+            contentToken: MetaTokenType.ATLContains, /*meta.atl.contains.renpy*/
+            begin: /^[ \t]*(contains)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Contains, /*keyword.control.flow.contains.renpy*/ },
+            },
+            end: /$/gm,
+            patterns: [atlExpression]
+        },
+    ]
+};
+
+export const atlBlocks: TokenPattern = {
+    patterns: [
+        {
+            debugName: "atlBlocks.patterns![0]",
+
+            // See https://www.renpy.org/doc/html/atl.html
+            contentToken: MetaTokenType.ATLBlock, /*meta.atl.block.renpy*/
+            begin: /^([ \t]+)?(?:(block)|(parallel)|(contains))\b[ \t]*(:)/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.block.renpy*/ },
+                2: { token: KeywordTokenType.Block, /*keyword.block.renpy*/ },
+                3: { token: KeywordTokenType.Parallel, /*keyword.parallel.renpy*/ },
+                4: { token: KeywordTokenType.Contains, /*keyword.contains.renpy*/ },
+                5: { token: CharacterTokenType.Colon, /*punctuation.section.block.begin.renpy*/ },
+            },
+            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+            patterns: [atl]
+        },
+        {
+            debugName: "atlBlocks.patterns![1]",
+
+            // https://www.renpy.org/doc/html/atl.html#choice-statement
+            contentToken: MetaTokenType.ATLChoiceBlock, /*meta.atl.choice.block.renpy*/
+            begin: /^([ \t]+)?(choice)\b[ \t]*(.+)?(:)/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.block.renpy*/ },
+                2: { token: KeywordTokenType.Choice, /*keyword.choice.renpy*/ },
+                3: { patterns: [atlSimpleExpression] },
+                4: { token: CharacterTokenType.Colon, /*punctuation.section.block.begin.renpy*/ },
+            },
+            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+            patterns: [atl]
+        },
+    ]
+};
+
+export const atlBuildInEvents: TokenPattern = {
+    debugName: "atlBuildInEvents",
+
+    // Pre-defined events (https://www.renpy.org/doc/html/atl.html#external-events)
+    token: EntityTokenType.EventName, /*support.function.event.renpy*/
+    match: /\b(?<!\.)(?:start|show|replace|hide|replaced|update|hover|idle|selected_hover|selected_idle)\b/g,
+};
+
+export const atlEventName: TokenPattern = {
+    patterns: [
+        atlBuildInEvents,
+        {
+            debugName: "atlEventName.patterns![2]",
+
+            token: MetaTokenType.FunctionCall, /*entity.name.function.renpy meta.function-call.generic.renpy*/
+            match: /\b([a-zA-Z_]\w*)\b/g,
+        },
+    ]
+};
+
+export const atlEventDefName: TokenPattern = {
+    patterns: [
+        atlBuildInEvents,
+        {
+            debugName: "atlEventDefName.patterns![2]",
+
+            token: EntityTokenType.FunctionName, /*entity.name.function.renpy*/
+            match: /\b([a-zA-Z_]\w*)\b/g,
+        },
+    ]
+};
+
+export const atlEvent: TokenPattern = {
+    debugName: "atlEvent",
+
+    // https://www.renpy.org/doc/html/atl.html#event-statement
+    token: MetaTokenType.ATLEvent, /*meta.atl.event.renpy*/
+    match: /^[ \t]*(event)\b[ \t]*\b([a-zA-Z_]\w*)\b/dgm,
+    captures: {
+        1: { token: KeywordTokenType.Event, /*keyword.event.renpy*/ },
+        2: { patterns: [atlEventName] },
+    },
+};
+
+export const atlOn: TokenPattern = {
+    debugName: "atlOn",
+
+    // https://www.renpy.org/doc/html/atl.html#on-statement
+    contentToken: MetaTokenType.ATLOn, /*meta.atl.on.renpy*/
+    begin: /^([ \t]+)?(on)\b[ \t]*(.+)?(:)/dgm,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.block.renpy*/ },
+        2: { token: KeywordTokenType.On, /*keyword.on.renpy*/ },
+        3: {
+            patterns: [
+                atlEventName,
+                {
+                    debugName: "atlOn.beginCaptures![3].patterns![1]",
+
+                    token: CharacterTokenType.Comma, /*punctuation.separator.parameters.renpy*/
+                    match: /[ \t]*,[ \t]*/g,
+                },
+            ]
+        },
+        4: { token: CharacterTokenType.Colon, /*punctuation.section.block.begin.renpy*/ },
+    },
+    end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+    patterns: [atl]
+};
+
+export const atlFunction: TokenPattern = {
+    debugName: "atlFunction",
+
+    // https://www.renpy.org/doc/html/atl.html#function-statement
+    token: MetaTokenType.ATLFunction, /*meta.atl.function.renpy*/
+    match: /^[ \t]*(function)\b[ \t]*\b([a-zA-Z_]\w*)\b/dgm,
+    captures: {
+        1: { token: KeywordTokenType.Function, /*keyword.function.renpy*/ },
+        2: {
+            patterns: [
+                {
+                    debugName: "atlFunction.captures![2].patterns![1]",
+
+                    token: MetaTokenType.FunctionCall, /*entity.name.function.renpy meta.function-call.generic.renpy*/
+                    match: /\b([a-zA-Z_]\w*)\b/g,
+                },
+            ]
+        },
+    },
+};
+
+export const atlBuildInWarpers: TokenPattern = {
+    debugName: "atlBuildInWarpers",
+
+    // Pre-defined warpers (https://www.renpy.org/doc/html/atl.html#warpers)
+    token: EntityTokenType.FunctionName, /*support.function.renpy*/
+    match: /\b(?<!\.)(?:linear|ease|easein|easeout|ease_back|ease_bounce|ease_circ|ease_cubic|ease_elastic|ease_expo|ease_quad|ease_quart|ease_quint|easein_back|easein_bounce|easein_circ|easein_cubic|easein_elastic|easein_expo|easein_quad|easein_quart|easein_quint|easeout_back|easeout_bounce|easeout_circ|easeout_cubic|easeout_elastic|easeout_expo|easeout_quad|easeout_quart|easeout_quint)\b/g,
+};
+
+export const atlWarperName: TokenPattern = {
+    patterns: [
+        atlBuildInWarpers,
+        atlBuildInProperties,
+        {
+            debugName: "atlWarperName.patterns![3]",
+
+            token: MetaTokenType.FunctionCall, /*entity.name.function.renpy meta.function-call.generic.renpy*/
+            match: /\b([a-zA-Z_]\w*)\b/g,
+        },
+    ]
+};
+
+export const atlWarper: TokenPattern = {
+    debugName: "atlWarper",
+
+    // https://www.renpy.org/doc/html/atl.html#warpers
+    token: MetaTokenType.ATLWarper, /*meta.atl.warper.renpy*/
+    begin: /\b(?<!\.)([a-zA-Z_]\w*)\b[ \t]*/dg,
+    beginCaptures: {
+        1: { patterns: [atlWarperName] },
+    },
+    end: /(?!\G)/g,
+    patterns: [atlSimpleExpression]
+};
+
+// Push pattern references that were not defined on include
+atl.patterns!.push(atlKeywords, atlBlocks, atlSimpleExpression, atlWarper, atlEvent, atlOn, atlFunction);
\ No newline at end of file
diff --git a/src/tokenizer/atl-token-patterns.ts b/src/tokenizer/atl-token-patterns.ts
deleted file mode 100644
index 62e18e4..0000000
--- a/src/tokenizer/atl-token-patterns.ts
+++ /dev/null
@@ -1,399 +0,0 @@
-/* eslint-disable no-useless-escape */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable no-useless-backreference */
-
-import { CharacterTokenType, EntityTokenType, KeywordTokenType, MetaTokenType } from "./renpy-tokens";
-import {
-    pythonBuiltinExceptions,
-    pythonBuiltinFunctions,
-    pythonBuiltinPossibleCallables,
-    pythonBuiltinTypes,
-    pythonCurlyBraces,
-    pythonEllipsis,
-    pythonExpression,
-    pythonFunctionCall,
-    pythonIllegalNames,
-    pythonIllegalOperator,
-    pythonItemAccess,
-    pythonLineContinuation,
-    pythonList,
-    pythonLiteral,
-    pythonMagicNames,
-    pythonMemberAccess,
-    pythonOddFunctionCall,
-    pythonOperator,
-    pythonPunctuation,
-    pythonRoundBraces,
-    pythonSpecialNames,
-    pythonSpecialVariables,
-} from "./python-token-patterns";
-import { TokenPattern } from "./token-pattern-types";
-import { comments, expressions } from "./common-token-patterns";
-
-// https://www.renpy.org/doc/html/atl.html#atl-syntax-and-semantics
-export const atl: TokenPattern = {
-    debugName: "atl",
-    patterns: [
-        /* Items included at the bottom of the file*/
-    ],
-};
-
-export const atlBuildInProperties: TokenPattern = {
-    debugName: "atlBuildInProperties",
-
-    // https://www.renpy.org/doc/html/atl.html#list-of-transform-properties,
-    patterns: [
-        {
-            // Special manipulation keywords,
-            match: /\b(?<!\.)(?:(warp)|(circles)|(clockwise)|(counterclockwise))\b/dg,
-            captures: {
-                1: { token: KeywordTokenType.Warp },
-                2: { token: KeywordTokenType.Circles },
-                3: { token: KeywordTokenType.Clockwise },
-                4: { token: KeywordTokenType.Counterclockwise },
-            },
-        },
-        {
-            // position props (int, absolute, or a float),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:xpos|ypos|xanchor|yanchor|xcenter|ycenter|radius)\b/g,
-        },
-        {
-            // position pair props,
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:pos|anchor|xycenter|around|alignaround|matrixanchor)\b/g,
-        },
-        {
-            // float props,
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:xalign|yalign|zoom|xzoom|yzoom|alpha|additive|angle|delay|events|zpos)\b/g,
-        },
-        {
-            // float pair props,
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:align|knot)\b/g,
-        },
-        {
-            // int props,
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:xoffset|yoffset|xtile|ytile)\b/g,
-        },
-        {
-            // int pair props,
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:offset)\b/g,
-        },
-        {
-            // boolean props,
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:rotate_pad|transform_anchor|nearest|crop_relative|subpixel|zzoom)\b/g,
-        },
-        {
-            // ('#float' | None),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:rotate|xpan|ypan|blur)\b/g,
-        },
-        {
-            // ('#position' | None),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:xsize|ysize)\b/g,
-        },
-        {
-            // ('\\(int, int, int, int\\)' | '\\(float, float, float, float\\)' | None),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:crop)\b/g,
-        },
-        {
-            // ('\\(int, int\\)' | None),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:corner1|corner2)\b/g,
-        },
-        {
-            // ('\\(position, position\\)' | None),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:xysize)\b/g,
-        },
-        {
-            // ('#string' | None),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:fit)\b/g,
-        },
-        {
-            // ('\\(int, int\\)' | None),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:size|maxsize)\b/g,
-        },
-        {
-            // ('#Matrix' | '#MatrixColor' | None),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:matrixcolor)\b/g,
-        },
-        {
-            // ('#Matrix' | '#TransformMatrix' | None),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:matrixtransform)\b/g,
-        },
-        {
-            // ('#bool' | '#float' | '\\(float, float, float\\)'),
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:perspective)\b/g,
-        },
-    ],
-};
-
-export const atlSimpleExpression: TokenPattern = {
-    debugName: "atlSimpleExpression",
-
-    patterns: [
-        expressions,
-        atlBuildInProperties,
-        pythonLiteral,
-        pythonMemberAccess,
-        pythonIllegalOperator,
-        pythonOperator,
-        pythonCurlyBraces,
-        pythonItemAccess,
-        pythonList,
-        pythonOddFunctionCall,
-        pythonRoundBraces,
-        pythonFunctionCall,
-        pythonBuiltinFunctions,
-        pythonBuiltinTypes,
-        pythonBuiltinExceptions,
-        pythonMagicNames,
-        pythonSpecialNames,
-        pythonIllegalNames,
-        pythonSpecialVariables,
-        pythonEllipsis,
-        pythonPunctuation,
-        pythonLineContinuation,
-    ],
-};
-
-// https://www.renpy.org/doc/html/atl.html#expression-statement
-export const atlExpression: TokenPattern = {
-    debugName: "atlExpression",
-
-    patterns: [
-        atlSimpleExpression,
-        {
-            begin: /\b(with)\b[ \t]*/dg,
-            beginCaptures: {
-                1: { token: KeywordTokenType.With },
-            },
-            end: /$/gm,
-            patterns: [atlSimpleExpression],
-        },
-        pythonExpression,
-    ],
-};
-
-export const atlKeywords: TokenPattern = {
-    debugName: "atlKeywords",
-
-    patterns: [
-        {
-            // https://www.renpy.org/doc/html/atl.html#animation-statement
-            match: /^[ \t]*(animation)\b/dgm,
-            captures: {
-                1: { token: KeywordTokenType.Animation },
-            },
-        },
-        {
-            // https://www.renpy.org/doc/html/atl.html#pass-statement
-            match: /^[ \t]*(pass)\b/dgm,
-            captures: {
-                1: { token: KeywordTokenType.Pass },
-            },
-        },
-        {
-            // https://www.renpy.org/doc/html/atl.html#repeat-statement and https://www.renpy.org/doc/html/atl.html#time-statement
-            begin: /^[ \t]*(?:(repeat)|(time)|(pause))\b[ \t]*/dgm,
-            beginCaptures: {
-                1: { token: KeywordTokenType.Repeat },
-                2: { token: KeywordTokenType.Time },
-                3: { token: KeywordTokenType.Pause },
-            },
-            end: /$/gm,
-            patterns: [atlSimpleExpression],
-        },
-        {
-            // https://www.renpy.org/doc/html/atl.html#expression-statement
-            contentToken: MetaTokenType.ATLWith,
-            begin: /^[ \t]*(with)\b[ \t]*/dgm,
-            beginCaptures: {
-                1: { token: KeywordTokenType.With },
-            },
-            end: /$/gm,
-            patterns: [atlSimpleExpression],
-        },
-        {
-            // https://www.renpy.org/doc/html/atl.html#contains-statement
-            contentToken: MetaTokenType.ATLContains,
-            begin: /^[ \t]*(contains)\b[ \t]*/dgm,
-            beginCaptures: {
-                1: { token: KeywordTokenType.Contains },
-            },
-            end: /$/gm,
-            patterns: [atlExpression],
-        },
-    ],
-};
-
-export const atlBlocks: TokenPattern = {
-    debugName: "atlBlocks",
-
-    patterns: [
-        {
-            // See https://www.renpy.org/doc/html/atl.html
-            contentToken: MetaTokenType.ATLBlock,
-            begin: /^([ \t]+)?(?:(block)|(parallel)|(contains))\b[ \t]*(:)/dgm,
-            beginCaptures: {
-                1: { token: CharacterTokenType.WhiteSpace },
-                2: { token: KeywordTokenType.Block },
-                3: { token: KeywordTokenType.Parallel },
-                4: { token: KeywordTokenType.Contains },
-                5: { token: CharacterTokenType.Colon },
-            },
-            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
-            patterns: [atl],
-        },
-        {
-            // https://www.renpy.org/doc/html/atl.html#choice-statement
-            contentToken: MetaTokenType.ATLChoiceBlock,
-            begin: /^([ \t]+)?(choice)\\b[ \t]*(.+)?(:)/dgm,
-            beginCaptures: {
-                1: { token: CharacterTokenType.WhiteSpace },
-                2: { token: KeywordTokenType.Choice },
-                3: { patterns: [atlSimpleExpression] },
-                4: { token: CharacterTokenType.Colon },
-            },
-            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
-            patterns: [atl],
-        },
-    ],
-};
-
-// Pre-defined events (https://www.renpy.org/doc/html/atl.html#external-events)
-export const atlBuildInEvents: TokenPattern = {
-    debugName: "atlBuildInEvents",
-
-    token: EntityTokenType.EventName,
-    match: /\b(?<!\.)(?:start|show|replace|hide|replaced|update|hover|idle|selected_hover|selected_idle)\b/g,
-};
-
-export const atlEventName: TokenPattern = {
-    debugName: "atlEventName",
-
-    patterns: [
-        pythonBuiltinPossibleCallables,
-        atlBuildInEvents,
-        {
-            token: EntityTokenType.FunctionName,
-            match: /\b([[:alpha:]_]\w*)\b/g,
-        },
-    ],
-};
-
-export const atlEventDefName: TokenPattern = {
-    debugName: "atlEventDefName",
-
-    patterns: [
-        pythonBuiltinPossibleCallables,
-        atlBuildInEvents,
-        {
-            token: EntityTokenType.FunctionName,
-            match: /\b([[:alpha:]_]\w*)\b/g,
-        },
-    ],
-};
-
-// https://www.renpy.org/doc/html/atl.html#event-statement
-export const atlEvent: TokenPattern = {
-    debugName: "atlEvent",
-
-    token: MetaTokenType.ATLEvent,
-    match: /^[ \t]*(event)\b[ \t]*\b([[:alpha:]_]\w*)\b/dgm,
-    captures: {
-        1: { token: KeywordTokenType.Event },
-        2: { patterns: [atlEventName] },
-    },
-};
-
-// https://www.renpy.org/doc/html/atl.html#on-statement
-export const atlOn: TokenPattern = {
-    debugName: "atlOn",
-
-    contentToken: MetaTokenType.ATLOn,
-    begin: /^([ \t]+)?(on)\b[ \t]*(.+)?(:)/dgm,
-    beginCaptures: {
-        1: { token: CharacterTokenType.WhiteSpace },
-        2: { token: KeywordTokenType.On },
-        3: {
-            patterns: [
-                atlEventName,
-                {
-                    match: /[ \t]*,[ \t]*/g,
-                    token: CharacterTokenType.Comma,
-                },
-                comments,
-            ],
-        },
-        4: { token: CharacterTokenType.Colon },
-    },
-    end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
-    patterns: [atl],
-};
-export const atlFunction: TokenPattern = {
-    debugName: "atlFunction",
-
-    // https://www.renpy.org/doc/html/atl.html#function-statement,
-    token: MetaTokenType.ATLFunction,
-    match: /^[ \t]*(function)\b[ \t]*\b([[:alpha:]_]\w*)\b/dgm,
-    captures: {
-        1: { token: KeywordTokenType.Function },
-        2: {
-            patterns: [
-                pythonBuiltinPossibleCallables,
-                {
-                    token: EntityTokenType.FunctionName,
-                    match: /\b([[:alpha:]_]\w*)\b/g,
-                },
-            ],
-        },
-    },
-};
-export const atlBuildInWarpers: TokenPattern = {
-    debugName: "atlBuildInWarpers",
-
-    // Pre-defined warpers (https://www.renpy.org/doc/html/atl.html#warpers),
-    token: EntityTokenType.FunctionName,
-    match: /\b(?<!\.)(?:linear|ease|easein|easeout|ease_back|ease_bounce|ease_circ|ease_cubic|ease_elastic|ease_expo|ease_quad|ease_quart|ease_quint|easein_back|easein_bounce|easein_circ|easein_cubic|easein_elastic|easein_expo|easein_quad|easein_quart|easein_quint|easeout_back|easeout_bounce|easeout_circ|easeout_cubic|easeout_elastic|easeout_expo|easeout_quad|easeout_quart|easeout_quint)\b/g,
-};
-export const atlWarperName: TokenPattern = {
-    debugName: "atlWarperName",
-
-    patterns: [
-        pythonBuiltinPossibleCallables,
-        atlBuildInWarpers,
-        atlBuildInProperties,
-        {
-            token: EntityTokenType.FunctionName,
-            match: /\b([[:alpha:]_]\w*)\b/g,
-        },
-    ],
-};
-export const atlWarper: TokenPattern = {
-    debugName: "atlWarper",
-
-    // https://www.renpy.org/doc/html/atl.html#warpers,
-    token: MetaTokenType.ATLWarper,
-    begin: /\b(?<!\.)([[:alpha:]_]\w*)\b[ \t]*/dg,
-    beginCaptures: {
-        1: { patterns: [atlWarperName] },
-    },
-    end: /(?!\G)/g,
-    patterns: [atlSimpleExpression],
-};
-
-atl.patterns!.push(atlKeywords, atlBlocks, atlSimpleExpression, atlWarper, atlEvent, atlOn, atlFunction);
diff --git a/src/tokenizer/common-token-patterns.ts b/src/tokenizer/common-token-patterns.ts
deleted file mode 100644
index d4c17c1..0000000
--- a/src/tokenizer/common-token-patterns.ts
+++ /dev/null
@@ -1,581 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { CharacterTokenType, EntityTokenType, EscapedCharacterTokenType, LiteralTokenType, MetaTokenType, OperatorTokenType } from "./renpy-tokens";
-import { TokenPattern } from "./token-pattern-types";
-
-export const newLine: TokenPattern = {
-    token: CharacterTokenType.NewLine,
-    match: /\r\n|\r|\n/g,
-};
-
-export const whiteSpace: TokenPattern = {
-    token: CharacterTokenType.WhiteSpace,
-    match: /[ \t]+/g,
-};
-
-export const invalidToken: TokenPattern = {
-    match: /(.*)/dg,
-    captures: {
-        1: { token: MetaTokenType.Invalid },
-    },
-};
-
-export const numFloat: TokenPattern = {
-    debugName: "numFloat",
-
-    match: /(?<!\w)(?:\.[0-9]+|[0-9]*\.[0-9]*|[0-9]*\.)\b/g,
-    token: LiteralTokenType.Float,
-};
-export const numInt: TokenPattern = {
-    debugName: "numInt",
-    match: /(?<![\w.])([1-9]+|0+|0([0-9]+)(?![eE.]))\b/dg,
-    captures: {
-        1: { token: LiteralTokenType.Integer },
-        2: { token: MetaTokenType.Invalid },
-    },
-};
-
-export const escapedChar: TokenPattern = {
-    debugName: "escapedChar",
-
-    match: /(\\")|(\\')|(\\ )|(\\n)|(\\\\)|(\[\[)|({{)/dg,
-    captures: {
-        1: {
-            token: EscapedCharacterTokenType.EscDoubleQuote,
-        },
-        2: {
-            token: EscapedCharacterTokenType.EscQuote,
-        },
-        3: {
-            token: EscapedCharacterTokenType.EscWhitespace,
-        },
-        4: {
-            token: EscapedCharacterTokenType.EscNewline,
-        },
-        5: {
-            token: EscapedCharacterTokenType.EscBackslash,
-        },
-        6: {
-            token: EscapedCharacterTokenType.EscOpenBracket,
-        },
-        7: {
-            token: EscapedCharacterTokenType.EscOpenSquareBracket,
-        },
-    },
-};
-
-export const hexLiteral: TokenPattern = {
-    debugName: "hexLiteral",
-
-    // Note: This pattern has no end check. Only use as include pattern!
-    patterns: [
-        {
-            // rgb, rgba, rrggbb, rrggbbaa
-            match: /#(?:[a-f0-9]{8}|[a-f0-9]{6}|[a-f0-9]{3,4})\b/gi,
-            token: LiteralTokenType.Color,
-        },
-        {
-            match: /#[a-f0-9]+\b/gi,
-            token: MetaTokenType.Invalid,
-        },
-        {
-            match: /(?:#[a-f0-9]*)?(.+)/dgi,
-            token: LiteralTokenType.Color,
-            captures: {
-                1: { token: MetaTokenType.Invalid },
-            },
-        },
-    ],
-};
-
-export const constantPlaceholder: TokenPattern = {
-    debugName: "constantPlaceholder",
-
-    // Python value interpolation using [ ... ]
-    token: MetaTokenType.Placeholder,
-    match: /(\[)(.*?)(\])(?![^[]*?\])/dg,
-    captures: {
-        1: { token: CharacterTokenType.OpenSquareBracket },
-        2: { token: MetaTokenType.PythonLine },
-        3: { token: CharacterTokenType.CloseSquareBracket },
-    },
-};
-
-export const stringsInterior: TokenPattern = {
-    debugName: "stringsInterior",
-
-    patterns: [
-        newLine,
-        escapedChar,
-        constantPlaceholder,
-        /*stringTags*/ // pushed below
-    ],
-};
-
-export const stringTags: TokenPattern = {
-    debugName: "stringTags",
-
-    patterns: [
-        {
-            // Valid tags without params (self-closing)
-            token: MetaTokenType.TagBlock,
-            match: /({)\s*(nw|done|fast|p|w|clear)\s*(})/dg,
-            captures: {
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: EntityTokenType.Tag },
-                3: { token: CharacterTokenType.CloseBracket },
-            },
-        },
-        {
-            // Valid tags with numeric params (self-closing)
-            token: MetaTokenType.TagBlock,
-            match: /({)\s*(p|w)(=)(\+)?(\d*(?:.\d+)?)\s*(})/dg,
-            captures: {
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: EntityTokenType.Tag },
-                3: { token: OperatorTokenType.Assign },
-                4: { token: OperatorTokenType.Plus },
-                5: { token: LiteralTokenType.Float },
-                6: { token: CharacterTokenType.CloseBracket },
-            },
-        },
-        {
-            // Valid tags with numeric params (self-closing)
-            token: MetaTokenType.TagBlock,
-            match: /({)\s*(v?space)(=)(\+)?(\d+)\s*(})/dg,
-            captures: {
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: EntityTokenType.Tag },
-                3: { token: OperatorTokenType.Assign },
-                4: { token: OperatorTokenType.Plus },
-                5: { token: LiteralTokenType.Integer },
-                6: { token: CharacterTokenType.CloseBracket },
-            },
-        },
-        {
-            // Comment tag (self-closing)
-            token: MetaTokenType.TagBlock,
-            match: /({)\s*(#)\s*(.*?)\s*(})/dg,
-            captures: {
-                0: { token: MetaTokenType.Comment },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: EntityTokenType.Tag },
-                3: { token: OperatorTokenType.Assign },
-                4: { token: LiteralTokenType.UnquotedString },
-                5: { token: CharacterTokenType.CloseBracket },
-            },
-        },
-        {
-            // Valid tags with file param
-            token: MetaTokenType.TagBlock,
-            match: /({)\s*(font|image)(=)([\w.]+)\s*(})/dg,
-            captures: {
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: EntityTokenType.Tag },
-                3: { token: OperatorTokenType.Assign },
-                4: { token: LiteralTokenType.UnquotedString },
-                5: { token: CharacterTokenType.CloseBracket },
-            },
-        },
-        {
-            // Valid tags without params (close required)
-            begin: /({)\s*(u|i|b|s|plain|alt|noalt|art|rb|rt)\s*(})/dg,
-            beginCaptures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: EntityTokenType.Tag },
-                3: { token: CharacterTokenType.CloseBracket },
-            },
-            end: /({)(\/)(\s+)?(\2)(\s+)?(})/dg,
-            endCaptures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: CharacterTokenType.ForwardSlash },
-                3: { token: CharacterTokenType.WhiteSpace },
-                4: { token: EntityTokenType.Tag },
-                5: { token: CharacterTokenType.WhiteSpace },
-                6: { token: CharacterTokenType.CloseBracket },
-            },
-            patterns: [stringsInterior],
-        },
-        {
-            // Valid tags with numeric params (close required)
-            begin: /({)\s*(alpha|cps|k)(=)(?:(\*)|(-)|(\+))?(\d+(?:.\d+)?)\s*(})/dg,
-            beginCaptures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: EntityTokenType.Tag },
-                3: { token: OperatorTokenType.Assign },
-                4: { token: OperatorTokenType.Multiply },
-                5: { token: OperatorTokenType.Minus },
-                6: { token: OperatorTokenType.Plus },
-                7: { token: LiteralTokenType.Float },
-                8: { token: CharacterTokenType.CloseBracket },
-            },
-            end: /({)(\/)(\s+)?(\2)(\s+)?(})/dg,
-            endCaptures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: CharacterTokenType.ForwardSlash },
-                3: { token: CharacterTokenType.WhiteSpace },
-                4: { token: EntityTokenType.Tag },
-                5: { token: CharacterTokenType.WhiteSpace },
-                6: { token: CharacterTokenType.CloseBracket },
-            },
-            patterns: [stringsInterior],
-        },
-        {
-            // Valid tags with numeric params (close required)
-            begin: /({)\s*(size)(=)(?:(-)|(\+))?(\d+)\s*(})/dg,
-            beginCaptures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: EntityTokenType.Tag },
-                3: { token: OperatorTokenType.Assign },
-                4: { token: OperatorTokenType.Minus },
-                5: { token: OperatorTokenType.Plus },
-                6: { token: LiteralTokenType.Integer },
-                7: { token: CharacterTokenType.CloseBracket },
-            },
-            end: /({)(\/)(\s+)?(\2)(\s+)?(})/dg,
-            endCaptures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: CharacterTokenType.ForwardSlash },
-                3: { token: CharacterTokenType.WhiteSpace },
-                4: { token: EntityTokenType.Tag },
-                5: { token: CharacterTokenType.WhiteSpace },
-                6: { token: CharacterTokenType.CloseBracket },
-            },
-            patterns: [stringsInterior],
-        },
-        {
-            // Color tag
-            begin: /({)\s*(color|outlinecolor)(=)(#?[a-zA-Z0-9]+)\s*(})/dg,
-            beginCaptures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: EntityTokenType.Tag },
-                3: { token: OperatorTokenType.Assign },
-                4: {
-                    patterns: [hexLiteral],
-                },
-                5: { token: CharacterTokenType.CloseBracket },
-            },
-            end: /({)(\/)(\s+)?(\2)(\s+)?(})/dg,
-            endCaptures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: CharacterTokenType.ForwardSlash },
-                3: { token: CharacterTokenType.WhiteSpace },
-                4: { token: EntityTokenType.Tag },
-                5: { token: CharacterTokenType.WhiteSpace },
-                6: { token: CharacterTokenType.CloseBracket },
-            },
-            patterns: [stringsInterior],
-        },
-        {
-            // a tag
-            begin: /({)\s*(a)(=)(.*?)\s*(})/dg,
-            beginCaptures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: EntityTokenType.Tag },
-                3: { token: OperatorTokenType.Assign },
-                4: {
-                    token: LiteralTokenType.UnquotedString,
-                },
-                5: { token: CharacterTokenType.CloseBracket },
-            },
-            end: /({)(\/)(\s+)?(\2)(\s+)?(})/dg,
-            endCaptures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: CharacterTokenType.ForwardSlash },
-                3: { token: CharacterTokenType.WhiteSpace },
-                4: { token: EntityTokenType.Tag },
-                5: { token: CharacterTokenType.WhiteSpace },
-                6: { token: CharacterTokenType.CloseBracket },
-            },
-            patterns: [stringsInterior],
-        },
-        {
-            contentToken: MetaTokenType.TagBlock,
-            begin: /({)([ \t]+)?(\w+)\b(?:(=)(.*?))?([ \t]+)?(})/dg,
-            beginCaptures: {
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: CharacterTokenType.WhiteSpace },
-                3: { token: EntityTokenType.Tag },
-                4: { token: OperatorTokenType.Assign },
-                5: { token: MetaTokenType.Arguments },
-                6: { token: CharacterTokenType.WhiteSpace },
-                7: { token: CharacterTokenType.CloseBracket },
-            },
-            end: /({)(\/)([ \t]+)?(\3)([ \t]+)?(})/dg,
-            endCaptures: {
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: CharacterTokenType.ForwardSlash },
-                3: { token: CharacterTokenType.WhiteSpace },
-                4: { token: EntityTokenType.Tag },
-                5: { token: CharacterTokenType.WhiteSpace },
-                6: { token: CharacterTokenType.CloseBracket },
-            },
-            patterns: [stringsInterior],
-        },
-        {
-            // Empty tag end
-            token: MetaTokenType.Invalid,
-            match: /({)(\/)?(\s+)?(})/dg,
-            captures: {
-                0: { token: MetaTokenType.TagBlock },
-                1: { token: CharacterTokenType.OpenBracket },
-                2: { token: CharacterTokenType.ForwardSlash },
-                3: { token: CharacterTokenType.WhiteSpace },
-                4: { token: CharacterTokenType.CloseBracket },
-            },
-        },
-    ],
-};
-
-stringsInterior.patterns!.push(stringTags);
-
-export const stringQuotedDouble: TokenPattern = {
-    debugName: "stringQuotedDouble",
-
-    patterns: [
-        {
-            // Triple quoted block string
-            token: LiteralTokenType.String,
-            begin: /(")(")(")/dg,
-            beginCaptures: {
-                1: { token: CharacterTokenType.DoubleQuote },
-                2: { token: CharacterTokenType.DoubleQuote },
-                3: { token: CharacterTokenType.DoubleQuote },
-            },
-            end: /(?<!\\)((?<=""")(")""|""")/dg,
-            endCaptures: {
-                1: { token: CharacterTokenType.DoubleQuote },
-                2: { token: MetaTokenType.EmptyString },
-            },
-            patterns: [stringsInterior],
-        },
-        {
-            // Double quoted single line string
-            token: LiteralTokenType.String,
-            begin: /(")/dg,
-            beginCaptures: {
-                1: { token: CharacterTokenType.DoubleQuote },
-            },
-            end: /(?<!\\)((?<=")(")|")/dg,
-            endCaptures: {
-                1: { token: CharacterTokenType.DoubleQuote },
-                2: { token: MetaTokenType.EmptyString },
-                3: { token: MetaTokenType.Invalid },
-            },
-            patterns: [stringsInterior],
-        },
-    ],
-};
-
-export const stringQuotedSingle: TokenPattern = {
-    debugName: "stringQuotedSingle",
-
-    patterns: [
-        {
-            // Single quoted block string
-            token: LiteralTokenType.String,
-            begin: /(''')/dg,
-            beginCaptures: {
-                0: { token: CharacterTokenType.Quote },
-            },
-            end: /(?<!\\)((?<=''')('|''')|''')/dg,
-            endCaptures: {
-                1: { token: CharacterTokenType.Quote },
-                2: { token: MetaTokenType.EmptyString },
-            },
-            patterns: [stringsInterior],
-        },
-        {
-            // Single quoted single line string
-            token: LiteralTokenType.String,
-            begin: /(')/dg,
-            beginCaptures: {
-                1: { token: CharacterTokenType.Quote },
-            },
-            end: /(?<!\\)((?<=')(')|')/dg,
-            endCaptures: {
-                1: { token: CharacterTokenType.Quote },
-                2: { token: MetaTokenType.EmptyString },
-                3: { token: MetaTokenType.Invalid },
-            },
-            patterns: [stringsInterior],
-        },
-    ],
-};
-
-export const stringQuotedBack: TokenPattern = {
-    debugName: "stringQuotedBack",
-
-    patterns: [
-        {
-            // Back quoted block string
-            token: LiteralTokenType.String,
-            begin: /(```)/dg,
-            beginCaptures: {
-                0: { token: CharacterTokenType.BackQuote },
-            },
-            end: /(?<!\\)((?<=```)(`)``|```)/dg,
-            endCaptures: {
-                1: { token: CharacterTokenType.BackQuote },
-                2: { token: MetaTokenType.EmptyString },
-            },
-            patterns: [stringsInterior],
-        },
-        {
-            // Back quoted single line string
-            token: LiteralTokenType.String,
-            begin: /(`)/dg,
-            beginCaptures: {
-                1: { token: CharacterTokenType.BackQuote },
-            },
-            end: /(?<!\\)((?<=`)(`)|`)/dg,
-            endCaptures: {
-                1: { token: CharacterTokenType.BackQuote },
-                2: { token: MetaTokenType.EmptyString },
-                3: { token: MetaTokenType.Invalid },
-            },
-            patterns: [stringsInterior],
-        },
-    ],
-};
-
-export const strings: TokenPattern = {
-    debugName: "strings",
-
-    patterns: [stringQuotedDouble, stringQuotedSingle, stringQuotedBack],
-};
-
-// NOTE: Having these patterns separated increases performance.
-// Benchmark before making a change!
-export const charactersPatten: TokenPattern = {
-    debugName: "charactersPatten",
-
-    patterns: [
-        newLine,
-        whiteSpace,
-        {
-            token: CharacterTokenType.OpenParentheses,
-            match: /\(/g,
-        },
-        {
-            token: CharacterTokenType.CloseParentheses,
-            match: /\)/g,
-        },
-
-        {
-            token: CharacterTokenType.OpenBracket,
-            match: /{/g,
-        },
-        {
-            token: CharacterTokenType.CloseBracket,
-            match: /}/g,
-        },
-
-        {
-            token: CharacterTokenType.OpenSquareBracket,
-            match: /\[/g,
-        },
-        {
-            token: CharacterTokenType.CloseSquareBracket,
-            match: /\]/g,
-        },
-
-        {
-            token: CharacterTokenType.Period,
-            match: /\./g,
-        },
-        {
-            token: CharacterTokenType.Colon,
-            match: /:/g,
-        },
-        {
-            token: CharacterTokenType.Semicolon,
-            match: /;/g,
-        },
-        {
-            token: CharacterTokenType.Comma,
-            match: /,/g,
-        },
-        {
-            token: CharacterTokenType.Hashtag,
-            match: /#/g,
-        },
-
-        {
-            token: CharacterTokenType.Quote,
-            match: /'/g,
-        },
-        {
-            token: CharacterTokenType.DoubleQuote,
-            match: /"/g,
-        },
-        {
-            token: CharacterTokenType.BackQuote,
-            match: /`/g,
-        },
-
-        {
-            token: CharacterTokenType.Backslash,
-            match: /\\/g,
-        },
-        {
-            token: CharacterTokenType.ForwardSlash,
-            match: /\//g,
-        },
-
-        {
-            token: OperatorTokenType.Assign,
-            match: /=/g,
-        },
-
-        {
-            token: MetaTokenType.Invalid,
-            match: /\b\w+\b/g,
-        },
-        {
-            token: CharacterTokenType.Unknown,
-            match: /./g,
-        },
-    ],
-};
-
-export const comments: TokenPattern = {
-    debugName: "comments",
-
-    token: MetaTokenType.Comment,
-    match: /(#)(.*)$/dgm,
-    captures: {
-        1: { token: CharacterTokenType.Hashtag },
-        2: {
-            patterns: [
-                {
-                    match: /(?:\b(NOTE|XXX|HACK|FIXME|BUG|TODO)\b)/dg,
-                    captures: { 1: { token: MetaTokenType.CommentCodeTag } },
-                },
-            ],
-        },
-    },
-};
-
-export const statements: TokenPattern = {
-    debugName: "statements",
-    patterns: [
-        /* Items included in renpy token-patterns file*/
-    ],
-};
-
-export const expressions: TokenPattern = {
-    debugName: "expressions",
-    patterns: [
-        /* Items included in renpy token-patterns file*/
-    ],
-};
diff --git a/src/tokenizer/debug-decorator.ts b/src/tokenizer/debug-decorator.ts
index 178942b..73e19cb 100644
--- a/src/tokenizer/debug-decorator.ts
+++ b/src/tokenizer/debug-decorator.ts
@@ -1,7 +1,7 @@
 import { performance } from "perf_hooks";
 import { DecorationOptions, Disposable, ExtensionContext, MarkdownString, Uri, window, workspace } from "vscode";
 import { CharacterTokenType, LiteralTokenType, EntityTokenType, EscapedCharacterTokenType, KeywordTokenType, MetaTokenType, OperatorTokenType } from "./renpy-tokens";
-import { Token } from "./token-definitions";
+import { TokenTree } from "./token-definitions";
 import { tokenizeDocument } from "./tokenizer";
 
 let timeout: NodeJS.Timer | undefined = undefined;
@@ -115,6 +115,13 @@ const errorDecorationType = window.createTextEditorDecorationType({
     textDecoration: "underline wavy red 2px",
 });
 
+const deprecatedDecorationType = window.createTextEditorDecorationType({
+    borderWidth: "1px",
+    borderStyle: "dotted",
+    borderColor: "#f44747",
+    textDecoration: "underline wavy yellow 2px",
+});
+
 const allDecorationTypes = [
     keywordDecorationType,
     controlKeywordDecorationType,
@@ -135,7 +142,7 @@ const allDecorationTypes = [
     errorDecorationType,
 ];
 
-let tokenCache: Token[] = [];
+let tokenCache: TokenTree;
 let documentVersion = -1;
 let documentUri: Uri | null = null;
 
@@ -183,7 +190,7 @@ function updateDecorations() {
         return;
     }
 
-    if (documentVersion !== activeEditor.document.version || documentUri !== activeEditor.document.uri || tokenCache.length === 0) {
+    if (documentVersion !== activeEditor.document.version || documentUri !== activeEditor.document.uri || tokenCache.count() === 0) {
         documentVersion = activeEditor.document.version;
         documentUri = activeEditor.document.uri;
 
@@ -219,9 +226,15 @@ function updateDecorations() {
     const escCharacters: DecorationOptions[] = [];
 
     const errors: DecorationOptions[] = [];
+    const deprecated: DecorationOptions[] = [];
+
+    tokens.forEach((node) => {
+        const token = node.token;
+        if (!token) {
+            return;
+        }
 
-    tokens.forEach((token) => {
-        const range = token.getRange();
+        const range = token.getVSCodeRange();
         const content = activeEditor?.document.getText(range);
 
         const decoration: DecorationOptions = {
@@ -290,15 +303,16 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
             case KeywordTokenType.Fadeout:
             case KeywordTokenType.Set: // Renpy sub expression keywords
             case KeywordTokenType.Expression:
-            case KeywordTokenType.At:
-            case KeywordTokenType.As:
-            case KeywordTokenType.With:
-            case KeywordTokenType.OnLayer:
-            case KeywordTokenType.ZOrder:
-            case KeywordTokenType.Behind:
             case KeywordTokenType.Animation:
             case KeywordTokenType.From:
+            case KeywordTokenType.Time:
+            case KeywordTokenType.Repeat:
             case KeywordTokenType.DollarSign:
+            case KeywordTokenType.Sensitive:
+            case KeywordTokenType.Text:
+            case KeywordTokenType.Other:
+            case KeywordTokenType.OtherPython:
+            case KeywordTokenType.OtherAudio:
             case KeywordTokenType.Warp: // ATL keywords
             case KeywordTokenType.Circles:
             case KeywordTokenType.Clockwise:
@@ -306,13 +320,20 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
             case KeywordTokenType.Event:
             case KeywordTokenType.On:
             case KeywordTokenType.Function:
+            case KeywordTokenType.Import: // Python keywords
+            case KeywordTokenType.Class:
+            case KeywordTokenType.Metaclass:
+            case KeywordTokenType.Lambda:
+            case KeywordTokenType.Async:
+            case KeywordTokenType.Def:
+            case KeywordTokenType.Global:
+            case KeywordTokenType.Nonlocal:
             case LiteralTokenType.Boolean: // Language keywords
             case OperatorTokenType.And:
             case OperatorTokenType.Or:
             case OperatorTokenType.Not:
             case OperatorTokenType.Is:
             case OperatorTokenType.IsNot:
-            case OperatorTokenType.In:
             case OperatorTokenType.NotIn:
                 keywords.push(decoration);
                 break;
@@ -320,7 +341,8 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
             case KeywordTokenType.If: // Conditional control flow keywords
             case KeywordTokenType.Elif:
             case KeywordTokenType.Else:
-            case KeywordTokenType.For: // Control flow keywords
+            case KeywordTokenType.In: // Control flow keywords
+            case KeywordTokenType.For:
             case KeywordTokenType.While:
             case KeywordTokenType.Pass:
             case KeywordTokenType.Return:
@@ -330,11 +352,19 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
             case KeywordTokenType.Parallel:
             case KeywordTokenType.Block:
             case KeywordTokenType.Choice:
+            case KeywordTokenType.At: // Renpy control flow keywords
+            case KeywordTokenType.As:
+            case KeywordTokenType.With:
+            case KeywordTokenType.Onlayer:
+            case KeywordTokenType.Zorder:
+            case KeywordTokenType.Behind:
                 controlKeywords.push(decoration);
                 break;
 
-            case EntityTokenType.Class: // Types
-            case EntityTokenType.Namespace:
+            case EntityTokenType.ClassName: // Types
+            case EntityTokenType.InheritedClassName:
+            case EntityTokenType.TypeName:
+            case EntityTokenType.NamespaceName:
                 types.push(decoration);
                 break;
 
@@ -346,42 +376,58 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
 
             // Variables
             case EntityTokenType.VariableName:
+            case EntityTokenType.ImageName:
+            case EntityTokenType.TextName:
+            case EntityTokenType.AudioName:
+            case EntityTokenType.CharacterName:
             case EntityTokenType.PropertyName:
                 variables.push(decoration);
                 break;
 
             // Other entities
-            case EntityTokenType.Tag:
+            case EntityTokenType.TagName:
                 otherEntities.push(decoration);
                 break;
 
             // Comments
             case MetaTokenType.Comment:
             case MetaTokenType.CommentCodeTag:
+            case MetaTokenType.CommentRegionTag:
+            case MetaTokenType.TypehintComment:
+            case MetaTokenType.TypehintDirective:
+            case MetaTokenType.TypehintIgnore:
+            case MetaTokenType.TypehintType:
+            case MetaTokenType.TypehintPunctuation:
+            case MetaTokenType.TypehintVariable:
+            case MetaTokenType.Docstring:
                 comments.push(decoration);
                 break;
 
+            case MetaTokenType.StringBegin:
+            case MetaTokenType.StringEnd:
             case MetaTokenType.CodeBlock:
             case MetaTokenType.PythonLine:
             case MetaTokenType.PythonBlock:
             case MetaTokenType.Arguments:
             case MetaTokenType.EmptyString:
+            case MetaTokenType.StringTag:
             case MetaTokenType.TagBlock:
+            case MetaTokenType.TaggedString:
             case MetaTokenType.Placeholder:
             case MetaTokenType.MenuStatement:
             case MetaTokenType.MenuBlock:
             case MetaTokenType.MenuOption:
             case MetaTokenType.MenuOptionBlock:
+            case MetaTokenType.BehindStatement:
+            case MetaTokenType.OnlayerStatement:
             case MetaTokenType.CameraStatement:
             case MetaTokenType.SceneStatement:
             case MetaTokenType.ShowStatement:
             case MetaTokenType.ImageStatement:
-            case MetaTokenType.NarratorSayStatement:
-            case MetaTokenType.SayStatement:
-            case MetaTokenType.CharacterNameString:
             case MetaTokenType.CallStatement:
             case MetaTokenType.JumpStatement:
             case MetaTokenType.PlayAudioStatement:
+            case MetaTokenType.QueueAudioStatement:
             case MetaTokenType.StopAudioStatement:
             case MetaTokenType.LabelStatement:
             case MetaTokenType.LabelCall:
@@ -389,6 +435,23 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
             case MetaTokenType.AtStatement:
             case MetaTokenType.AsStatement:
             case MetaTokenType.WithStatement:
+            case MetaTokenType.ScreenStatement:
+            case MetaTokenType.ScreenSensitive:
+            case MetaTokenType.ScreenFrame:
+            case MetaTokenType.ScreenWindow:
+            case MetaTokenType.ScreenText:
+            case MetaTokenType.ScreenBlock:
+            case MetaTokenType.NarratorSayStatement:
+            case MetaTokenType.SayStatement:
+            case MetaTokenType.CharacterNameString:
+            case MetaTokenType.SayNarrator:
+            case MetaTokenType.SayCharacter:
+            case MetaTokenType.AtParameters:
+            case MetaTokenType.AsParameters:
+            case MetaTokenType.BehindParameters:
+            case MetaTokenType.OnlayerParameters:
+            case MetaTokenType.WithParameters:
+            case MetaTokenType.ZorderParameters:
             case MetaTokenType.ATLBlock:
             case MetaTokenType.ATLChoiceBlock:
             case MetaTokenType.ATLContains:
@@ -397,6 +460,47 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
             case MetaTokenType.ATLFunction:
             case MetaTokenType.ATLWarper:
             case MetaTokenType.ATLOn:
+            case MetaTokenType.MemberAccess:
+            case MetaTokenType.ItemAccess:
+            case MetaTokenType.IndexedName:
+            case MetaTokenType.Attribute:
+            case MetaTokenType.ClassDefinition:
+            case MetaTokenType.ClassInheritance:
+            case MetaTokenType.FunctionDefinition:
+            case MetaTokenType.LambdaFunction:
+            case MetaTokenType.FunctionLambdaParameters:
+            case MetaTokenType.FunctionParameters:
+            case MetaTokenType.FunctionDecorator:
+            case MetaTokenType.FunctionCall:
+            case MetaTokenType.FunctionCallGeneric:
+            case MetaTokenType.Fstring:
+            case MetaTokenType.ControlFlowKeyword:
+            case MetaTokenType.LogicalOperatorKeyword:
+            case MetaTokenType.Operator:
+            case MetaTokenType.ArithmeticOperator:
+            case MetaTokenType.BitwiseOperatorKeyword:
+            case MetaTokenType.ComparisonOperatorKeyword:
+            case MetaTokenType.ConstantLiteral:
+            case MetaTokenType.ConstantNumeric:
+            case MetaTokenType.ConstantCaps:
+            case MetaTokenType.BuiltinExceptionType:
+            case MetaTokenType.BuiltinType:
+            case MetaTokenType.MagicVariable:
+            case MetaTokenType.EscapeSequence:
+            case MetaTokenType.FormatPercent:
+            case MetaTokenType.FormatBrace:
+            case MetaTokenType.StringStorageType:
+            case MetaTokenType.FormatStorageType:
+            case MetaTokenType.ImaginaryNumberStorageType:
+            case MetaTokenType.NumberStorageType:
+            case MetaTokenType.ClassStorageType:
+            case MetaTokenType.CommentBegin:
+            case MetaTokenType.CommentEnd:
+            case MetaTokenType.Backreference:
+            case MetaTokenType.BackreferenceNamed:
+            case MetaTokenType.CharacterSet:
+            case MetaTokenType.Named:
+            case MetaTokenType.ModifierFlagStorageType:
                 otherMeta.push(decoration);
                 break;
 
@@ -439,7 +543,7 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
             case OperatorTokenType.BitwiseNot:
             case OperatorTokenType.BitwiseLeftShift:
             case OperatorTokenType.BitwiseRightShift:
-            case OperatorTokenType.Assign: // Assignment operators
+            case OperatorTokenType.Assignment: // Assignment operators
             case OperatorTokenType.PlusAssign:
             case OperatorTokenType.MinusAssign:
             case OperatorTokenType.MultiplyAssign:
@@ -461,13 +565,17 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
                 operators.push(decoration);
                 break;
 
-            case CharacterTokenType.WhiteSpace:
+            case CharacterTokenType.Whitespace:
             case CharacterTokenType.NewLine:
             case CharacterTokenType.Period:
             case CharacterTokenType.Colon:
             case CharacterTokenType.Semicolon:
             case CharacterTokenType.Comma:
             case CharacterTokenType.Hashtag:
+            case CharacterTokenType.Caret:
+            case CharacterTokenType.DollarSymbol:
+            case CharacterTokenType.AtSymbol:
+            case CharacterTokenType.EqualsSymbol:
             case CharacterTokenType.Quote:
             case CharacterTokenType.DoubleQuote:
             case CharacterTokenType.BackQuote:
@@ -499,6 +607,11 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
             case MetaTokenType.Invalid:
                 errors.push(decoration);
                 break;
+
+            case MetaTokenType.Deprecated:
+                deprecated.push(decoration);
+                break;
+
             default:
                 throw new Error(`Unhandled token case: ${tokenTypeToStringMap[token.tokenType]}(id: ${token.tokenType})`);
         }
@@ -527,6 +640,7 @@ ${(decoration.hoverMessage as MarkdownString).value}`);
     activeEditor.setDecorations(escCharacterDecorationType, escCharacters);
 
     activeEditor.setDecorations(errorDecorationType, errors);
+    activeEditor.setDecorations(deprecatedDecorationType, deprecated);
 }
 
 function triggerUpdateDecorations(throttle = false) {
@@ -557,6 +671,7 @@ const tokenTypeDefinitions: EnumToString<AllTokenTypes> = {
     Early: { name: "Early", value: KeywordTokenType.Early },
     Define: { name: "Define", value: KeywordTokenType.Define },
     Default: { name: "Default", value: KeywordTokenType.Default },
+
     Label: { name: "Label", value: KeywordTokenType.Label },
     Menu: { name: "Menu", value: KeywordTokenType.Menu },
     Pause: { name: "Pause", value: KeywordTokenType.Pause },
@@ -585,19 +700,25 @@ const tokenTypeDefinitions: EnumToString<AllTokenTypes> = {
     At: { name: "At", value: KeywordTokenType.At },
     As: { name: "As", value: KeywordTokenType.As },
     With: { name: "With", value: KeywordTokenType.With },
-    OnLayer: { name: "OnLayer", value: KeywordTokenType.OnLayer },
-    ZOrder: { name: "ZOrder", value: KeywordTokenType.ZOrder },
+    Onlayer: { name: "Onlayer", value: KeywordTokenType.Onlayer },
+    Zorder: { name: "Zorder", value: KeywordTokenType.Zorder },
     Behind: { name: "Behind", value: KeywordTokenType.Behind },
     Animation: { name: "Animation", value: KeywordTokenType.Animation },
     From: { name: "From", value: KeywordTokenType.From },
     Time: { name: "Time", value: KeywordTokenType.Time },
     Repeat: { name: "Repeat", value: KeywordTokenType.Repeat },
     DollarSign: { name: "DollarSign", value: KeywordTokenType.DollarSign },
+    Sensitive: { name: "Sensitive", value: KeywordTokenType.Sensitive },
+    Text: { name: "Text", value: KeywordTokenType.Text },
+    Other: { name: "Other", value: KeywordTokenType.Other },
+    OtherPython: { name: "OtherPython", value: KeywordTokenType.OtherPython },
+    OtherAudio: { name: "OtherAudio", value: KeywordTokenType.OtherAudio },
 
     If: { name: "If", value: KeywordTokenType.If },
     Elif: { name: "Elif", value: KeywordTokenType.Elif },
     Else: { name: "Else", value: KeywordTokenType.Else },
 
+    In: { name: "In", value: KeywordTokenType.In },
     For: { name: "For", value: KeywordTokenType.For },
     While: { name: "While", value: KeywordTokenType.While },
     Pass: { name: "Pass", value: KeywordTokenType.Pass },
@@ -617,12 +738,28 @@ const tokenTypeDefinitions: EnumToString<AllTokenTypes> = {
     On: { name: "On", value: KeywordTokenType.On },
     Function: { name: "Function", value: KeywordTokenType.Function },
 
-    Class: { name: "Class", value: EntityTokenType.Class },
-    Namespace: { name: "Namespace", value: EntityTokenType.Namespace },
+    Import: { name: "Import", value: KeywordTokenType.Import },
+    Class: { name: "Class", value: KeywordTokenType.Class },
+    Metaclass: { name: "Metaclass", value: KeywordTokenType.Metaclass },
+    Lambda: { name: "Lambda", value: KeywordTokenType.Lambda },
+    Async: { name: "Async", value: KeywordTokenType.Async },
+    Def: { name: "Def", value: KeywordTokenType.Def },
+    Global: { name: "Global", value: KeywordTokenType.Global },
+    Nonlocal: { name: "Nonlocal", value: KeywordTokenType.Nonlocal },
+
+    ClassName: { name: "ClassName", value: EntityTokenType.ClassName },
+    InheritedClassName: { name: "InheritedClassName", value: EntityTokenType.InheritedClassName },
+    TypeName: { name: "TypeName", value: EntityTokenType.TypeName },
+    NamespaceName: { name: "NamespaceName", value: EntityTokenType.NamespaceName },
     FunctionName: { name: "FunctionName", value: EntityTokenType.FunctionName },
-    Tag: { name: "Tag", value: EntityTokenType.Tag },
+    TagName: { name: "TagName", value: EntityTokenType.TagName },
     VariableName: { name: "VariableName", value: EntityTokenType.VariableName },
 
+    ImageName: { name: "ImageName", value: EntityTokenType.ImageName },
+    TextName: { name: "TextName", value: EntityTokenType.TextName },
+    AudioName: { name: "AudioName", value: EntityTokenType.AudioName },
+    CharacterName: { name: "CharacterName", value: EntityTokenType.CharacterName },
+
     EventName: { name: "EventName", value: EntityTokenType.EventName },
     PropertyName: { name: "PropertyName", value: EntityTokenType.PropertyName },
 
@@ -651,7 +788,7 @@ const tokenTypeDefinitions: EnumToString<AllTokenTypes> = {
     BitwiseLeftShift: { name: "BitwiseLeftShift", value: OperatorTokenType.BitwiseLeftShift },
     BitwiseRightShift: { name: "BitwiseRightShift", value: OperatorTokenType.BitwiseRightShift },
 
-    Assign: { name: "Assign", value: OperatorTokenType.Assign },
+    Assignment: { name: "Assignment", value: OperatorTokenType.Assignment },
     PlusAssign: { name: "PlusAssign", value: OperatorTokenType.PlusAssign },
     MinusAssign: { name: "MinusAssign", value: OperatorTokenType.MinusAssign },
     MultiplyAssign: { name: "MultiplyAssign", value: OperatorTokenType.MultiplyAssign },
@@ -679,9 +816,21 @@ const tokenTypeDefinitions: EnumToString<AllTokenTypes> = {
     Is: { name: "Is", value: OperatorTokenType.Is },
     IsNot: { name: "IsNot", value: OperatorTokenType.IsNot },
 
-    In: { name: "In", value: OperatorTokenType.In },
     NotIn: { name: "NotIn", value: OperatorTokenType.NotIn },
 
+    Unpacking: { name: "Unpacking", value: OperatorTokenType.Unpacking },
+    PositionalParameter: { name: "PositionalParameter", value: OperatorTokenType.PositionalParameter },
+
+    Quantifier: { name: "Quantifier", value: OperatorTokenType.Quantifier },
+    Disjunction: { name: "Disjunction", value: OperatorTokenType.Disjunction },
+    Negation: { name: "Negation", value: OperatorTokenType.Negation },
+    Lookahead: { name: "Lookahead", value: OperatorTokenType.Lookahead },
+    LookaheadNegative: { name: "LookaheadNegative", value: OperatorTokenType.LookaheadNegative },
+    Lookbehind: { name: "Lookbehind", value: OperatorTokenType.Lookbehind },
+    LookbehindNegative: { name: "LookbehindNegative", value: OperatorTokenType.LookbehindNegative },
+    Conditional: { name: "Conditional", value: OperatorTokenType.Conditional },
+    ConditionalNegative: { name: "ConditionalNegative", value: OperatorTokenType.ConditionalNegative },
+
     Unknown: { name: "Unknown", value: CharacterTokenType.Unknown },
 
     OpenParentheses: { name: "OpenParentheses", value: CharacterTokenType.OpenParentheses },
@@ -693,7 +842,7 @@ const tokenTypeDefinitions: EnumToString<AllTokenTypes> = {
     OpenSquareBracket: { name: "OpenSquareBracket", value: CharacterTokenType.OpenSquareBracket },
     CloseSquareBracket: { name: "CloseSquareBracket", value: CharacterTokenType.CloseSquareBracket },
 
-    WhiteSpace: { name: "WhiteSpace", value: CharacterTokenType.WhiteSpace },
+    Whitespace: { name: "Whitespace", value: CharacterTokenType.Whitespace },
     NewLine: { name: "NewLine", value: CharacterTokenType.NewLine },
 
     Period: { name: "Period", value: CharacterTokenType.Period },
@@ -701,6 +850,10 @@ const tokenTypeDefinitions: EnumToString<AllTokenTypes> = {
     Semicolon: { name: "Semicolon", value: CharacterTokenType.Semicolon },
     Comma: { name: "Comma", value: CharacterTokenType.Comma },
     Hashtag: { name: "Hashtag", value: CharacterTokenType.Hashtag },
+    Caret: { name: "Caret", value: CharacterTokenType.Caret },
+    DollarSymbol: { name: "DollarSymbol", value: CharacterTokenType.DollarSymbol },
+    AtSymbol: { name: "AtSymbol", value: CharacterTokenType.AtSymbol },
+    EqualsSymbol: { name: "EqualsSymbol", value: CharacterTokenType.EqualsSymbol },
 
     Quote: { name: "Quote", value: CharacterTokenType.Quote },
     DoubleQuote: { name: "DoubleQuote", value: CharacterTokenType.DoubleQuote },
@@ -719,16 +872,31 @@ const tokenTypeDefinitions: EnumToString<AllTokenTypes> = {
     EscOpenBracket: { name: "EscOpenBracket", value: EscapedCharacterTokenType.EscOpenBracket },
 
     Invalid: { name: "Invalid", value: MetaTokenType.Invalid },
+    Deprecated: { name: "Deprecated", value: MetaTokenType.Deprecated },
+
     Comment: { name: "Comment", value: MetaTokenType.Comment },
-    CodeBlock: { name: "CodeBlock", value: MetaTokenType.CodeBlock },
+    CommentCodeTag: { name: "CommentCodeTag", value: MetaTokenType.CommentCodeTag },
+    CommentRegionTag: { name: "CommentRegionTag", value: MetaTokenType.CommentRegionTag },
+    TypehintComment: { name: "TypehintComment", value: MetaTokenType.TypehintComment },
+    TypehintDirective: { name: "TypehintDirective", value: MetaTokenType.TypehintDirective },
+    TypehintIgnore: { name: "TypehintIgnore", value: MetaTokenType.TypehintIgnore },
+    TypehintType: { name: "TypehintType", value: MetaTokenType.TypehintType },
+    TypehintPunctuation: { name: "TypehintPunctuation", value: MetaTokenType.TypehintPunctuation },
+    TypehintVariable: { name: "TypehintVariable", value: MetaTokenType.TypehintVariable },
+    Docstring: { name: "Docstring", value: MetaTokenType.Docstring },
+
+    StringBegin: { name: "StringBegin", value: MetaTokenType.StringBegin },
+    StringEnd: { name: "StringEnd", value: MetaTokenType.StringEnd },
 
+    CodeBlock: { name: "CodeBlock", value: MetaTokenType.CodeBlock },
     PythonLine: { name: "PythonLine", value: MetaTokenType.PythonLine },
     PythonBlock: { name: "PythonBlock", value: MetaTokenType.PythonBlock },
     Arguments: { name: "Arguments", value: MetaTokenType.Arguments },
 
-    CommentCodeTag: { name: "CommentCodeTag", value: MetaTokenType.CommentCodeTag },
     EmptyString: { name: "EmptyString", value: MetaTokenType.EmptyString },
+    StringTag: { name: "StringTag", value: MetaTokenType.StringTag },
     TagBlock: { name: "TagBlock", value: MetaTokenType.TagBlock },
+    TaggedString: { name: "TaggedString", value: MetaTokenType.TaggedString },
     Placeholder: { name: "Placeholder", value: MetaTokenType.Placeholder },
 
     MenuStatement: { name: "MenuStatement", value: MetaTokenType.MenuStatement },
@@ -736,28 +904,48 @@ const tokenTypeDefinitions: EnumToString<AllTokenTypes> = {
     MenuOption: { name: "MenuOption", value: MetaTokenType.MenuOption },
     MenuOptionBlock: { name: "MenuOptionBlock", value: MetaTokenType.MenuOptionBlock },
 
+    LabelStatement: { name: "LabelStatement", value: MetaTokenType.LabelStatement },
+    LabelCall: { name: "LabelCall", value: MetaTokenType.LabelCall },
+    LabelAccess: { name: "LabelAccess", value: MetaTokenType.LabelAccess },
+
+    BehindStatement: { name: "BehindStatement", value: MetaTokenType.BehindStatement },
+    OnlayerStatement: { name: "OnlayerStatement", value: MetaTokenType.OnlayerStatement },
+    ZorderStatement: { name: "ZorderStatement", value: MetaTokenType.ZorderStatement },
+    AtStatement: { name: "AtStatement", value: MetaTokenType.AtStatement },
+    AsStatement: { name: "AsStatement", value: MetaTokenType.AsStatement },
+    WithStatement: { name: "WithStatement", value: MetaTokenType.WithStatement },
+
+    ImageStatement: { name: "ImageStatement", value: MetaTokenType.ImageStatement },
     CameraStatement: { name: "CameraStatement", value: MetaTokenType.CameraStatement },
     SceneStatement: { name: "SceneStatement", value: MetaTokenType.SceneStatement },
     ShowStatement: { name: "ShowStatement", value: MetaTokenType.ShowStatement },
-    ImageStatement: { name: "ImageStatement", value: MetaTokenType.ImageStatement },
 
-    NarratorSayStatement: { name: "NarratorSayStatement", value: MetaTokenType.NarratorSayStatement },
-    SayStatement: { name: "SayStatement", value: MetaTokenType.SayStatement },
-    CharacterNameString: { name: "CharacterNameString", value: MetaTokenType.CharacterNameString },
-
-    CallStatement: { name: "CallStatement", value: MetaTokenType.CallStatement },
     JumpStatement: { name: "JumpStatement", value: MetaTokenType.JumpStatement },
+    CallStatement: { name: "CallStatement", value: MetaTokenType.CallStatement },
 
     PlayAudioStatement: { name: "PlayAudioStatement", value: MetaTokenType.PlayAudioStatement },
+    QueueAudioStatement: { name: "QueueAudioStatement", value: MetaTokenType.QueueAudioStatement },
     StopAudioStatement: { name: "StopAudioStatement", value: MetaTokenType.StopAudioStatement },
 
-    LabelStatement: { name: "LabelStatement", value: MetaTokenType.LabelStatement },
-    LabelCall: { name: "LabelCall", value: MetaTokenType.LabelCall },
-    LabelAccess: { name: "LabelAccess", value: MetaTokenType.LabelAccess },
+    ScreenStatement: { name: "ScreenStatement", value: MetaTokenType.ScreenStatement },
+    ScreenSensitive: { name: "ScreenSensitive", value: MetaTokenType.ScreenSensitive },
+    ScreenFrame: { name: "ScreenFrame", value: MetaTokenType.ScreenFrame },
+    ScreenWindow: { name: "ScreenWindow", value: MetaTokenType.ScreenWindow },
+    ScreenText: { name: "ScreenText", value: MetaTokenType.ScreenText },
+    ScreenBlock: { name: "ScreenBlock", value: MetaTokenType.ScreenBlock },
 
-    AtStatement: { name: "AtStatement", value: MetaTokenType.AtStatement },
-    AsStatement: { name: "AsStatement", value: MetaTokenType.AsStatement },
-    WithStatement: { name: "WithStatement", value: MetaTokenType.WithStatement },
+    NarratorSayStatement: { name: "NarratorSayStatement", value: MetaTokenType.NarratorSayStatement },
+    SayStatement: { name: "SayStatement", value: MetaTokenType.SayStatement },
+    CharacterNameString: { name: "CharacterNameString", value: MetaTokenType.CharacterNameString },
+    SayNarrator: { name: "SayNarrator", value: MetaTokenType.SayNarrator },
+    SayCharacter: { name: "SayCharacter", value: MetaTokenType.SayCharacter },
+
+    AtParameters: { name: "AtParameters", value: MetaTokenType.AtParameters },
+    AsParameters: { name: "AsParameters", value: MetaTokenType.AsParameters },
+    BehindParameters: { name: "BehindParameters", value: MetaTokenType.BehindParameters },
+    OnlayerParameters: { name: "OnlayerParameters", value: MetaTokenType.OnlayerParameters },
+    WithParameters: { name: "WithParameters", value: MetaTokenType.WithParameters },
+    ZorderParameters: { name: "ZorderParameters", value: MetaTokenType.ZorderParameters },
 
     ATLBlock: { name: "ATLBlock", value: MetaTokenType.ATLBlock },
     ATLChoiceBlock: { name: "ATLChoiceBlock", value: MetaTokenType.ATLChoiceBlock },
@@ -767,6 +955,48 @@ const tokenTypeDefinitions: EnumToString<AllTokenTypes> = {
     ATLFunction: { name: "ATLFunction", value: MetaTokenType.ATLFunction },
     ATLWarper: { name: "ATLWarper", value: MetaTokenType.ATLWarper },
     ATLOn: { name: "ATLOn", value: MetaTokenType.ATLOn },
+
+    MemberAccess: { name: "MemberAccess", value: MetaTokenType.MemberAccess },
+    ItemAccess: { name: "ItemAccess", value: MetaTokenType.ItemAccess },
+    IndexedName: { name: "IndexedName", value: MetaTokenType.IndexedName },
+    Attribute: { name: "Attribute", value: MetaTokenType.Attribute },
+    ClassDefinition: { name: "ClassDefinition", value: MetaTokenType.ClassDefinition },
+    ClassInheritance: { name: "ClassInheritance", value: MetaTokenType.ClassInheritance },
+    FunctionDefinition: { name: "FunctionDefinition", value: MetaTokenType.FunctionDefinition },
+    LambdaFunction: { name: "LambdaFunction", value: MetaTokenType.LambdaFunction },
+    FunctionLambdaParameters: { name: "FunctionLambdaParameters", value: MetaTokenType.FunctionLambdaParameters },
+    FunctionParameters: { name: "FunctionParameters", value: MetaTokenType.FunctionParameters },
+    FunctionDecorator: { name: "FunctionDecorator", value: MetaTokenType.FunctionDecorator },
+    FunctionCall: { name: "FunctionCall", value: MetaTokenType.FunctionCall },
+    FunctionCallGeneric: { name: "FunctionCallGeneric", value: MetaTokenType.FunctionCallGeneric },
+    Fstring: { name: "Fstring", value: MetaTokenType.Fstring },
+    ControlFlowKeyword: { name: "ControlFlowKeyword", value: MetaTokenType.ControlFlowKeyword },
+    LogicalOperatorKeyword: { name: "LogicalOperatorKeyword", value: MetaTokenType.LogicalOperatorKeyword },
+    Operator: { name: "Operator", value: MetaTokenType.Operator },
+    ArithmeticOperator: { name: "ArithmeticOperator", value: MetaTokenType.ArithmeticOperator },
+    BitwiseOperatorKeyword: { name: "BitwiseOperatorKeyword", value: MetaTokenType.BitwiseOperatorKeyword },
+    ComparisonOperatorKeyword: { name: "ComparisonOperatorKeyword", value: MetaTokenType.ComparisonOperatorKeyword },
+    ConstantLiteral: { name: "ConstantLiteral", value: MetaTokenType.ConstantLiteral },
+    ConstantNumeric: { name: "ConstantNumeric", value: MetaTokenType.ConstantNumeric },
+    ConstantCaps: { name: "ConstantCaps", value: MetaTokenType.ConstantCaps },
+    BuiltinExceptionType: { name: "BuiltinExceptionType", value: MetaTokenType.BuiltinExceptionType },
+    BuiltinType: { name: "BuiltinType", value: MetaTokenType.BuiltinType },
+    MagicVariable: { name: "MagicVariable", value: MetaTokenType.MagicVariable },
+    EscapeSequence: { name: "EscapeSequence", value: MetaTokenType.EscapeSequence },
+    FormatPercent: { name: "FormatPercent", value: MetaTokenType.FormatPercent },
+    FormatBrace: { name: "FormatBrace", value: MetaTokenType.FormatBrace },
+    StringStorageType: { name: "StringStorageType", value: MetaTokenType.StringStorageType },
+    FormatStorageType: { name: "FormatStorageType", value: MetaTokenType.FormatStorageType },
+    ImaginaryNumberStorageType: { name: "ImaginaryNumberStorageType", value: MetaTokenType.ImaginaryNumberStorageType },
+    NumberStorageType: { name: "NumberStorageType", value: MetaTokenType.NumberStorageType },
+    ClassStorageType: { name: "ClassStorageType", value: MetaTokenType.ClassStorageType },
+    CommentBegin: { name: "CommentBegin", value: MetaTokenType.CommentBegin },
+    CommentEnd: { name: "CommentEnd", value: MetaTokenType.CommentEnd },
+    Backreference: { name: "Backreference", value: MetaTokenType.Backreference },
+    BackreferenceNamed: { name: "BackreferenceNamed", value: MetaTokenType.BackreferenceNamed },
+    CharacterSet: { name: "CharacterSet", value: MetaTokenType.CharacterSet },
+    Named: { name: "Named", value: MetaTokenType.Named },
+    ModifierFlagStorageType: { name: "ModifierFlagStorageType", value: MetaTokenType.ModifierFlagStorageType },
 };
 
 export const tokenTypeToStringMap = Object.fromEntries(Object.entries(tokenTypeDefinitions).map(([, v]) => [v.value, v.name]));
diff --git a/src/tokenizer/python-token-patterns.g.ts b/src/tokenizer/python-token-patterns.g.ts
new file mode 100644
index 0000000..71dac1e
--- /dev/null
+++ b/src/tokenizer/python-token-patterns.g.ts
@@ -0,0 +1,3169 @@
+/* eslint-disable no-useless-escape */
+/* eslint-disable no-useless-backreference */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+// THIS FILE HAS BEEN GENERATED BY THE `syntax-to-token-pattern.py` GENERATOR
+// DO NOT EDIT THIS FILE DIRECTLY! INSTEAD RUN THE PYTHON SCRIPT.
+// ANY MANUAL EDITS MADE TO THIS FILE WILL BE OVERWRITTEN. YOU HAVE BEEN WARNED.
+// Last generated: 01/06/2023 14:57:48 (UTC+0)
+
+import { MetaTokenType, KeywordTokenType, EntityTokenType, CharacterTokenType, OperatorTokenType, LiteralTokenType } from "./renpy-tokens";
+import { TokenPattern } from "./token-pattern-types";
+
+export const python: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const impossible: TokenPattern = {
+    debugName: "impossible",
+
+    // This is a special rule that should be used where no match is desired. It is not a good idea to match something like '1{0}' because in some cases that can result in infinite loops in token generation. So the rule instead matches and impossible expression to allow a match to fail and move to the next token.
+    match: /$.^/gm,
+};
+
+export const statement: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const semicolon: TokenPattern = {
+    patterns: [
+        {
+            debugName: "semicolon.patterns![0]",
+
+            token: MetaTokenType.Deprecated, /*invalid.deprecated.semicolon.python*/
+            match: /\;$/gm,
+        },
+    ]
+};
+
+export const comments: TokenPattern = {
+    patterns: [
+        {
+            debugName: "comments.patterns![0]",
+
+            token: MetaTokenType.Comment, /*comment.line.number-sign.renpy*/
+            match: /^[ \t]*(#[ \t]*(?:end)?region)\b.*$/dgm,
+            captures: {
+                1: { token: MetaTokenType.CommentRegionTag, /*punctuation.definition.tag.region*/ },
+            },
+        },
+        {
+            debugName: "comments.patterns![1]",
+
+            token: MetaTokenType.Comment, /*comment.line.number-sign.python*/
+            contentToken: MetaTokenType.TypehintComment, /*meta.typehint.comment.python*/
+            begin: /(?:\#\s*(type:)\s*(?!$|\#))/dgm,
+            beginCaptures: {
+                0: { token: MetaTokenType.TypehintComment, /*meta.typehint.comment.python*/ },
+                1: { token: MetaTokenType.TypehintDirective, /*comment.typehint.directive.notation.python*/ },
+            },
+            end: /(?:$|(?=\#))/gm,
+            patterns: [
+                {
+                    debugName: "comments.patterns![1].patterns![0]",
+
+                    token: MetaTokenType.TypehintIgnore, /*comment.typehint.ignore.notation.python*/
+                    match: /ignore(?=\s*(?:$|\#))/gm,
+                },
+                {
+                    debugName: "comments.patterns![1].patterns![1]",
+
+                    token: MetaTokenType.TypehintType, /*comment.typehint.type.notation.python*/
+                    match: /(?<!\.)\b(bool|bytes|float|int|object|str|List|Dict|Iterable|Sequence|Set|FrozenSet|Callable|Union|Tuple|Any|None)\b/g,
+                },
+                {
+                    debugName: "comments.patterns![1].patterns![2]",
+
+                    token: MetaTokenType.TypehintPunctuation, /*comment.typehint.punctuation.notation.python*/
+                    match: /([\[\]\(\),\.\=\*]|(->))/g,
+                },
+                {
+                    debugName: "comments.patterns![1].patterns![3]",
+
+                    token: MetaTokenType.TypehintVariable, /*comment.typehint.variable.notation.python*/
+                    match: /([a-zA-Z_]\w*)/g,
+                },
+            ]
+        },
+    ]
+};
+
+export const docstringStatement: TokenPattern = {
+    debugName: "docstringStatement",
+
+    // the string either terminates correctly or by the beginning of a new line (this is for single line docstrings that aren't terminated) AND it's not followed by another docstring
+    begin: /^(?=\s*[rR]?(\'\'\'|\"\"\"|\'|\"))/gm,
+    end: /((?<=\1)|^)(?!\s*[rR]?(\'\'\'|\"\"\"|\'|\"))/gm,
+    patterns: [
+    ]
+};
+
+export const docstring: TokenPattern = {
+    patterns: [
+        {
+            debugName: "docstring.patterns![0]",
+
+            token: MetaTokenType.Docstring, /*string.quoted.docstring.multi.python*/
+            begin: /(\'\'\'|\"\"\")/dg,
+            beginCaptures: {
+                1: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+            },
+            end: /(\1)/dg,
+            endCaptures: {
+                1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+            },
+            patterns: [
+            ]
+        },
+        {
+            debugName: "docstring.patterns![1]",
+
+            token: MetaTokenType.Docstring, /*string.quoted.docstring.raw.multi.python*/
+            begin: /([rR])(\'\'\'|\"\"\")/dg,
+            beginCaptures: {
+                1: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+                2: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+            },
+            end: /(\2)/dg,
+            endCaptures: {
+                1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+            },
+            patterns: [
+            ]
+        },
+        {
+            debugName: "docstring.patterns![2]",
+
+            token: MetaTokenType.Docstring, /*string.quoted.docstring.single.python*/
+            begin: /(\'|\")/dg,
+            beginCaptures: {
+                1: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+            },
+            end: /(\1)|(\n)/dg,
+            endCaptures: {
+                1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+                2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+            },
+            patterns: [
+            ]
+        },
+        {
+            debugName: "docstring.patterns![3]",
+
+            token: MetaTokenType.Docstring, /*string.quoted.docstring.raw.single.python*/
+            begin: /([rR])(\'|\")/dg,
+            beginCaptures: {
+                1: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+                2: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+            },
+            end: /(\2)|(\n)/dg,
+            endCaptures: {
+                1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+                2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+            },
+            patterns: []
+        }]
+};
+
+export const docstringGutsUnicode: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const docstringPrompt: TokenPattern = {
+    debugName: "docstringPrompt",
+
+    match: /(?:\s*((?:>>>|\.\.\.)\s)(?=\s*\S))/dg,
+    captures: {
+        1: { token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.python*/ },
+    },
+};
+
+export const statementKeyword: TokenPattern = {
+    patterns: [
+        {
+            debugName: "statementKeyword.patterns![0]",
+
+            token: KeywordTokenType.Def, /*storage.type.function.python*/
+            match: /\b((async\s+)?\s*def)\b/g,
+        },
+        {
+            debugName: "statementKeyword.patterns![1]",
+
+            // if `as` is eventually followed by `:` or line continuation, it's probably control flow like:    with foo as bar, \
+            //          Foo as Bar:      try:        do_stuff()      except Exception as e:        pass
+            token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.python*/
+            match: /\b(?<!\.)as\b(?=.*[:\\])/g,
+        },
+        {
+            debugName: "statementKeyword.patterns![2]",
+
+            // other legal use of `as` is in an import
+            token: KeywordTokenType.Import, /*keyword.control.import.python*/
+            match: /\b(?<!\.)as\b/g,
+        },
+        {
+            debugName: "statementKeyword.patterns![3]",
+
+            token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.python*/
+            match: /\b(?<!\.)(async|continue|del|assert|break|finally|for|from|elif|else|if|except|pass|raise|return|try|while|with)\b/g,
+        },
+        {
+            debugName: "statementKeyword.patterns![4]",
+
+            match: /\b(?<!\.)(?:(global)|(nonlocal))\b/dg,
+            captures: {
+                1: { token: KeywordTokenType.Global, /*storage.modifier.declaration.global.python*/ },
+                2: { token: KeywordTokenType.Nonlocal, /*storage.modifier.declaration.nonlocal.python*/ },
+            },
+        },
+        {
+            debugName: "statementKeyword.patterns![5]",
+
+            token: KeywordTokenType.Class, /*storage.type.class.python*/
+            match: /\b(?<!\.)(class)\b/g,
+        },
+        {
+            debugName: "statementKeyword.patterns![6]",
+
+            match: /^\s*(case|match)(?=\s*([-+\w\d(\[{'":#]|$))\b/dgm,
+            captures: {
+                1: { token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.python*/ },
+            },
+        },
+    ]
+};
+
+export const expressionBare: TokenPattern = {
+    // valid Python expressions w/o comments and line continuation
+    patterns: [
+    ]
+};
+
+export const expressionBase: TokenPattern = {
+    // valid Python expressions with comments and line continuation
+    patterns: [
+        comments,
+        expressionBare,
+    ]
+};
+
+export const expression: TokenPattern = {
+    // All valid Python expressions
+    patterns: [
+        expressionBase,
+        {
+            debugName: "expression.patterns![2]",
+
+            // Tokenize identifiers to help linters
+            token: EntityTokenType.VariableName, /*variable.name.python*/
+            match: /\b([a-zA-Z_]\w*)\b/g,
+        },
+    ]
+};
+
+export const memberAccess: TokenPattern = {
+    debugName: "memberAccess",
+
+    token: MetaTokenType.MemberAccess, /*meta.member.access.python*/
+    begin: /(\.)\s*(?!\.)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Period, /*punctuation.separator.period.python*/ },
+    },
+    end: /(?<=\S)(?=\W)|(^|(?<=\s))(?=[^\\\w\s])|$/gm,
+    patterns: [
+    ]
+};
+
+export const memberAccessBase: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const memberAccessAttribute: TokenPattern = {
+    debugName: "memberAccessAttribute",
+
+    // Highlight attribute access in otherwise non-specialized cases.
+    token: MetaTokenType.Attribute, /*meta.attribute.python*/
+    match: /\b([a-zA-Z_]\w*)\b/g,
+};
+
+export const specialNames: TokenPattern = {
+    debugName: "specialNames",
+
+    token: MetaTokenType.ConstantCaps, /*constant.other.caps.python*/
+    match: /\b(_*[A-Z][_\d]*[A-Z])[A-Z\d]*(_\w*)?\b/g,
+};
+
+export const curlyBraces: TokenPattern = {
+    debugName: "curlyBraces",
+
+    begin: /\{/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.dict.begin.python*/ },
+    },
+    end: /\}/dg,
+    endCaptures: {
+        0: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.dict.end.python*/ },
+    },
+    patterns: [
+        {
+            debugName: "curlyBraces.patterns![0]",
+
+            token: CharacterTokenType.Colon, /*punctuation.separator.dict.python*/
+            match: /:/g,
+        },
+        expression,
+    ]
+};
+
+export const list: TokenPattern = {
+    debugName: "list",
+
+    begin: /\[/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenSquareBracket, /*punctuation.definition.list.begin.python*/ },
+    },
+    end: /\]/dg,
+    endCaptures: {
+        0: { token: CharacterTokenType.CloseSquareBracket, /*punctuation.definition.list.end.python*/ },
+    },
+    patterns: [expression]
+};
+
+export const oddFunctionCall: TokenPattern = {
+    debugName: "oddFunctionCall",
+
+    // A bit obscured function call where there may have been anarbitrary number of other operations to get the function.E.g. "arr[idx](args)"
+    begin: /(?<=\]|\))\s*(?=\()/g,
+    end: /(\))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*punctuation.definition.arguments.end.python*/ },
+    },
+    patterns: [
+    ]
+};
+
+export const roundBraces: TokenPattern = {
+    debugName: "roundBraces",
+
+    begin: /\(/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.python*/ },
+    },
+    end: /\)/dg,
+    endCaptures: {
+        0: { token: CharacterTokenType.CloseParentheses, /*punctuation.parenthesis.end.python*/ },
+    },
+    patterns: [expression]
+};
+
+export const lineContinuation: TokenPattern = {
+    patterns: [
+        {
+            debugName: "lineContinuation.patterns![0]",
+
+            match: /(\\)\s*(\S.*$\n?)/dgm,
+            captures: {
+                1: { token: CharacterTokenType.Backslash, /*punctuation.separator.continuation.line.python*/ },
+                2: { token: MetaTokenType.Invalid, /*invalid.illegal.line.continuation.python*/ },
+            },
+        },
+        {
+            debugName: "lineContinuation.patterns![1]",
+
+            begin: /(\\)\s*$\n?/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.Backslash, /*punctuation.separator.continuation.line.python*/ },
+            },
+            end: /(?=^\s*$)|(?!(\s*[rR]?(\'\'\'|\"\"\"|\'|\"))|((?<=\\\s*)$))/gm,
+            patterns: []
+        }]
+};
+
+export const assignmentOperator: TokenPattern = {
+    debugName: "assignmentOperator",
+
+    token: OperatorTokenType.Assignment, /*keyword.operator.assignment.python*/
+    match: /<<=|>>=|\/\/=|\*\*=|\+=|-=|\/=|@=|\*=|%=|~=|\^=|&=|\|=|=(?!=)/gm,
+};
+
+export const operator: TokenPattern = {
+    debugName: "operator",
+
+    match: /\b(?<!\.)(?:(and|or|not|in|is)|(for|if|else|await|(?:yield(?:\s+from)?)))(?!\s*:)\b|(<<|>>|&|\||\^|~)|(\*\*|\*|\+|-|%|\/\/|\/|@)|(!=|==|>=|<=|<|>)|(:=)/dgm,
+    captures: {
+        1: { token: MetaTokenType.LogicalOperatorKeyword, /*keyword.operator.logical.python*/ },
+        2: { token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.python*/ },
+        3: { token: MetaTokenType.BitwiseOperatorKeyword, /*keyword.operator.bitwise.python*/ },
+        4: { token: MetaTokenType.ArithmeticOperator, /*keyword.operator.arithmetic.python*/ },
+        5: { token: MetaTokenType.ComparisonOperatorKeyword, /*keyword.operator.comparison.python*/ },
+        6: { token: OperatorTokenType.Assignment, /*keyword.operator.assignment.python*/ },
+    },
+};
+
+export const punctuation: TokenPattern = {
+    patterns: [
+        {
+            debugName: "punctuation.patterns![0]",
+
+            token: CharacterTokenType.Colon, /*punctuation.separator.colon.python*/
+            match: /:/g,
+        },
+        {
+            debugName: "punctuation.patterns![1]",
+
+            token: CharacterTokenType.Comma, /*punctuation.separator.element.python*/
+            match: /,/g,
+        },
+    ]
+};
+
+export const literal: TokenPattern = {
+    patterns: [
+        {
+            debugName: "literal.patterns![0]",
+
+            token: MetaTokenType.ConstantLiteral, /*constant.language.python*/
+            match: /\b(True|False|None|NotImplemented|Ellipsis)\b/g,
+        },
+    ]
+};
+
+export const number: TokenPattern = {
+    patterns: [
+        {
+            debugName: "number.patterns![6]",
+
+            token: MetaTokenType.Invalid, /*invalid.illegal.name.python*/
+            match: /\b[0-9]+\w+/g,
+        },
+    ]
+};
+
+export const numberFloat: TokenPattern = {
+    debugName: "numberFloat",
+
+    token: LiteralTokenType.Float, /*constant.numeric.float.python*/
+    match: /(?<!\w)(?:(?:\.[0-9](?:_?[0-9])*|[0-9](?:_?[0-9])*\.[0-9](?:_?[0-9])*|[0-9](?:_?[0-9])*\.)(?:[eE][+-]?[0-9](?:_?[0-9])*)?|[0-9](?:_?[0-9])*(?:[eE][+-]?[0-9](?:_?[0-9])*))([jJ])?\b/dg,
+    captures: {
+        1: { token: MetaTokenType.ImaginaryNumberStorageType, /*storage.type.imaginary.number.python*/ },
+    },
+};
+
+export const numberDec: TokenPattern = {
+    debugName: "numberDec",
+
+    token: MetaTokenType.ConstantNumeric, /*constant.numeric.dec.python*/
+    match: /(?<![\w.])(?:[1-9](?:_?[0-9])*|0+|[0-9](?:_?[0-9])*([jJ])|0([0-9]+)(?![eE.]))\b/dg,
+    captures: {
+        1: { token: MetaTokenType.ImaginaryNumberStorageType, /*storage.type.imaginary.number.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.dec.python*/ },
+    },
+};
+
+export const numberHex: TokenPattern = {
+    debugName: "numberHex",
+
+    token: MetaTokenType.ConstantNumeric, /*constant.numeric.hex.python*/
+    match: /(?<![\w.])(0[xX])(_?[0-9a-fA-F])+\b/dg,
+    captures: {
+        1: { token: MetaTokenType.NumberStorageType, /*storage.type.number.python*/ },
+    },
+};
+
+export const numberOct: TokenPattern = {
+    debugName: "numberOct",
+
+    token: MetaTokenType.ConstantNumeric, /*constant.numeric.oct.python*/
+    match: /(?<![\w.])(0[oO])(_?[0-7])+\b/dg,
+    captures: {
+        1: { token: MetaTokenType.NumberStorageType, /*storage.type.number.python*/ },
+    },
+};
+
+export const numberBin: TokenPattern = {
+    debugName: "numberBin",
+
+    token: MetaTokenType.ConstantNumeric, /*constant.numeric.bin.python*/
+    match: /(?<![\w.])(0[bB])(_?[01])+\b/dg,
+    captures: {
+        1: { token: MetaTokenType.NumberStorageType, /*storage.type.number.python*/ },
+    },
+};
+
+export const numberLong: TokenPattern = {
+    debugName: "numberLong",
+
+    // this is to support python2 syntax for long ints
+    token: MetaTokenType.ConstantNumeric, /*constant.numeric.bin.python*/
+    match: /(?<![\w.])([1-9][0-9]*|0)([lL])\b/dg,
+    captures: {
+        2: { token: MetaTokenType.NumberStorageType, /*storage.type.number.python*/ },
+    },
+};
+
+export const regexp: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const string: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const stringUnicodeGuts: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const stringConsumeEscape: TokenPattern = {
+    debugName: "stringConsumeEscape",
+
+    match: /\\['"\n\\]/g,
+};
+
+export const stringRawGuts: TokenPattern = {
+    patterns: [stringConsumeEscape]
+};
+
+export const stringRawBinGuts: TokenPattern = {
+    patterns: [stringConsumeEscape]
+};
+
+export const stringEntity: TokenPattern = {
+    patterns: []
+};
+
+export const fstringGuts: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const fstringRawGuts: TokenPattern = {
+    patterns: [
+        stringConsumeEscape]
+};
+
+export const fstringIllegalSingleBrace: TokenPattern = {
+    debugName: "fstringIllegalSingleBrace",
+
+    // it is illegal to have a multiline brace inside a single-line string
+    begin: /(\{)(?=[^\n}]*$\n?)/dgm,
+    beginCaptures: {
+        1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+    },
+    end: /(\})|(?=\n)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+    },
+    patterns: []
+};
+
+export const fstringIllegalMultiBrace: TokenPattern = {
+    patterns: [
+        impossible]
+};
+
+export const fExpression: TokenPattern = {
+    // All valid Python expressions, except comments and line continuation
+    patterns: [
+        expressionBare,
+        memberAccess,
+        {
+            debugName: "fExpression.patterns![2]",
+
+            // Tokenize identifiers to help linters
+            match: /\b([a-zA-Z_]\w*)\b/g,
+        },
+    ]
+};
+
+export const escapeSequenceUnicode: TokenPattern = {
+    patterns: [
+        {
+            debugName: "escapeSequenceUnicode.patterns![0]",
+
+            token: MetaTokenType.EscapeSequence, /*constant.character.escape.python*/
+            match: /\\(u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8}|N\{[\w\s]+?\})/g,
+        },
+    ]
+};
+
+export const escapeSequence: TokenPattern = {
+    debugName: "escapeSequence",
+
+    token: MetaTokenType.EscapeSequence, /*constant.character.escape.python*/
+    match: /\\(x[0-9A-Fa-f]{2}|[0-7]{1,3}|[\\"'abfnrtv])/g,
+};
+
+export const stringLineContinuation: TokenPattern = {
+    debugName: "stringLineContinuation",
+
+    token: MetaTokenType.ConstantLiteral, /*constant.language.python*/
+    match: /\\$/gm,
+};
+
+export const stringFormatting: TokenPattern = {
+    debugName: "stringFormatting",
+
+    token: MetaTokenType.FormatPercent, /*meta.format.percent.python*/
+    match: /(%(\([\w\s]*\))?[-+#0 ]*(\d+|\*)?(\.(\d+|\*))?([hlL])?[diouxXeEfFgGcrsab%])/dg,
+    captures: {
+        1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+    },
+};
+
+export const stringBraceFormatting: TokenPattern = {
+    patterns: [
+        {
+            debugName: "stringBraceFormatting.patterns![0]",
+
+            token: MetaTokenType.FormatBrace, /*meta.format.brace.python*/
+            match: /({{|}}|(?:{\w*(\.[a-zA-Z_]\w*|\[[^\]'"]+\])*(![rsa])?(:\w?[<>=^]?[-+ ]?\#?\d*,?(\.\d+)?[bcdeEfFgGnosxX%]?)?}))/dgm,
+            captures: {
+                1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+                3: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+                4: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+            },
+        },
+        {
+            debugName: "stringBraceFormatting.patterns![1]",
+
+            token: MetaTokenType.FormatBrace, /*meta.format.brace.python*/
+            match: /({\w*(\.[a-zA-Z_]\w*|\[[^\]'"]+\])*(![rsa])?(:)[^'"{}\n]*(?:\{[^'"}\n]*?\}[^'"{}\n]*)*})/dg,
+            captures: {
+                1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+                3: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+                4: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+            },
+        },
+    ]
+};
+
+export const fstringFormatting: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const fstringFormattingSingeBrace: TokenPattern = {
+    debugName: "fstringFormattingSingeBrace",
+
+    token: MetaTokenType.Invalid, /*invalid.illegal.brace.python*/
+    match: /(}(?!}))/g,
+};
+
+export const importStatement: TokenPattern = {
+    // Import statements used to correctly mark `from`, `import`, and `as`
+    patterns: [
+        {
+            debugName: "importStatement.patterns![0]",
+
+            begin: /\b(?<!\.)(from)\b(?=.+import)/dg,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Import, /*keyword.control.import.python*/ },
+            },
+            end: /$|(?=import)/gm,
+            patterns: [
+                {
+                    debugName: "importStatement.patterns![0].patterns![0]",
+
+                    token: CharacterTokenType.Period, /*punctuation.separator.period.python*/
+                    match: /\.+/g,
+                },
+                expression,
+            ]
+        },
+        {
+            debugName: "importStatement.patterns![1]",
+
+            begin: /\b(?<!\.)(import)\b/dg,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Import, /*keyword.control.import.python*/ },
+            },
+            end: /$/gm,
+            patterns: [
+                {
+                    debugName: "importStatement.patterns![1].patterns![0]",
+
+                    token: KeywordTokenType.Import, /*keyword.control.import.python*/
+                    match: /\b(?<!\.)as\b/g,
+                },
+                expression,
+            ]
+        },
+    ]
+};
+
+export const classDeclaration: TokenPattern = {
+    patterns: [
+        {
+            debugName: "classDeclaration.patterns![0]",
+
+            token: MetaTokenType.ClassDefinition, /*meta.class.python*/
+            begin: /\s*(class)\s+(?=[a-zA-Z_]\w*\s*(:|\())/dg,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Class, /*storage.type.class.python*/ },
+            },
+            end: /(:)/dg,
+            endCaptures: {
+                1: { token: CharacterTokenType.Colon, /*punctuation.section.class.begin.python*/ },
+            },
+            patterns: []
+        }]
+};
+
+export const className: TokenPattern = {
+    patterns: [
+        {
+            debugName: "className.patterns![2]",
+
+            token: EntityTokenType.ClassName, /*entity.name.type.class.python*/
+            match: /\b([a-zA-Z_]\w*)\b/g,
+        },
+    ]
+};
+
+export const classInheritance: TokenPattern = {
+    debugName: "classInheritance",
+
+    token: MetaTokenType.ClassInheritance, /*meta.class.inheritance.python*/
+    begin: /(\()/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.inheritance.begin.python*/ },
+    },
+    end: /(\))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.inheritance.end.python*/ },
+    },
+    patterns: [
+        {
+            debugName: "classInheritance.patterns![0]",
+
+            token: OperatorTokenType.Unpacking, /*keyword.operator.unpacking.arguments.python*/
+            match: /(\*\*|\*)/g,
+        },
+        {
+            debugName: "classInheritance.patterns![1]",
+
+            token: CharacterTokenType.Comma, /*punctuation.separator.inheritance.python*/
+            match: /,/g,
+        },
+        {
+            debugName: "classInheritance.patterns![2]",
+
+            token: OperatorTokenType.Assignment, /*keyword.operator.assignment.python*/
+            match: /=(?!=)/g,
+        },
+        {
+            debugName: "classInheritance.patterns![3]",
+
+            token: KeywordTokenType.Metaclass, /*support.type.metaclass.python*/
+            match: /\bmetaclass\b/g,
+        },
+        expressionBase,
+    ]
+};
+
+export const classKwarg: TokenPattern = {
+    debugName: "classKwarg",
+
+    match: /\b([a-zA-Z_]\w*)\s*(=)(?!=)/dg,
+    captures: {
+        1: { token: EntityTokenType.VariableName, /*entity.other.inherited-class.python variable.parameter.class.python*/ },
+        2: { token: OperatorTokenType.Assignment, /*keyword.operator.assignment.python*/ },
+    },
+};
+
+export const inheritanceIdentifier: TokenPattern = {
+    debugName: "inheritanceIdentifier",
+
+    match: /\b([a-zA-Z_]\w*)\b/dg,
+    captures: {
+        1: { token: EntityTokenType.InheritedClassName, /*entity.other.inherited-class.python*/ },
+    },
+};
+
+export const memberAccessClass: TokenPattern = {
+    debugName: "memberAccessClass",
+
+    token: MetaTokenType.MemberAccess, /*meta.member.access.python*/
+    begin: /(\.)\s*(?!\.)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Period, /*punctuation.separator.period.python*/ },
+    },
+    end: /(?<=\S)(?=\W)|$/gm,
+    patterns: [
+        memberAccessBase,
+        inheritanceIdentifier,
+    ]
+};
+
+export const lambda: TokenPattern = {
+    patterns: [
+        {
+            debugName: "lambda.patterns![0]",
+
+            match: /((?<=\.)lambda|lambda(?=\s*[\.=]))/dg,
+            captures: {
+                1: { token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.python*/ },
+            },
+        },
+        {
+            debugName: "lambda.patterns![1]",
+
+            match: /\b(lambda)\s*?(?=[,\n]|$)/dgm,
+            captures: {
+                1: { token: KeywordTokenType.Lambda, /*storage.type.function.lambda.python*/ },
+            },
+        },
+        {
+            debugName: "lambda.patterns![2]",
+
+            token: MetaTokenType.LambdaFunction, /*meta.lambda-function.python*/
+            contentToken: MetaTokenType.FunctionDefinition, /*meta.function.lambda.parameters.python*/
+            begin: /\b(lambda)\b/dg,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Lambda, /*storage.type.function.lambda.python*/ },
+            },
+            end: /(:)|(\n)/dg,
+            endCaptures: {
+                1: { token: CharacterTokenType.Colon, /*punctuation.section.function.lambda.begin.python*/ },
+            },
+            patterns: [
+                {
+                    debugName: "lambda.patterns![2].patterns![0]",
+
+                    token: OperatorTokenType.PositionalParameter, /*keyword.operator.positional.parameter.python*/
+                    match: /\//g,
+                },
+                {
+                    debugName: "lambda.patterns![2].patterns![1]",
+
+                    token: OperatorTokenType.Unpacking, /*keyword.operator.unpacking.parameter.python*/
+                    match: /(\*\*|\*)/g,
+                },
+                {
+                    debugName: "lambda.patterns![2].patterns![4]",
+
+                    match: /([a-zA-Z_]\w*)\s*(?:(,)|(?=:|$))/dgm,
+                    captures: {
+                        1: { token: EntityTokenType.VariableName, /*variable.parameter.function.language.python*/ },
+                        2: { token: CharacterTokenType.Comma, /*punctuation.separator.parameters.python*/ },
+                    },
+                },
+                comments,
+                lineContinuation,
+            ]
+        },
+    ]
+};
+
+export const lambdaIncomplete: TokenPattern = {
+    debugName: "lambdaIncomplete",
+
+    token: KeywordTokenType.Lambda, /*storage.type.function.lambda.python*/
+    match: /\blambda(?=\s*[,)])/g,
+};
+
+export const lambdaNestedIncomplete: TokenPattern = {
+    debugName: "lambdaNestedIncomplete",
+
+    token: KeywordTokenType.Lambda, /*storage.type.function.lambda.python*/
+    match: /\blambda(?=\s*[:,)])/g,
+};
+
+export const lambdaParameterWithDefault: TokenPattern = {
+    debugName: "lambdaParameterWithDefault",
+
+    begin: /\b([a-zA-Z_]\w*)\s*(=)/dg,
+    beginCaptures: {
+        1: { token: EntityTokenType.VariableName, /*variable.parameter.function.language.python*/ },
+        2: { token: MetaTokenType.Operator, /*keyword.operator.python*/ },
+    },
+    end: /(,)|(?=:|$)/dgm,
+    endCaptures: {
+        1: { token: CharacterTokenType.Comma, /*punctuation.separator.parameters.python*/ },
+    },
+    patterns: [expression]
+};
+
+export const generator: TokenPattern = {
+    debugName: "generator",
+
+    // Match "for ... in" construct used in generators and for loops to correctly identify the "in" as a control flow keyword.
+    begin: /\bfor\b/dg,
+    beginCaptures: {
+        0: { token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.python*/ },
+    },
+    end: /\bin\b/dg,
+    endCaptures: {
+        0: { token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.python*/ },
+    },
+    patterns: [expression]
+};
+
+export const functionDeclaration: TokenPattern = {
+    debugName: "functionDeclaration",
+
+    token: MetaTokenType.FunctionDefinition, /*meta.function.python*/
+    begin: /\s*(?:\b(async)\s+)?\b(def)\s+(?=\w+\s*\()/dg,
+    beginCaptures: {
+        1: { token: KeywordTokenType.Async, /*storage.type.function.async.python*/ },
+        2: { token: KeywordTokenType.Def, /*storage.type.function.python*/ },
+    },
+    end: /(:|(?=[#'"\n]))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.Colon, /*punctuation.section.function.begin.python*/ },
+    },
+    patterns: [lineContinuation]
+};
+
+export const functionDefName: TokenPattern = {
+    patterns: [
+        {
+            debugName: "functionDefName.patterns![2]",
+
+            token: EntityTokenType.FunctionName, /*entity.name.function.python*/
+            match: /\b([a-zA-Z_]\w*)\b/g,
+        },
+    ]
+};
+
+export const parameters: TokenPattern = {
+    debugName: "parameters",
+
+    token: MetaTokenType.FunctionDefinition, /*meta.function.parameters.python*/
+    begin: /(\()/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.definition.parameters.begin.python*/ },
+    },
+    end: /(\))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*punctuation.definition.parameters.end.python*/ },
+    },
+    patterns: [
+        {
+            debugName: "parameters.patterns![0]",
+
+            token: OperatorTokenType.PositionalParameter, /*keyword.operator.positional.parameter.python*/
+            match: /\//g,
+        },
+        {
+            debugName: "parameters.patterns![1]",
+
+            token: OperatorTokenType.Unpacking, /*keyword.operator.unpacking.parameter.python*/
+            match: /(\*\*|\*)/g,
+        },
+        lambdaIncomplete,
+        {
+            debugName: "parameters.patterns![6]",
+
+            match: /([a-zA-Z_]\w*)\s*(?:(,)|(?=[)#\n=]))/dg,
+            captures: {
+                1: { token: EntityTokenType.VariableName, /*variable.parameter.function.language.python*/ },
+                2: { token: CharacterTokenType.Comma, /*punctuation.separator.parameters.python*/ },
+            },
+        },
+        comments,
+    ]
+};
+
+export const parameterSpecial: TokenPattern = {
+    debugName: "parameterSpecial",
+
+    match: /\b((self)|(cls))\b\s*(?:(,)|(?=\)))/dg,
+    captures: {
+        1: { token: EntityTokenType.VariableName, /*variable.parameter.function.language.python*/ },
+        2: { token: EntityTokenType.VariableName, /*variable.parameter.function.language.special.self.python*/ },
+        3: { token: EntityTokenType.VariableName, /*variable.parameter.function.language.special.cls.python*/ },
+        4: { token: CharacterTokenType.Comma, /*punctuation.separator.parameters.python*/ },
+    },
+};
+
+export const looseDefault: TokenPattern = {
+    debugName: "looseDefault",
+
+    begin: /(=)/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.Operator, /*keyword.operator.python*/ },
+    },
+    end: /(,)|(?=\))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.Comma, /*punctuation.separator.parameters.python*/ },
+    },
+    patterns: [expression]
+};
+
+export const annotatedParameter: TokenPattern = {
+    debugName: "annotatedParameter",
+
+    begin: /\b([a-zA-Z_]\w*)\s*(:)/dg,
+    beginCaptures: {
+        1: { token: EntityTokenType.VariableName, /*variable.parameter.function.language.python*/ },
+        2: { token: CharacterTokenType.Colon, /*punctuation.separator.annotation.python*/ },
+    },
+    end: /(,)|(?=\))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.Comma, /*punctuation.separator.parameters.python*/ },
+    },
+    patterns: [
+        expression,
+        {
+            debugName: "annotatedParameter.patterns![1]",
+
+            token: OperatorTokenType.Assignment, /*keyword.operator.assignment.python*/
+            match: /=(?!=)/g,
+        },
+    ]
+};
+
+export const returnAnnotation: TokenPattern = {
+    debugName: "returnAnnotation",
+
+    begin: /(->)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Colon, /*punctuation.separator.annotation.result.python*/ },
+    },
+    end: /(?=:)/g,
+    patterns: [expression]
+};
+
+export const itemAccess: TokenPattern = {
+    patterns: [
+        {
+            debugName: "itemAccess.patterns![0]",
+
+            token: MetaTokenType.ItemAccess, /*meta.item-access.python*/
+            begin: /\b(?=[a-zA-Z_]\w*\s*\[)/g,
+            end: /(\])/dg,
+            endCaptures: {
+                1: { token: CharacterTokenType.CloseParentheses, /*punctuation.definition.arguments.end.python*/ },
+            },
+            patterns: [expression]
+        },
+    ]
+};
+
+export const itemName: TokenPattern = {
+    patterns: [
+        specialNames,
+        {
+            debugName: "itemName.patterns![3]",
+
+            token: MetaTokenType.IndexedName, /*meta.indexed-name.python*/
+            match: /\b([a-zA-Z_]\w*)\b/g,
+        },
+    ]
+};
+
+export const itemIndex: TokenPattern = {
+    debugName: "itemIndex",
+
+    contentToken: MetaTokenType.Arguments, /*meta.item-access.arguments.python*/
+    begin: /(\[)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.definition.arguments.begin.python*/ },
+    },
+    end: /(?=\])/g,
+    patterns: [
+        {
+            debugName: "itemIndex.patterns![0]",
+
+            token: CharacterTokenType.Colon, /*punctuation.separator.slice.python*/
+            match: /:/g,
+        },
+        expression,
+    ]
+};
+
+export const decorator: TokenPattern = {
+    debugName: "decorator",
+
+    token: MetaTokenType.FunctionDefinition, /*meta.function.decorator.python*/
+    begin: /^\s*((@))\s*(?=[a-zA-Z_]\w*)/dgm,
+    beginCaptures: {
+        1: { token: EntityTokenType.FunctionName, /*entity.name.function.decorator.python*/ },
+        2: { token: CharacterTokenType.AtSymbol, /*punctuation.definition.decorator.python*/ },
+    },
+    end: /(\))(?:(.*?)(?=\s*(?:\#|$)))|(?=\n|\#)/dgm,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*punctuation.definition.arguments.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.decorator.python*/ },
+    },
+    patterns: [
+    ]
+};
+
+export const decoratorName: TokenPattern = {
+    patterns: [
+        {
+            debugName: "decoratorName.patterns![2]",
+
+            token: EntityTokenType.FunctionName, /*entity.name.function.decorator.python*/
+            match: /([a-zA-Z_]\w*)|(\.)/dg,
+            captures: {
+                2: { token: CharacterTokenType.Period, /*punctuation.separator.period.python*/ },
+            },
+        },
+        lineContinuation,
+        {
+            debugName: "decoratorName.patterns![4]",
+
+            token: MetaTokenType.Invalid, /*invalid.illegal.decorator.python*/
+            match: /\s*([^(a-zA-Z\s_\.#\\].*?)(?=\#|$)/dgm,
+            captures: {
+                1: { token: MetaTokenType.Invalid, /*invalid.illegal.decorator.python*/ },
+            },
+        },
+    ]
+};
+
+export const callWrapperInheritance: TokenPattern = {
+    debugName: "callWrapperInheritance",
+
+    // same as a function call, but in inheritance context
+    token: MetaTokenType.FunctionCall, /*meta.function-call.python*/
+    begin: /\b(?=([a-zA-Z_]\w*)\s*(\())/g,
+    end: /(\))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*punctuation.definition.arguments.end.python*/ },
+    },
+    patterns: [
+    ]
+};
+
+export const inheritanceName: TokenPattern = {
+    patterns: [
+        lambdaIncomplete,
+        inheritanceIdentifier,
+    ]
+};
+
+export const functionCall: TokenPattern = {
+    debugName: "functionCall",
+
+    // Regular function call of the type "name(args)"
+    token: MetaTokenType.FunctionCall, /*meta.function-call.python*/
+    begin: /\b(?=([a-zA-Z_]\w*)\s*(\())/g,
+    end: /(\))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*punctuation.definition.arguments.end.python*/ },
+    },
+    patterns: [
+    ]
+};
+
+export const functionName: TokenPattern = {
+    patterns: [
+        {
+            debugName: "functionName.patterns![1]",
+
+            // Some color schemas support meta.function-call.generic scope
+            token: MetaTokenType.FunctionCall, /*meta.function-call.generic.python*/
+            match: /\b([a-zA-Z_]\w*)\b/g,
+        },
+    ]
+};
+
+export const functionArguments: TokenPattern = {
+    debugName: "functionArguments",
+
+    contentToken: MetaTokenType.Arguments, /*meta.function-call.arguments.python*/
+    begin: /(\()/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.definition.arguments.begin.python*/ },
+    },
+    end: /(?=\))(?!\)\s*\()/g,
+    patterns: [
+        {
+            debugName: "functionArguments.patterns![0]",
+
+            token: CharacterTokenType.Comma, /*punctuation.separator.arguments.python*/
+            match: /(,)/g,
+        },
+        {
+            debugName: "functionArguments.patterns![1]",
+
+            match: /(?:(?<=[,(])|^)\s*(\*{1,2})/dgm,
+            captures: {
+                1: { token: OperatorTokenType.Unpacking, /*keyword.operator.unpacking.arguments.python*/ },
+            },
+        },
+        lambdaIncomplete,
+        {
+            debugName: "functionArguments.patterns![4]",
+
+            match: /\b([a-zA-Z_]\w*)\s*(=)(?!=)/dg,
+            captures: {
+                1: { token: EntityTokenType.VariableName, /*variable.parameter.function-call.python*/ },
+                2: { token: OperatorTokenType.Assignment, /*keyword.operator.assignment.python*/ },
+            },
+        },
+        {
+            debugName: "functionArguments.patterns![5]",
+
+            token: OperatorTokenType.Assignment, /*keyword.operator.assignment.python*/
+            match: /=(?!=)/g,
+        },
+        expression,
+        {
+            debugName: "functionArguments.patterns![7]",
+
+            match: /\s*(\))\s*(\()/dg,
+            captures: {
+                1: { token: CharacterTokenType.CloseParentheses, /*punctuation.definition.arguments.end.python*/ },
+                2: { token: CharacterTokenType.OpenParentheses, /*punctuation.definition.arguments.begin.python*/ },
+            },
+        },
+    ]
+};
+
+export const builtinCallables: TokenPattern = {
+    patterns: []
+};
+
+export const builtinPossibleCallables: TokenPattern = {
+    patterns: [
+        builtinCallables]
+};
+
+export const builtinExceptions: TokenPattern = {
+    debugName: "builtinExceptions",
+
+    token: MetaTokenType.BuiltinExceptionType, /*support.type.exception.python*/
+    match: /(?<!\.)\b((Arithmetic|Assertion|Attribute|Buffer|BlockingIO|BrokenPipe|ChildProcess|(Connection(Aborted|Refused|Reset)?)|EOF|Environment|FileExists|FileNotFound|FloatingPoint|IO|Import|Indentation|Index|Interrupted|IsADirectory|NotADirectory|Permission|ProcessLookup|Timeout|Key|Lookup|Memory|Name|NotImplemented|OS|Overflow|Reference|Runtime|Recursion|Syntax|System|Tab|Type|UnboundLocal|Unicode(Encode|Decode|Translate)?|Value|Windows|ZeroDivision|ModuleNotFound)Error|((Pending)?Deprecation|Runtime|Syntax|User|Future|Import|Unicode|Bytes|Resource)?Warning|SystemExit|Stop(Async)?Iteration|KeyboardInterrupt|GeneratorExit|(Base)?Exception)\b/g,
+};
+
+export const builtinFunctions: TokenPattern = {
+    patterns: [
+        {
+            debugName: "builtinFunctions.patterns![0]",
+
+            token: EntityTokenType.FunctionName, /*support.function.builtin.python*/
+            match: /(?<!\.)\b(__import__|abs|aiter|all|any|anext|ascii|bin|breakpoint|callable|chr|compile|copyright|credits|delattr|dir|divmod|enumerate|eval|exec|exit|filter|format|getattr|globals|hasattr|hash|help|hex|id|input|isinstance|issubclass|iter|len|license|locals|map|max|memoryview|min|next|oct|open|ord|pow|print|quit|range|reload|repr|reversed|round|setattr|sorted|sum|vars|zip)\b/g,
+        },
+        {
+            debugName: "builtinFunctions.patterns![1]",
+
+            token: EntityTokenType.VariableName, /*variable.legacy.builtin.python*/
+            match: /(?<!\.)\b(file|reduce|intern|raw_input|unicode|cmp|basestring|execfile|long|xrange)\b/g,
+        },
+    ]
+};
+
+export const builtinTypes: TokenPattern = {
+    debugName: "builtinTypes",
+
+    token: MetaTokenType.BuiltinType, /*support.type.python*/
+    match: /(?<!\.)\b(bool|bytearray|bytes|classmethod|complex|dict|float|frozenset|int|list|object|property|set|slice|staticmethod|str|tuple|type|super)\b/g,
+};
+
+export const magicFunctionNames: TokenPattern = {
+    debugName: "magicFunctionNames",
+
+    // these methods have magic interpretation by python and are generally calledindirectly through syntactic constructs
+    match: /\b(__(?:abs|add|aenter|aexit|aiter|and|anext|await|bool|call|ceil|class_getitem|cmp|coerce|complex|contains|copy|deepcopy|del|delattr|delete|delitem|delslice|dir|div|divmod|enter|eq|exit|float|floor|floordiv|format|ge|get|getattr|getattribute|getinitargs|getitem|getnewargs|getslice|getstate|gt|hash|hex|iadd|iand|idiv|ifloordiv||ilshift|imod|imul|index|init|instancecheck|int|invert|ior|ipow|irshift|isub|iter|itruediv|ixor|le|len|long|lshift|lt|missing|mod|mul|ne|neg|new|next|nonzero|oct|or|pos|pow|radd|rand|rdiv|rdivmod|reduce|reduce_ex|repr|reversed|rfloordiv||rlshift|rmod|rmul|ror|round|rpow|rrshift|rshift|rsub|rtruediv|rxor|set|setattr|setitem|set_name|setslice|setstate|sizeof|str|sub|subclasscheck|truediv|trunc|unicode|xor|matmul|rmatmul|imatmul|init_subclass|set_name|fspath|bytes|prepare|length_hint)__)\b/dg,
+    captures: {
+        1: { token: EntityTokenType.FunctionName, /*support.function.magic.python*/ },
+    },
+};
+
+export const magicVariableNames: TokenPattern = {
+    debugName: "magicVariableNames",
+
+    // magic variables which a class/module may have.
+    match: /\b(__(?:all|annotations|bases|builtins|class|closure|code|debug|defaults|dict|doc|file|func|globals|kwdefaults|match_args|members|metaclass|methods|module|mro|mro_entries|name|qualname|post_init|self|signature|slots|subclasses|version|weakref|wrapped|classcell|spec|path|package|future|traceback)__)\b/dg,
+    captures: {
+        1: { token: EntityTokenType.VariableName, /*support.variable.magic.python*/ },
+    },
+};
+
+export const magicNames: TokenPattern = {
+    patterns: [
+        magicFunctionNames,
+        magicVariableNames,
+    ]
+};
+
+export const illegalNames: TokenPattern = {
+    debugName: "illegalNames",
+
+    match: /\b(?:(and|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|in|is|(?<=\.)lambda|lambda(?=\s*[\.=])|nonlocal|not|or|pass|raise|return|try|while|with|yield)|(as|import))\b/dg,
+    captures: {
+        1: { token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.python*/ },
+        2: { token: KeywordTokenType.Import, /*keyword.control.import.python*/ },
+    },
+};
+
+export const specialVariables: TokenPattern = {
+    debugName: "specialVariables",
+
+    match: /\b(?<!\.)(?:(self)|(cls))\b/dg,
+    captures: {
+        1: { token: EntityTokenType.VariableName, /*variable.language.special.self.python*/ },
+        2: { token: EntityTokenType.VariableName, /*variable.language.special.cls.python*/ },
+    },
+};
+
+export const ellipsis: TokenPattern = {
+    debugName: "ellipsis",
+
+    token: MetaTokenType.ConstantCaps, /*constant.other.ellipsis.python*/
+    match: /\.\.\./g,
+};
+
+export const backticks: TokenPattern = {
+    debugName: "backticks",
+
+    token: MetaTokenType.Deprecated, /*invalid.deprecated.backtick.python*/
+    begin: /\`/g,
+    end: /(?:\`|(?<!\\)(\n))/g,
+    patterns: [expression]
+};
+
+export const illegalOperator: TokenPattern = {
+    patterns: [
+        {
+            debugName: "illegalOperator.patterns![0]",
+
+            token: MetaTokenType.Invalid, /*invalid.illegal.operator.python*/
+            match: /&&|\|\||--|\+\+/g,
+        },
+        {
+            debugName: "illegalOperator.patterns![1]",
+
+            token: MetaTokenType.Invalid, /*invalid.illegal.operator.python*/
+            match: /[?$]/gm,
+        },
+        {
+            debugName: "illegalOperator.patterns![2]",
+
+            // We don't want `!` to flash when we're typing `!=`
+            token: MetaTokenType.Invalid, /*invalid.illegal.operator.python*/
+            match: /!\b/g,
+        },
+    ]
+};
+
+export const illegalObjectName: TokenPattern = {
+    debugName: "illegalObjectName",
+
+    // It's illegal to name class or function "True"
+    token: MetaTokenType.Invalid, /*keyword.illegal.name.python*/
+    match: /\b(True|False|None)\b/g,
+};
+
+export const illegalAnno: TokenPattern = {
+    debugName: "illegalAnno",
+
+    token: MetaTokenType.Invalid, /*invalid.illegal.annotation.python*/
+    match: /->/g,
+};
+
+export const regexpBaseExpression: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const fregexpBaseExpression: TokenPattern = {
+    patterns: [
+        {
+            debugName: "fregexpBaseExpression.patterns![2]",
+
+            match: /\{.*?\}/g,
+        },
+    ]
+};
+
+export const fstringFormattingBraces: TokenPattern = {
+    patterns: [
+        {
+            debugName: "fstringFormattingBraces.patterns![0]",
+
+            // empty braces are illegal
+            match: /({)(\s*?)(})/dg,
+            captures: {
+                1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+                2: { token: MetaTokenType.Invalid, /*invalid.illegal.brace.python*/ },
+                3: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+            },
+        },
+        {
+            debugName: "fstringFormattingBraces.patterns![1]",
+
+            token: MetaTokenType.EscapeSequence, /*constant.character.escape.python*/
+            match: /({{|}})/g,
+        },
+    ]
+};
+
+export const regexpBaseCommon: TokenPattern = {
+    patterns: [
+        {
+            debugName: "regexpBaseCommon.patterns![0]",
+
+            token: CharacterTokenType.Period, /*support.other.match.any.regexp*/
+            match: /\./g,
+        },
+        {
+            debugName: "regexpBaseCommon.patterns![1]",
+
+            token: CharacterTokenType.Caret, /*support.other.match.begin.regexp*/
+            match: /\^/gm,
+        },
+        {
+            debugName: "regexpBaseCommon.patterns![2]",
+
+            token: CharacterTokenType.DollarSymbol, /*support.other.match.end.regexp*/
+            match: /\$/gm,
+        },
+        {
+            debugName: "regexpBaseCommon.patterns![3]",
+
+            token: OperatorTokenType.Quantifier, /*keyword.operator.quantifier.regexp*/
+            match: /[+*?]\??/g,
+        },
+        {
+            debugName: "regexpBaseCommon.patterns![4]",
+
+            token: OperatorTokenType.Disjunction, /*keyword.operator.disjunction.regexp*/
+            match: /\|/g,
+        },
+    ]
+};
+
+export const regexpQuantifier: TokenPattern = {
+    debugName: "regexpQuantifier",
+
+    token: OperatorTokenType.Quantifier, /*keyword.operator.quantifier.regexp*/
+    match: /\{(\d+|\d+,(\d+)?|,\d+)\}/g,
+};
+
+export const fregexpQuantifier: TokenPattern = {
+    debugName: "fregexpQuantifier",
+
+    token: OperatorTokenType.Quantifier, /*keyword.operator.quantifier.regexp*/
+    match: /\{\{(\d+|\d+,(\d+)?|,\d+)\}\}/g,
+};
+
+export const regexpBackreferenceNumber: TokenPattern = {
+    debugName: "regexpBackreferenceNumber",
+
+    token: MetaTokenType.Backreference, /*meta.backreference.regexp*/
+    match: /(\\[1-9]\d?)/dg,
+    captures: {
+        1: { token: EntityTokenType.TagName, /*entity.name.tag.backreference.regexp*/ },
+    },
+};
+
+export const regexpBackreference: TokenPattern = {
+    debugName: "regexpBackreference",
+
+    token: MetaTokenType.BackreferenceNamed, /*meta.backreference.named.regexp*/
+    match: /(\()(\?P=\w+(?:\s+[a-zA-Z0-9]+)?)(\))/dg,
+    captures: {
+        1: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.backreference.named.regexp*/ },
+        2: { token: EntityTokenType.TagName, /*entity.name.tag.named.backreference.regexp*/ },
+        3: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.backreference.named.regexp*/ },
+    },
+};
+
+export const regexpFlags: TokenPattern = {
+    debugName: "regexpFlags",
+
+    token: MetaTokenType.ModifierFlagStorageType, /*storage.modifier.flag.regexp*/
+    match: /\(\?[aiLmsux]+\)/g,
+};
+
+export const regexpEscapeSpecial: TokenPattern = {
+    debugName: "regexpEscapeSpecial",
+
+    token: MetaTokenType.EscapeSequence, /*support.other.escape.special.regexp*/
+    match: /\\([AbBdDsSwWZ])/g,
+};
+
+export const regexpEscapeCharacter: TokenPattern = {
+    debugName: "regexpEscapeCharacter",
+
+    token: MetaTokenType.EscapeSequence, /*constant.character.escape.regexp*/
+    match: /\\(x[0-9A-Fa-f]{2}|0[0-7]{1,2}|[0-7]{3})/g,
+};
+
+export const regexpEscapeUnicode: TokenPattern = {
+    debugName: "regexpEscapeUnicode",
+
+    token: MetaTokenType.EscapeSequence, /*constant.character.unicode.regexp*/
+    match: /\\(u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/g,
+};
+
+export const regexpEscapeCatchall: TokenPattern = {
+    debugName: "regexpEscapeCatchall",
+
+    token: MetaTokenType.EscapeSequence, /*constant.character.escape.regexp*/
+    match: /\\(.|\n)/g,
+};
+
+export const regexpEscapeSequence: TokenPattern = {
+    patterns: [
+        regexpEscapeSpecial,
+        regexpEscapeCharacter,
+        regexpEscapeUnicode,
+        regexpBackreferenceNumber,
+        regexpEscapeCatchall,
+    ]
+};
+
+export const regexpCharecterSetEscapes: TokenPattern = {
+    patterns: [
+        {
+            debugName: "regexpCharecterSetEscapes.patterns![0]",
+
+            token: MetaTokenType.EscapeSequence, /*constant.character.escape.regexp*/
+            match: /\\[abfnrtv\\]/g,
+        },
+        regexpEscapeSpecial,
+        {
+            debugName: "regexpCharecterSetEscapes.patterns![2]",
+
+            token: MetaTokenType.EscapeSequence, /*constant.character.escape.regexp*/
+            match: /\\([0-7]{1,3})/g,
+        },
+        regexpEscapeCharacter,
+        regexpEscapeUnicode,
+        regexpEscapeCatchall,
+    ]
+};
+
+export const codetags: TokenPattern = {
+    debugName: "codetags",
+
+    match: /(?:\b(NOTE|XXX|HACK|FIXME|BUG|TODO)\b)/dg,
+    captures: {
+        1: { token: MetaTokenType.CommentCodeTag, /*keyword.codetag.notation.python*/ },
+    },
+};
+
+export const commentsBase: TokenPattern = {
+    debugName: "commentsBase",
+
+    token: MetaTokenType.Comment, /*comment.line.number-sign.python*/
+    begin: /(\#)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Hashtag, /*punctuation.definition.comment.python*/ },
+    },
+    end: /($)/gm,
+    patterns: [codetags]
+};
+
+export const commentsStringSingleThree: TokenPattern = {
+    debugName: "commentsStringSingleThree",
+
+    token: MetaTokenType.Comment, /*comment.line.number-sign.python*/
+    begin: /(\#)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Hashtag, /*punctuation.definition.comment.python*/ },
+    },
+    end: /($|(?='''))/gm,
+    patterns: [codetags]
+};
+
+export const commentsStringDoubleThree: TokenPattern = {
+    debugName: "commentsStringDoubleThree",
+
+    token: MetaTokenType.Comment, /*comment.line.number-sign.python*/
+    begin: /(\#)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Hashtag, /*punctuation.definition.comment.python*/ },
+    },
+    end: /($|(?="""))/gm,
+    patterns: [codetags]
+};
+
+export const singleOneRegexpExpression: TokenPattern = {
+    patterns: [
+        regexpBaseExpression,
+        regexpFlags,
+        regexpBackreference,
+    ]
+};
+
+export const singleOneRegexpCharacterSet: TokenPattern = {
+    patterns: [
+        {
+            debugName: "singleOneRegexpCharacterSet.patterns![0]",
+
+            match: /\[\^?\](?!.*?\])/gm,
+        },
+        {
+            debugName: "singleOneRegexpCharacterSet.patterns![1]",
+
+            token: MetaTokenType.CharacterSet, /*meta.character.set.regexp*/
+            begin: /(\[)(\^)?(\])?/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.OpenSquareBracket, /*constant.other.set.regexp punctuation.character.set.begin.regexp*/ },
+                2: { token: OperatorTokenType.Negation, /*keyword.operator.negation.regexp*/ },
+                3: { token: MetaTokenType.CharacterSet, /*constant.character.set.regexp*/ },
+            },
+            end: /(\]|(?=\'))|((?=(?<!\\)\n))/dg,
+            endCaptures: {
+                1: { token: CharacterTokenType.CloseSquareBracket, /*constant.other.set.regexp punctuation.character.set.end.regexp*/ },
+                2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+            },
+            patterns: [
+                regexpCharecterSetEscapes,
+                {
+                    debugName: "singleOneRegexpCharacterSet.patterns![1].patterns![1]",
+
+                    token: MetaTokenType.CharacterSet, /*constant.character.set.regexp*/
+                    match: /[^\n]/g,
+                },
+            ]
+        },
+    ]
+};
+
+export const singleOneRegexpNamedGroup: TokenPattern = {
+    debugName: "singleOneRegexpNamedGroup",
+
+    token: MetaTokenType.Named, /*meta.named.regexp*/
+    begin: /(\()(\?P<\w+(?:\s+[a-zA-Z0-9]+)?>)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.named.regexp*/ },
+        2: { token: EntityTokenType.TagName, /*entity.name.tag.named.group.regexp*/ },
+    },
+    end: /(\)|(?=\'))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.named.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [singleOneRegexpExpression]
+};
+
+export const singleOneRegexpComments: TokenPattern = {
+    debugName: "singleOneRegexpComments",
+
+    token: MetaTokenType.Comment, /*comment.regexp*/
+    begin: /\(\?#/dg,
+    beginCaptures: {
+        0: { token: MetaTokenType.CommentBegin, /*punctuation.comment.begin.regexp*/ },
+    },
+    end: /(\)|(?=\'))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.CommentEnd, /*punctuation.comment.end.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [codetags]
+};
+
+export const singleOneRegexpLookahead: TokenPattern = {
+    debugName: "singleOneRegexpLookahead",
+
+    begin: /(\()\?=/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Lookahead, /*keyword.operator.lookahead.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookahead.regexp*/ },
+    },
+    end: /(\)|(?=\'))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookahead.regexp punctuation.parenthesis.end.lookahead.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [singleOneRegexpExpression]
+};
+
+export const singleOneRegexpLookaheadNegative: TokenPattern = {
+    debugName: "singleOneRegexpLookaheadNegative",
+
+    begin: /(\()\?!/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.LookaheadNegative, /*keyword.operator.lookahead.negative.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookahead.regexp*/ },
+    },
+    end: /(\)|(?=\'))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookahead.negative.regexp punctuation.parenthesis.end.lookahead.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [singleOneRegexpExpression]
+};
+
+export const singleOneRegexpLookbehind: TokenPattern = {
+    debugName: "singleOneRegexpLookbehind",
+
+    begin: /(\()\?<=/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Lookbehind, /*keyword.operator.lookbehind.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookbehind.regexp*/ },
+    },
+    end: /(\)|(?=\'))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookbehind.regexp punctuation.parenthesis.end.lookbehind.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [singleOneRegexpExpression]
+};
+
+export const singleOneRegexpLookbehindNegative: TokenPattern = {
+    debugName: "singleOneRegexpLookbehindNegative",
+
+    begin: /(\()\?<!/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.LookbehindNegative, /*keyword.operator.lookbehind.negative.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookbehind.regexp*/ },
+    },
+    end: /(\)|(?=\'))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.end.lookbehind.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [singleOneRegexpExpression]
+};
+
+export const singleOneRegexpConditional: TokenPattern = {
+    debugName: "singleOneRegexpConditional",
+
+    begin: /(\()\?\((\w+(?:\s+[a-zA-Z0-9]+)?|\d+)\)/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Conditional, /*keyword.operator.conditional.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.conditional.regexp*/ },
+    },
+    end: /(\)|(?=\'))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.conditional.negative.regexp punctuation.parenthesis.end.conditional.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [singleOneRegexpExpression]
+};
+
+export const singleOneRegexpParenthesesNonCapturing: TokenPattern = {
+    debugName: "singleOneRegexpParenthesesNonCapturing",
+
+    begin: /\(\?:/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.non-capturing.regexp*/ },
+    },
+    end: /(\)|(?=\'))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.non-capturing.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [singleOneRegexpExpression]
+};
+
+export const singleOneRegexpParentheses: TokenPattern = {
+    debugName: "singleOneRegexpParentheses",
+
+    begin: /\(/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp*/ },
+    },
+    end: /(\)|(?=\'))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [singleOneRegexpExpression]
+};
+
+export const singleThreeRegexpExpression: TokenPattern = {
+    patterns: [
+        regexpBaseExpression,
+        regexpFlags,
+        regexpBackreference,
+        commentsStringSingleThree,
+    ]
+};
+
+export const singleThreeRegexpCharacterSet: TokenPattern = {
+    patterns: [
+        {
+            debugName: "singleThreeRegexpCharacterSet.patterns![0]",
+
+            match: /\[\^?\](?!.*?\])/gm,
+        },
+        {
+            debugName: "singleThreeRegexpCharacterSet.patterns![1]",
+
+            token: MetaTokenType.CharacterSet, /*meta.character.set.regexp*/
+            begin: /(\[)(\^)?(\])?/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.OpenSquareBracket, /*constant.other.set.regexp punctuation.character.set.begin.regexp*/ },
+                2: { token: OperatorTokenType.Negation, /*keyword.operator.negation.regexp*/ },
+                3: { token: MetaTokenType.CharacterSet, /*constant.character.set.regexp*/ },
+            },
+            end: /(\]|(?=\'\'\'))/dg,
+            endCaptures: {
+                1: { token: CharacterTokenType.CloseSquareBracket, /*constant.other.set.regexp punctuation.character.set.end.regexp*/ },
+                2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+            },
+            patterns: [
+                regexpCharecterSetEscapes,
+                {
+                    debugName: "singleThreeRegexpCharacterSet.patterns![1].patterns![1]",
+
+                    token: MetaTokenType.CharacterSet, /*constant.character.set.regexp*/
+                    match: /[^\n]/g,
+                },
+            ]
+        },
+    ]
+};
+
+export const singleThreeRegexpNamedGroup: TokenPattern = {
+    debugName: "singleThreeRegexpNamedGroup",
+
+    token: MetaTokenType.Named, /*meta.named.regexp*/
+    begin: /(\()(\?P<\w+(?:\s+[a-zA-Z0-9]+)?>)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.named.regexp*/ },
+        2: { token: EntityTokenType.TagName, /*entity.name.tag.named.group.regexp*/ },
+    },
+    end: /(\)|(?=\'\'\'))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.named.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        singleThreeRegexpExpression,
+        commentsStringSingleThree,
+    ]
+};
+
+export const singleThreeRegexpComments: TokenPattern = {
+    debugName: "singleThreeRegexpComments",
+
+    token: MetaTokenType.Comment, /*comment.regexp*/
+    begin: /\(\?#/dg,
+    beginCaptures: {
+        0: { token: MetaTokenType.CommentBegin, /*punctuation.comment.begin.regexp*/ },
+    },
+    end: /(\)|(?=\'\'\'))/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.CommentEnd, /*punctuation.comment.end.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [codetags]
+};
+
+export const singleThreeRegexpLookahead: TokenPattern = {
+    debugName: "singleThreeRegexpLookahead",
+
+    begin: /(\()\?=/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Lookahead, /*keyword.operator.lookahead.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookahead.regexp*/ },
+    },
+    end: /(\)|(?=\'\'\'))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookahead.regexp punctuation.parenthesis.end.lookahead.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        singleThreeRegexpExpression,
+        commentsStringSingleThree,
+    ]
+};
+
+export const singleThreeRegexpLookaheadNegative: TokenPattern = {
+    debugName: "singleThreeRegexpLookaheadNegative",
+
+    begin: /(\()\?!/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.LookaheadNegative, /*keyword.operator.lookahead.negative.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookahead.regexp*/ },
+    },
+    end: /(\)|(?=\'\'\'))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookahead.negative.regexp punctuation.parenthesis.end.lookahead.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        singleThreeRegexpExpression,
+        commentsStringSingleThree,
+    ]
+};
+
+export const singleThreeRegexpLookbehind: TokenPattern = {
+    debugName: "singleThreeRegexpLookbehind",
+
+    begin: /(\()\?<=/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Lookbehind, /*keyword.operator.lookbehind.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookbehind.regexp*/ },
+    },
+    end: /(\)|(?=\'\'\'))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookbehind.regexp punctuation.parenthesis.end.lookbehind.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        singleThreeRegexpExpression,
+        commentsStringSingleThree,
+    ]
+};
+
+export const singleThreeRegexpLookbehindNegative: TokenPattern = {
+    debugName: "singleThreeRegexpLookbehindNegative",
+
+    begin: /(\()\?<!/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.LookbehindNegative, /*keyword.operator.lookbehind.negative.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookbehind.regexp*/ },
+    },
+    end: /(\)|(?=\'\'\'))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.end.lookbehind.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        singleThreeRegexpExpression,
+        commentsStringSingleThree,
+    ]
+};
+
+export const singleThreeRegexpConditional: TokenPattern = {
+    debugName: "singleThreeRegexpConditional",
+
+    begin: /(\()\?\((\w+(?:\s+[a-zA-Z0-9]+)?|\d+)\)/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Conditional, /*keyword.operator.conditional.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.conditional.regexp*/ },
+    },
+    end: /(\)|(?=\'\'\'))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.conditional.negative.regexp punctuation.parenthesis.end.conditional.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        singleThreeRegexpExpression,
+        commentsStringSingleThree,
+    ]
+};
+
+export const singleThreeRegexpParenthesesNonCapturing: TokenPattern = {
+    debugName: "singleThreeRegexpParenthesesNonCapturing",
+
+    begin: /\(\?:/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.non-capturing.regexp*/ },
+    },
+    end: /(\)|(?=\'\'\'))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.non-capturing.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        singleThreeRegexpExpression,
+        commentsStringSingleThree,
+    ]
+};
+
+export const singleThreeRegexpParentheses: TokenPattern = {
+    debugName: "singleThreeRegexpParentheses",
+
+    begin: /\(/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp*/ },
+    },
+    end: /(\)|(?=\'\'\'))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        singleThreeRegexpExpression,
+        commentsStringSingleThree,
+    ]
+};
+
+export const doubleOneRegexpExpression: TokenPattern = {
+    patterns: [
+        regexpBaseExpression,
+        regexpFlags,
+        regexpBackreference,
+    ]
+};
+
+export const doubleOneRegexpCharacterSet: TokenPattern = {
+    patterns: [
+        {
+            debugName: "doubleOneRegexpCharacterSet.patterns![0]",
+
+            match: /\[\^?\](?!.*?\])/gm,
+        },
+        {
+            debugName: "doubleOneRegexpCharacterSet.patterns![1]",
+
+            token: MetaTokenType.CharacterSet, /*meta.character.set.regexp*/
+            begin: /(\[)(\^)?(\])?/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.OpenSquareBracket, /*constant.other.set.regexp punctuation.character.set.begin.regexp*/ },
+                2: { token: OperatorTokenType.Negation, /*keyword.operator.negation.regexp*/ },
+                3: { token: MetaTokenType.CharacterSet, /*constant.character.set.regexp*/ },
+            },
+            end: /(\]|(?="))|((?=(?<!\\)\n))/dg,
+            endCaptures: {
+                1: { token: CharacterTokenType.CloseSquareBracket, /*constant.other.set.regexp punctuation.character.set.end.regexp*/ },
+                2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+            },
+            patterns: [
+                regexpCharecterSetEscapes,
+                {
+                    debugName: "doubleOneRegexpCharacterSet.patterns![1].patterns![1]",
+
+                    token: MetaTokenType.CharacterSet, /*constant.character.set.regexp*/
+                    match: /[^\n]/g,
+                },
+            ]
+        },
+    ]
+};
+
+export const doubleOneRegexpNamedGroup: TokenPattern = {
+    debugName: "doubleOneRegexpNamedGroup",
+
+    token: MetaTokenType.Named, /*meta.named.regexp*/
+    begin: /(\()(\?P<\w+(?:\s+[a-zA-Z0-9]+)?>)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.named.regexp*/ },
+        2: { token: EntityTokenType.TagName, /*entity.name.tag.named.group.regexp*/ },
+    },
+    end: /(\)|(?="))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.named.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [doubleOneRegexpExpression]
+};
+
+export const doubleOneRegexpComments: TokenPattern = {
+    debugName: "doubleOneRegexpComments",
+
+    token: MetaTokenType.Comment, /*comment.regexp*/
+    begin: /\(\?#/dg,
+    beginCaptures: {
+        0: { token: MetaTokenType.CommentBegin, /*punctuation.comment.begin.regexp*/ },
+    },
+    end: /(\)|(?="))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.CommentEnd, /*punctuation.comment.end.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [codetags]
+};
+
+export const doubleOneRegexpLookahead: TokenPattern = {
+    debugName: "doubleOneRegexpLookahead",
+
+    begin: /(\()\?=/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Lookahead, /*keyword.operator.lookahead.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookahead.regexp*/ },
+    },
+    end: /(\)|(?="))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookahead.regexp punctuation.parenthesis.end.lookahead.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [doubleOneRegexpExpression]
+};
+
+export const doubleOneRegexpLookaheadNegative: TokenPattern = {
+    debugName: "doubleOneRegexpLookaheadNegative",
+
+    begin: /(\()\?!/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.LookaheadNegative, /*keyword.operator.lookahead.negative.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookahead.regexp*/ },
+    },
+    end: /(\)|(?="))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookahead.negative.regexp punctuation.parenthesis.end.lookahead.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [doubleOneRegexpExpression]
+};
+
+export const doubleOneRegexpLookbehind: TokenPattern = {
+    debugName: "doubleOneRegexpLookbehind",
+
+    begin: /(\()\?<=/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Lookbehind, /*keyword.operator.lookbehind.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookbehind.regexp*/ },
+    },
+    end: /(\)|(?="))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookbehind.regexp punctuation.parenthesis.end.lookbehind.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [doubleOneRegexpExpression]
+};
+
+export const doubleOneRegexpLookbehindNegative: TokenPattern = {
+    debugName: "doubleOneRegexpLookbehindNegative",
+
+    begin: /(\()\?<!/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.LookbehindNegative, /*keyword.operator.lookbehind.negative.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookbehind.regexp*/ },
+    },
+    end: /(\)|(?="))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.end.lookbehind.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [doubleOneRegexpExpression]
+};
+
+export const doubleOneRegexpConditional: TokenPattern = {
+    debugName: "doubleOneRegexpConditional",
+
+    begin: /(\()\?\((\w+(?:\s+[a-zA-Z0-9]+)?|\d+)\)/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Conditional, /*keyword.operator.conditional.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.conditional.regexp*/ },
+    },
+    end: /(\)|(?="))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.conditional.negative.regexp punctuation.parenthesis.end.conditional.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [doubleOneRegexpExpression]
+};
+
+export const doubleOneRegexpParenthesesNonCapturing: TokenPattern = {
+    debugName: "doubleOneRegexpParenthesesNonCapturing",
+
+    begin: /\(\?:/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.non-capturing.regexp*/ },
+    },
+    end: /(\)|(?="))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.non-capturing.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [doubleOneRegexpExpression]
+};
+
+export const doubleOneRegexpParentheses: TokenPattern = {
+    debugName: "doubleOneRegexpParentheses",
+
+    begin: /\(/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp*/ },
+    },
+    end: /(\)|(?="))|((?=(?<!\\)\n))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [doubleOneRegexpExpression]
+};
+
+export const doubleThreeRegexpExpression: TokenPattern = {
+    patterns: [
+        regexpBaseExpression,
+        regexpFlags,
+        regexpBackreference,
+        commentsStringDoubleThree,
+    ]
+};
+
+export const doubleThreeRegexpCharacterSet: TokenPattern = {
+    patterns: [
+        {
+            debugName: "doubleThreeRegexpCharacterSet.patterns![0]",
+
+            match: /\[\^?\](?!.*?\])/gm,
+        },
+        {
+            debugName: "doubleThreeRegexpCharacterSet.patterns![1]",
+
+            token: MetaTokenType.CharacterSet, /*meta.character.set.regexp*/
+            begin: /(\[)(\^)?(\])?/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.OpenSquareBracket, /*constant.other.set.regexp punctuation.character.set.begin.regexp*/ },
+                2: { token: OperatorTokenType.Negation, /*keyword.operator.negation.regexp*/ },
+                3: { token: MetaTokenType.CharacterSet, /*constant.character.set.regexp*/ },
+            },
+            end: /(\]|(?="""))/dg,
+            endCaptures: {
+                1: { token: CharacterTokenType.CloseSquareBracket, /*constant.other.set.regexp punctuation.character.set.end.regexp*/ },
+                2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+            },
+            patterns: [
+                regexpCharecterSetEscapes,
+                {
+                    debugName: "doubleThreeRegexpCharacterSet.patterns![1].patterns![1]",
+
+                    token: MetaTokenType.CharacterSet, /*constant.character.set.regexp*/
+                    match: /[^\n]/g,
+                },
+            ]
+        },
+    ]
+};
+
+export const doubleThreeRegexpNamedGroup: TokenPattern = {
+    debugName: "doubleThreeRegexpNamedGroup",
+
+    token: MetaTokenType.Named, /*meta.named.regexp*/
+    begin: /(\()(\?P<\w+(?:\s+[a-zA-Z0-9]+)?>)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.named.regexp*/ },
+        2: { token: EntityTokenType.TagName, /*entity.name.tag.named.group.regexp*/ },
+    },
+    end: /(\)|(?="""))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.named.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        doubleThreeRegexpExpression,
+        commentsStringDoubleThree,
+    ]
+};
+
+export const doubleThreeRegexpComments: TokenPattern = {
+    debugName: "doubleThreeRegexpComments",
+
+    token: MetaTokenType.Comment, /*comment.regexp*/
+    begin: /\(\?#/dg,
+    beginCaptures: {
+        0: { token: MetaTokenType.CommentBegin, /*punctuation.comment.begin.regexp*/ },
+    },
+    end: /(\)|(?="""))/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.CommentEnd, /*punctuation.comment.end.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [codetags]
+};
+
+export const doubleThreeRegexpLookahead: TokenPattern = {
+    debugName: "doubleThreeRegexpLookahead",
+
+    begin: /(\()\?=/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Lookahead, /*keyword.operator.lookahead.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookahead.regexp*/ },
+    },
+    end: /(\)|(?="""))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookahead.regexp punctuation.parenthesis.end.lookahead.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        doubleThreeRegexpExpression,
+        commentsStringDoubleThree,
+    ]
+};
+
+export const doubleThreeRegexpLookaheadNegative: TokenPattern = {
+    debugName: "doubleThreeRegexpLookaheadNegative",
+
+    begin: /(\()\?!/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.LookaheadNegative, /*keyword.operator.lookahead.negative.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookahead.regexp*/ },
+    },
+    end: /(\)|(?="""))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookahead.negative.regexp punctuation.parenthesis.end.lookahead.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        doubleThreeRegexpExpression,
+        commentsStringDoubleThree,
+    ]
+};
+
+export const doubleThreeRegexpLookbehind: TokenPattern = {
+    debugName: "doubleThreeRegexpLookbehind",
+
+    begin: /(\()\?<=/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Lookbehind, /*keyword.operator.lookbehind.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookbehind.regexp*/ },
+    },
+    end: /(\)|(?="""))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookbehind.regexp punctuation.parenthesis.end.lookbehind.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        doubleThreeRegexpExpression,
+        commentsStringDoubleThree,
+    ]
+};
+
+export const doubleThreeRegexpLookbehindNegative: TokenPattern = {
+    debugName: "doubleThreeRegexpLookbehindNegative",
+
+    begin: /(\()\?<!/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.LookbehindNegative, /*keyword.operator.lookbehind.negative.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.lookbehind.regexp*/ },
+    },
+    end: /(\)|(?="""))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.end.lookbehind.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        doubleThreeRegexpExpression,
+        commentsStringDoubleThree,
+    ]
+};
+
+export const doubleThreeRegexpConditional: TokenPattern = {
+    debugName: "doubleThreeRegexpConditional",
+
+    begin: /(\()\?\((\w+(?:\s+[a-zA-Z0-9]+)?|\d+)\)/dg,
+    beginCaptures: {
+        0: { token: OperatorTokenType.Conditional, /*keyword.operator.conditional.regexp*/ },
+        1: { token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.conditional.regexp*/ },
+    },
+    end: /(\)|(?="""))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*keyword.operator.conditional.negative.regexp punctuation.parenthesis.end.conditional.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        doubleThreeRegexpExpression,
+        commentsStringDoubleThree,
+    ]
+};
+
+export const doubleThreeRegexpParenthesesNonCapturing: TokenPattern = {
+    debugName: "doubleThreeRegexpParenthesesNonCapturing",
+
+    begin: /\(\?:/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.non-capturing.regexp*/ },
+    },
+    end: /(\)|(?="""))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.non-capturing.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        doubleThreeRegexpExpression,
+        commentsStringDoubleThree,
+    ]
+};
+
+export const doubleThreeRegexpParentheses: TokenPattern = {
+    debugName: "doubleThreeRegexpParentheses",
+
+    begin: /\(/dg,
+    beginCaptures: {
+        0: { token: CharacterTokenType.OpenParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp*/ },
+    },
+    end: /(\)|(?="""))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*support.other.parenthesis.regexp punctuation.parenthesis.end.regexp*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        doubleThreeRegexpExpression,
+        commentsStringDoubleThree,
+    ]
+};
+
+export const regexpSingleOneLine: TokenPattern = {
+    debugName: "regexpSingleOneLine",
+
+    token: LiteralTokenType.String, /*string.regexp.quoted.single.python*/
+    begin: /\b(([uU]r)|([bB]r)|(r[bB]?))(\')/dg,
+    beginCaptures: {
+        2: { token: MetaTokenType.Deprecated, /*invalid.deprecated.prefix.python*/ },
+        3: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        4: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        5: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\')|(?<!\\)(\n)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [singleOneRegexpExpression]
+};
+
+export const regexpSingleThreeLine: TokenPattern = {
+    debugName: "regexpSingleThreeLine",
+
+    token: LiteralTokenType.String, /*string.regexp.quoted.multi.python*/
+    begin: /\b(([uU]r)|([bB]r)|(r[bB]?))(\'\'\')/dg,
+    beginCaptures: {
+        2: { token: MetaTokenType.Deprecated, /*invalid.deprecated.prefix.python*/ },
+        3: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        4: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        5: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\'\'\')/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [singleThreeRegexpExpression]
+};
+
+export const regexpDoubleOneLine: TokenPattern = {
+    debugName: "regexpDoubleOneLine",
+
+    token: LiteralTokenType.String, /*string.regexp.quoted.single.python*/
+    begin: /\b(([uU]r)|([bB]r)|(r[bB]?))(")/dg,
+    beginCaptures: {
+        2: { token: MetaTokenType.Deprecated, /*invalid.deprecated.prefix.python*/ },
+        3: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        4: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        5: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(")|(?<!\\)(\n)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [doubleOneRegexpExpression]
+};
+
+export const regexpDoubleThreeLine: TokenPattern = {
+    debugName: "regexpDoubleThreeLine",
+
+    token: LiteralTokenType.String, /*string.regexp.quoted.multi.python*/
+    begin: /\b(([uU]r)|([bB]r)|(r[bB]?))(""")/dg,
+    beginCaptures: {
+        2: { token: MetaTokenType.Deprecated, /*invalid.deprecated.prefix.python*/ },
+        3: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        4: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        5: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(""")/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [doubleThreeRegexpExpression]
+};
+
+export const stringRawQuotedSingleLine: TokenPattern = {
+    debugName: "stringRawQuotedSingleLine",
+
+    token: LiteralTokenType.String, /*string.quoted.raw.single.python*/
+    begin: /\b(([uU]R)|(R))((['"]))/dg,
+    beginCaptures: {
+        2: { token: MetaTokenType.Deprecated, /*invalid.deprecated.prefix.python*/ },
+        3: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        4: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\4)|((?<!\\)\n)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [stringRawGuts]
+};
+
+export const stringBinQuotedSingleLine: TokenPattern = {
+    debugName: "stringBinQuotedSingleLine",
+
+    token: LiteralTokenType.String, /*string.quoted.binary.single.python*/
+    begin: /(\b[bB])((['"]))/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        2: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\2)|((?<!\\)\n)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [stringEntity]
+};
+
+export const stringRawBinQuotedSingleLine: TokenPattern = {
+    debugName: "stringRawBinQuotedSingleLine",
+
+    token: LiteralTokenType.String, /*string.quoted.raw.binary.single.python*/
+    begin: /(\b(?:R[bB]|[bB]R))((['"]))/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        2: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\2)|((?<!\\)\n)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [stringRawBinGuts]
+};
+
+export const stringQuotedSingleLine: TokenPattern = {
+    debugName: "stringQuotedSingleLine",
+
+    token: LiteralTokenType.String, /*string.quoted.single.python*/
+    begin: /(?:\b([rR])(?=[uU]))?([uU])?((['"]))/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.Invalid, /*invalid.illegal.prefix.python*/ },
+        2: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        3: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\3)|((?<!\\)\n)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [stringUnicodeGuts]
+};
+
+export const stringSingleBadBrace1FormattingUnicode: TokenPattern = {
+    debugName: "stringSingleBadBrace1FormattingUnicode",
+
+    // template using {% ... %}
+    begin: /(?=\{%(.*?(?!(['"])|((?<!\\)\n)))%\})/g,
+    end: /(?=(['"])|((?<!\\)\n))/g,
+    patterns: [
+        escapeSequenceUnicode,
+        escapeSequence,
+        stringLineContinuation,
+    ]
+};
+
+export const stringSingleBadBrace1FormattingRaw: TokenPattern = {
+    debugName: "stringSingleBadBrace1FormattingRaw",
+
+    // template using {% ... %}
+    begin: /(?=\{%(.*?(?!(['"])|((?<!\\)\n)))%\})/g,
+    end: /(?=(['"])|((?<!\\)\n))/g,
+    patterns: [stringConsumeEscape]
+};
+
+export const stringSingleBadBrace2FormattingUnicode: TokenPattern = {
+    debugName: "stringSingleBadBrace2FormattingUnicode",
+
+    // odd format or format-like syntax
+    begin: /(?!\{\{)(?=\{(\w*?(?!(['"])|((?<!\\)\n))[^!:\.\[}\w]).*?(?!(['"])|((?<!\\)\n))\})/g,
+    end: /(?=(['"])|((?<!\\)\n))/g,
+    patterns: [
+        escapeSequenceUnicode,
+        stringEntity,
+    ]
+};
+
+export const stringSingleBadBrace2FormattingRaw: TokenPattern = {
+    debugName: "stringSingleBadBrace2FormattingRaw",
+
+    // odd format or format-like syntax
+    begin: /(?!\{\{)(?=\{(\w*?(?!(['"])|((?<!\\)\n))[^!:\.\[}\w]).*?(?!(['"])|((?<!\\)\n))\})/g,
+    end: /(?=(['"])|((?<!\\)\n))/g,
+    patterns: [
+        stringConsumeEscape,
+        stringFormatting,
+    ]
+};
+
+export const stringRawQuotedMultiLine: TokenPattern = {
+    debugName: "stringRawQuotedMultiLine",
+
+    token: LiteralTokenType.String, /*string.quoted.raw.multi.python*/
+    begin: /\b(([uU]R)|(R))('''|""")/dg,
+    beginCaptures: {
+        2: { token: MetaTokenType.Deprecated, /*invalid.deprecated.prefix.python*/ },
+        3: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        4: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\4)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [stringRawGuts]
+};
+
+export const stringBinQuotedMultiLine: TokenPattern = {
+    debugName: "stringBinQuotedMultiLine",
+
+    token: LiteralTokenType.String, /*string.quoted.binary.multi.python*/
+    begin: /(\b[bB])('''|""")/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        2: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\2)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [stringEntity]
+};
+
+export const stringRawBinQuotedMultiLine: TokenPattern = {
+    debugName: "stringRawBinQuotedMultiLine",
+
+    token: LiteralTokenType.String, /*string.quoted.raw.binary.multi.python*/
+    begin: /(\b(?:R[bB]|[bB]R))('''|""")/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        2: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\2)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [stringRawBinGuts]
+};
+
+export const stringQuotedMultiLine: TokenPattern = {
+    debugName: "stringQuotedMultiLine",
+
+    token: LiteralTokenType.String, /*string.quoted.multi.python*/
+    begin: /(?:\b([rR])(?=[uU]))?([uU])?('''|""")/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.Invalid, /*invalid.illegal.prefix.python*/ },
+        2: { token: MetaTokenType.StringStorageType, /*storage.type.string.python*/ },
+        3: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\3)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [stringUnicodeGuts]
+};
+
+export const stringMultiBadBrace1FormattingUnicode: TokenPattern = {
+    debugName: "stringMultiBadBrace1FormattingUnicode",
+
+    // template using {% ... %}
+    begin: /(?=\{%(.*?(?!'''|"""))%\})/g,
+    end: /(?='''|""")/g,
+    patterns: [
+        escapeSequenceUnicode,
+        escapeSequence,
+        stringLineContinuation,
+    ]
+};
+
+export const stringMultiBadBrace1FormattingRaw: TokenPattern = {
+    debugName: "stringMultiBadBrace1FormattingRaw",
+
+    // template using {% ... %}
+    begin: /(?=\{%(.*?(?!'''|"""))%\})/g,
+    end: /(?='''|""")/g,
+    patterns: [stringConsumeEscape]
+};
+
+export const stringMultiBadBrace2FormattingUnicode: TokenPattern = {
+    debugName: "stringMultiBadBrace2FormattingUnicode",
+
+    // odd format or format-like syntax
+    begin: /(?!\{\{)(?=\{(\w*?(?!'''|""")[^!:\.\[}\w]).*?(?!'''|""")\})/g,
+    end: /(?='''|""")/g,
+    patterns: [
+        escapeSequenceUnicode,
+        stringEntity,
+    ]
+};
+
+export const stringMultiBadBrace2FormattingRaw: TokenPattern = {
+    debugName: "stringMultiBadBrace2FormattingRaw",
+
+    // odd format or format-like syntax
+    begin: /(?!\{\{)(?=\{(\w*?(?!'''|""")[^!:\.\[}\w]).*?(?!'''|""")\})/g,
+    end: /(?='''|""")/g,
+    patterns: [
+        stringConsumeEscape,
+        stringFormatting,
+    ]
+};
+
+export const fstringFnormQuotedSingleLine: TokenPattern = {
+    debugName: "fstringFnormQuotedSingleLine",
+
+    token: MetaTokenType.Fstring, /*meta.fstring.python*/
+    begin: /(\b[fF])([bBuU])?((['"]))/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.StringStorageType, /*string.interpolated.python string.quoted.single.python storage.type.string.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.prefix.python*/ },
+        3: { token: LiteralTokenType.String, /*punctuation.definition.string.begin.python string.interpolated.python string.quoted.single.python*/ },
+    },
+    end: /(\3)|((?<!\\)\n)/dg,
+    endCaptures: {
+        1: { token: LiteralTokenType.String, /*punctuation.definition.string.end.python string.interpolated.python string.quoted.single.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        fstringGuts,
+        fstringIllegalSingleBrace,
+    ]
+};
+
+export const fstringNormfQuotedSingleLine: TokenPattern = {
+    debugName: "fstringNormfQuotedSingleLine",
+
+    token: MetaTokenType.Fstring, /*meta.fstring.python*/
+    begin: /(\b[bBuU])([fF])((['"]))/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.Invalid, /*invalid.illegal.prefix.python*/ },
+        2: { token: MetaTokenType.StringStorageType, /*string.interpolated.python string.quoted.single.python storage.type.string.python*/ },
+        3: { token: MetaTokenType.StringBegin, /*string.quoted.single.python punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\3)|((?<!\\)\n)/dg,
+    endCaptures: {
+        1: { token: LiteralTokenType.String, /*punctuation.definition.string.end.python string.interpolated.python string.quoted.single.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        fstringGuts,
+        fstringIllegalSingleBrace,
+    ]
+};
+
+export const fstringRawQuotedSingleLine: TokenPattern = {
+    debugName: "fstringRawQuotedSingleLine",
+
+    token: MetaTokenType.Fstring, /*meta.fstring.python*/
+    begin: /(\b(?:[rR][fF]|[fF][rR]))((['"]))/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.StringStorageType, /*string.interpolated.python string.quoted.raw.single.python storage.type.string.python*/ },
+        2: { token: MetaTokenType.StringBegin, /*string.quoted.raw.single.python punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\2)|((?<!\\)\n)/dg,
+    endCaptures: {
+        1: { token: LiteralTokenType.String, /*punctuation.definition.string.end.python string.interpolated.python string.quoted.raw.single.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        fstringRawGuts,
+        fstringIllegalSingleBrace,
+    ]
+};
+
+export const fstringSingleCore: TokenPattern = {
+    debugName: "fstringSingleCore",
+
+    token: LiteralTokenType.String, /*string.interpolated.python string.quoted.single.python*/
+    match: /(.+?)(($\n?)|(?=[\\\}\{]|(['"])|((?<!\\)\n)))|\n/gm,
+};
+
+export const fstringRawSingleCore: TokenPattern = {
+    debugName: "fstringRawSingleCore",
+
+    token: LiteralTokenType.String, /*string.interpolated.python string.quoted.raw.single.python*/
+    match: /(.+?)(($\n?)|(?=[\\\}\{]|(['"])|((?<!\\)\n)))|\n/gm,
+};
+
+export const fstringSingleBrace: TokenPattern = {
+    debugName: "fstringSingleBrace",
+
+    // value interpolation using { ... }
+    begin: /(\{)/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+    },
+    end: /(\})|(?=\n)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+    },
+    patterns: [fExpression]
+};
+
+export const fstringTerminatorSingle: TokenPattern = {
+    patterns: [
+        {
+            debugName: "fstringTerminatorSingle.patterns![0]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(=(![rsa])?)(?=})/g,
+        },
+        {
+            debugName: "fstringTerminatorSingle.patterns![1]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(=?![rsa])(?=})/g,
+        },
+        {
+            debugName: "fstringTerminatorSingle.patterns![2]",
+
+            match: /((?:=?)(?:![rsa])?)(:\w?[<>=^]?[-+ ]?\#?\d*,?(\.\d+)?[bcdeEfFgGnosxX%]?)(?=})/dgm,
+            captures: {
+                1: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+                2: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+            },
+        },
+    ]
+};
+
+export const fstringTerminatorSingleTail: TokenPattern = {
+    debugName: "fstringTerminatorSingleTail",
+
+    begin: /((?:=?)(?:![rsa])?)(:)(?=.*?{)/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+        2: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+    },
+    end: /(?=})|(?=\n)/g,
+    patterns: [
+        fstringIllegalSingleBrace,
+        fstringSingleBrace,
+        {
+            debugName: "fstringTerminatorSingleTail.patterns![2]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /([bcdeEfFgGnosxX%])(?=})/g,
+        },
+        {
+            debugName: "fstringTerminatorSingleTail.patterns![3]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(\.\d+)/g,
+        },
+        {
+            debugName: "fstringTerminatorSingleTail.patterns![4]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(,)/g,
+        },
+        {
+            debugName: "fstringTerminatorSingleTail.patterns![5]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(\d+)/g,
+        },
+        {
+            debugName: "fstringTerminatorSingleTail.patterns![6]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(\#)/g,
+        },
+        {
+            debugName: "fstringTerminatorSingleTail.patterns![7]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /([-+ ])/g,
+        },
+        {
+            debugName: "fstringTerminatorSingleTail.patterns![8]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /([<>=^])/gm,
+        },
+        {
+            debugName: "fstringTerminatorSingleTail.patterns![9]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(\w)/g,
+        },
+    ]
+};
+
+export const fstringFnormQuotedMultiLine: TokenPattern = {
+    debugName: "fstringFnormQuotedMultiLine",
+
+    token: MetaTokenType.Fstring, /*meta.fstring.python*/
+    begin: /(\b[fF])([bBuU])?('''|""")/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.StringStorageType, /*string.interpolated.python string.quoted.multi.python storage.type.string.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.prefix.python*/ },
+        3: { token: LiteralTokenType.String, /*punctuation.definition.string.begin.python string.interpolated.python string.quoted.multi.python*/ },
+    },
+    end: /(\3)/dg,
+    endCaptures: {
+        1: { token: LiteralTokenType.String, /*punctuation.definition.string.end.python string.interpolated.python string.quoted.multi.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        fstringGuts,
+        fstringIllegalMultiBrace,
+    ]
+};
+
+export const fstringNormfQuotedMultiLine: TokenPattern = {
+    debugName: "fstringNormfQuotedMultiLine",
+
+    token: MetaTokenType.Fstring, /*meta.fstring.python*/
+    begin: /(\b[bBuU])([fF])('''|""")/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.Invalid, /*invalid.illegal.prefix.python*/ },
+        2: { token: MetaTokenType.StringStorageType, /*string.interpolated.python string.quoted.multi.python storage.type.string.python*/ },
+        3: { token: MetaTokenType.StringBegin, /*string.quoted.multi.python punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\3)/dg,
+    endCaptures: {
+        1: { token: LiteralTokenType.String, /*punctuation.definition.string.end.python string.interpolated.python string.quoted.multi.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        fstringGuts,
+        fstringIllegalMultiBrace,
+    ]
+};
+
+export const fstringRawQuotedMultiLine: TokenPattern = {
+    debugName: "fstringRawQuotedMultiLine",
+
+    token: MetaTokenType.Fstring, /*meta.fstring.python*/
+    begin: /(\b(?:[rR][fF]|[fF][rR]))('''|""")/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.StringStorageType, /*string.interpolated.python string.quoted.raw.multi.python storage.type.string.python*/ },
+        2: { token: MetaTokenType.StringBegin, /*string.quoted.raw.multi.python punctuation.definition.string.begin.python*/ },
+    },
+    end: /(\2)/dg,
+    endCaptures: {
+        1: { token: LiteralTokenType.String, /*punctuation.definition.string.end.python string.interpolated.python string.quoted.raw.multi.python*/ },
+        2: { token: MetaTokenType.Invalid, /*invalid.illegal.newline.python*/ },
+    },
+    patterns: [
+        fstringRawGuts,
+        fstringIllegalMultiBrace,
+    ]
+};
+
+export const fstringMultiCore: TokenPattern = {
+    debugName: "fstringMultiCore",
+
+    token: LiteralTokenType.String, /*string.interpolated.python string.quoted.multi.python*/
+    match: /(.+?)(($\n?)|(?=[\\\}\{]|'''|"""))|\n/gm,
+};
+
+export const fstringRawMultiCore: TokenPattern = {
+    debugName: "fstringRawMultiCore",
+
+    token: LiteralTokenType.String, /*string.interpolated.python string.quoted.raw.multi.python*/
+    match: /(.+?)(($\n?)|(?=[\\\}\{]|'''|"""))|\n/gm,
+};
+
+export const fstringMultiBrace: TokenPattern = {
+    debugName: "fstringMultiBrace",
+
+    // value interpolation using { ... }
+    begin: /(\{)/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+    },
+    end: /(\})/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.python*/ },
+    },
+    patterns: [fExpression]
+};
+
+export const fstringTerminatorMulti: TokenPattern = {
+    patterns: [
+        {
+            debugName: "fstringTerminatorMulti.patterns![0]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(=(![rsa])?)(?=})/g,
+        },
+        {
+            debugName: "fstringTerminatorMulti.patterns![1]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(=?![rsa])(?=})/g,
+        },
+        {
+            debugName: "fstringTerminatorMulti.patterns![2]",
+
+            match: /((?:=?)(?:![rsa])?)(:\w?[<>=^]?[-+ ]?\#?\d*,?(\.\d+)?[bcdeEfFgGnosxX%]?)(?=})/dgm,
+            captures: {
+                1: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+                2: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+            },
+        },
+    ]
+};
+
+export const fstringTerminatorMultiTail: TokenPattern = {
+    debugName: "fstringTerminatorMultiTail",
+
+    begin: /((?:=?)(?:![rsa])?)(:)(?=.*?{)/dg,
+    beginCaptures: {
+        1: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+        2: { token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/ },
+    },
+    end: /(?=})/g,
+    patterns: [
+        fstringIllegalMultiBrace,
+        fstringMultiBrace,
+        {
+            debugName: "fstringTerminatorMultiTail.patterns![2]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /([bcdeEfFgGnosxX%])(?=})/g,
+        },
+        {
+            debugName: "fstringTerminatorMultiTail.patterns![3]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(\.\d+)/g,
+        },
+        {
+            debugName: "fstringTerminatorMultiTail.patterns![4]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(,)/g,
+        },
+        {
+            debugName: "fstringTerminatorMultiTail.patterns![5]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(\d+)/g,
+        },
+        {
+            debugName: "fstringTerminatorMultiTail.patterns![6]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(\#)/g,
+        },
+        {
+            debugName: "fstringTerminatorMultiTail.patterns![7]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /([-+ ])/g,
+        },
+        {
+            debugName: "fstringTerminatorMultiTail.patterns![8]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /([<>=^])/gm,
+        },
+        {
+            debugName: "fstringTerminatorMultiTail.patterns![9]",
+
+            token: MetaTokenType.FormatStorageType, /*storage.type.format.python*/
+            match: /(\w)/g,
+        },
+    ]
+};
+
+// Push pattern references that were not defined on include
+python.patterns!.push(statement, expression);
+statement.patterns!.push(importStatement, classDeclaration, functionDeclaration, generator, statementKeyword, assignmentOperator, decorator, docstringStatement, semicolon);
+comments.patterns!.push(commentsBase);
+docstringStatement.patterns!.push(docstring);
+docstring.patterns![0].patterns!.push(docstringPrompt, codetags, docstringGutsUnicode);
+docstring.patterns![1].patterns!.push(stringConsumeEscape, docstringPrompt, codetags);
+docstring.patterns![2].patterns!.push(codetags, docstringGutsUnicode);
+docstring.patterns![3].patterns!.push(stringConsumeEscape, codetags);
+docstringGutsUnicode.patterns!.push(escapeSequenceUnicode, escapeSequence, stringLineContinuation);
+expressionBare.patterns!.push(backticks, illegalAnno, literal, regexp, string, lambda, generator, illegalOperator, operator, curlyBraces, itemAccess, list, oddFunctionCall, roundBraces, functionCall, builtinFunctions, builtinTypes, builtinExceptions, magicNames, specialNames, illegalNames, specialVariables, ellipsis, punctuation, lineContinuation);
+expressionBase.patterns!.push(lineContinuation);
+expression.patterns!.splice(1, 0, memberAccess);
+memberAccess.patterns!.push(functionCall, memberAccessBase, memberAccessAttribute);
+memberAccessBase.patterns!.push(magicNames, illegalNames, illegalObjectName, specialNames, lineContinuation, itemAccess);
+oddFunctionCall.patterns!.push(functionArguments);
+lineContinuation.patterns![1].patterns!.push(regexp, string);
+literal.patterns!.push(number);
+number.patterns!.splice(0, 0, numberFloat);
+number.patterns!.splice(1, 0, numberDec);
+number.patterns!.splice(2, 0, numberHex);
+number.patterns!.splice(3, 0, numberOct);
+number.patterns!.splice(4, 0, numberBin);
+number.patterns!.splice(5, 0, numberLong);
+regexp.patterns!.push(regexpSingleThreeLine, regexpDoubleThreeLine, regexpSingleOneLine, regexpDoubleOneLine);
+string.patterns!.push(stringQuotedMultiLine, stringQuotedSingleLine, stringBinQuotedMultiLine, stringBinQuotedSingleLine, stringRawQuotedMultiLine, stringRawQuotedSingleLine, stringRawBinQuotedMultiLine, stringRawBinQuotedSingleLine, fstringFnormQuotedMultiLine, fstringFnormQuotedSingleLine, fstringNormfQuotedMultiLine, fstringNormfQuotedSingleLine, fstringRawQuotedMultiLine, fstringRawQuotedSingleLine);
+stringUnicodeGuts.patterns!.push(escapeSequenceUnicode, stringEntity, stringBraceFormatting);
+stringRawGuts.patterns!.push(stringFormatting, stringBraceFormatting);
+stringRawBinGuts.patterns!.push(stringFormatting);
+stringEntity.patterns!.push(escapeSequence, stringLineContinuation, stringFormatting);
+fstringGuts.patterns!.push(escapeSequenceUnicode, escapeSequence, stringLineContinuation, fstringFormatting);
+fstringRawGuts.patterns!.push(fstringFormatting);
+fstringIllegalSingleBrace.patterns!.push(fstringTerminatorSingle, fExpression);
+fstringFormatting.patterns!.push(fstringFormattingBraces, fstringFormattingSingeBrace);
+classDeclaration.patterns![0].patterns!.push(className, classInheritance);
+className.patterns!.splice(0, 0, illegalObjectName);
+className.patterns!.splice(1, 0, builtinPossibleCallables);
+classInheritance.patterns!.splice(4, 0, illegalNames);
+classInheritance.patterns!.splice(5, 0, classKwarg);
+classInheritance.patterns!.splice(6, 0, callWrapperInheritance);
+classInheritance.patterns!.push(memberAccessClass, inheritanceIdentifier);
+memberAccessClass.patterns!.splice(0, 0, callWrapperInheritance);
+lambda.patterns![2].patterns!.splice(2, 0, lambdaNestedIncomplete);
+lambda.patterns![2].patterns!.splice(3, 0, illegalNames);
+lambda.patterns![2].patterns!.splice(6, 0, backticks);
+lambda.patterns![2].patterns!.splice(7, 0, illegalAnno);
+lambda.patterns![2].patterns!.splice(8, 0, lambdaParameterWithDefault);
+lambda.patterns![2].patterns!.push(illegalOperator);
+functionDeclaration.patterns!.splice(0, 0, functionDefName);
+functionDeclaration.patterns!.splice(1, 0, parameters);
+functionDeclaration.patterns!.push(returnAnnotation);
+functionDefName.patterns!.splice(0, 0, illegalObjectName);
+functionDefName.patterns!.splice(1, 0, builtinPossibleCallables);
+parameters.patterns!.splice(3, 0, illegalNames);
+parameters.patterns!.splice(4, 0, illegalObjectName);
+parameters.patterns!.splice(5, 0, parameterSpecial);
+parameters.patterns!.push(looseDefault, annotatedParameter);
+itemAccess.patterns![0].patterns!.splice(0, 0, itemName);
+itemAccess.patterns![0].patterns!.splice(1, 0, itemIndex);
+itemName.patterns!.splice(0, 0, specialVariables);
+itemName.patterns!.splice(1, 0, builtinFunctions);
+decorator.patterns!.push(decoratorName, functionArguments);
+decoratorName.patterns!.splice(0, 0, builtinCallables);
+decoratorName.patterns!.splice(1, 0, illegalObjectName);
+callWrapperInheritance.patterns!.push(inheritanceName, functionArguments);
+inheritanceName.patterns!.splice(1, 0, builtinPossibleCallables);
+functionCall.patterns!.push(specialVariables, functionName, functionArguments);
+functionName.patterns!.splice(0, 0, builtinPossibleCallables);
+functionArguments.patterns!.splice(3, 0, illegalNames);
+builtinCallables.patterns!.push(illegalNames, illegalObjectName, builtinExceptions, builtinFunctions, builtinTypes);
+builtinPossibleCallables.patterns!.push(magicNames);
+regexpBaseExpression.patterns!.push(regexpQuantifier, regexpBaseCommon);
+fregexpBaseExpression.patterns!.splice(0, 0, fregexpQuantifier);
+fregexpBaseExpression.patterns!.splice(1, 0, fstringFormattingBraces);
+fregexpBaseExpression.patterns!.push(regexpBaseCommon);
+regexpBaseCommon.patterns!.push(regexpEscapeSequence);
+singleOneRegexpExpression.patterns!.splice(1, 0, singleOneRegexpCharacterSet);
+singleOneRegexpExpression.patterns!.splice(2, 0, singleOneRegexpComments);
+singleOneRegexpExpression.patterns!.splice(4, 0, singleOneRegexpNamedGroup);
+singleOneRegexpExpression.patterns!.push(singleOneRegexpLookahead, singleOneRegexpLookaheadNegative, singleOneRegexpLookbehind, singleOneRegexpLookbehindNegative, singleOneRegexpConditional, singleOneRegexpParenthesesNonCapturing, singleOneRegexpParentheses);
+singleThreeRegexpExpression.patterns!.splice(1, 0, singleThreeRegexpCharacterSet);
+singleThreeRegexpExpression.patterns!.splice(2, 0, singleThreeRegexpComments);
+singleThreeRegexpExpression.patterns!.splice(4, 0, singleThreeRegexpNamedGroup);
+singleThreeRegexpExpression.patterns!.splice(6, 0, singleThreeRegexpLookahead);
+singleThreeRegexpExpression.patterns!.splice(7, 0, singleThreeRegexpLookaheadNegative);
+singleThreeRegexpExpression.patterns!.splice(8, 0, singleThreeRegexpLookbehind);
+singleThreeRegexpExpression.patterns!.splice(9, 0, singleThreeRegexpLookbehindNegative);
+singleThreeRegexpExpression.patterns!.splice(10, 0, singleThreeRegexpConditional);
+singleThreeRegexpExpression.patterns!.splice(11, 0, singleThreeRegexpParenthesesNonCapturing);
+singleThreeRegexpExpression.patterns!.splice(12, 0, singleThreeRegexpParentheses);
+doubleOneRegexpExpression.patterns!.splice(1, 0, doubleOneRegexpCharacterSet);
+doubleOneRegexpExpression.patterns!.splice(2, 0, doubleOneRegexpComments);
+doubleOneRegexpExpression.patterns!.splice(4, 0, doubleOneRegexpNamedGroup);
+doubleOneRegexpExpression.patterns!.push(doubleOneRegexpLookahead, doubleOneRegexpLookaheadNegative, doubleOneRegexpLookbehind, doubleOneRegexpLookbehindNegative, doubleOneRegexpConditional, doubleOneRegexpParenthesesNonCapturing, doubleOneRegexpParentheses);
+doubleThreeRegexpExpression.patterns!.splice(1, 0, doubleThreeRegexpCharacterSet);
+doubleThreeRegexpExpression.patterns!.splice(2, 0, doubleThreeRegexpComments);
+doubleThreeRegexpExpression.patterns!.splice(4, 0, doubleThreeRegexpNamedGroup);
+doubleThreeRegexpExpression.patterns!.splice(6, 0, doubleThreeRegexpLookahead);
+doubleThreeRegexpExpression.patterns!.splice(7, 0, doubleThreeRegexpLookaheadNegative);
+doubleThreeRegexpExpression.patterns!.splice(8, 0, doubleThreeRegexpLookbehind);
+doubleThreeRegexpExpression.patterns!.splice(9, 0, doubleThreeRegexpLookbehindNegative);
+doubleThreeRegexpExpression.patterns!.splice(10, 0, doubleThreeRegexpConditional);
+doubleThreeRegexpExpression.patterns!.splice(11, 0, doubleThreeRegexpParenthesesNonCapturing);
+doubleThreeRegexpExpression.patterns!.splice(12, 0, doubleThreeRegexpParentheses);
+stringRawQuotedSingleLine.patterns!.splice(0, 0, stringSingleBadBrace1FormattingRaw);
+stringRawQuotedSingleLine.patterns!.splice(1, 0, stringSingleBadBrace2FormattingRaw);
+stringQuotedSingleLine.patterns!.splice(0, 0, stringSingleBadBrace1FormattingUnicode);
+stringQuotedSingleLine.patterns!.splice(1, 0, stringSingleBadBrace2FormattingUnicode);
+stringRawQuotedMultiLine.patterns!.splice(0, 0, stringMultiBadBrace1FormattingRaw);
+stringRawQuotedMultiLine.patterns!.splice(1, 0, stringMultiBadBrace2FormattingRaw);
+stringQuotedMultiLine.patterns!.splice(0, 0, stringMultiBadBrace1FormattingUnicode);
+stringQuotedMultiLine.patterns!.splice(1, 0, stringMultiBadBrace2FormattingUnicode);
+fstringFnormQuotedSingleLine.patterns!.push(fstringSingleBrace, fstringSingleCore);
+fstringNormfQuotedSingleLine.patterns!.push(fstringSingleBrace, fstringSingleCore);
+fstringRawQuotedSingleLine.patterns!.push(fstringSingleBrace, fstringRawSingleCore);
+fstringSingleBrace.patterns!.splice(0, 0, fstringTerminatorSingle);
+fstringTerminatorSingle.patterns!.push(fstringTerminatorSingleTail);
+fstringFnormQuotedMultiLine.patterns!.push(fstringMultiBrace, fstringMultiCore);
+fstringNormfQuotedMultiLine.patterns!.push(fstringMultiBrace, fstringMultiCore);
+fstringRawQuotedMultiLine.patterns!.push(fstringMultiBrace, fstringRawMultiCore);
+fstringMultiBrace.patterns!.splice(0, 0, fstringTerminatorMulti);
+fstringTerminatorMulti.patterns!.push(fstringTerminatorMultiTail);
\ No newline at end of file
diff --git a/src/tokenizer/python-token-patterns.ts b/src/tokenizer/python-token-patterns.ts
deleted file mode 100644
index 5940792..0000000
--- a/src/tokenizer/python-token-patterns.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-/* eslint-disable no-useless-escape */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable no-useless-backreference */
-import { charactersPatten, strings } from "./common-token-patterns";
-import { MetaTokenType } from "./renpy-tokens";
-import { TokenPattern, TokenRepoPattern } from "./token-pattern-types";
-
-export const pythonMemberAccess: TokenPattern = {
-    patterns: [charactersPatten],
-};
-
-export const pythonExpressionBare: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonExpressionBase: TokenPattern = {
-    patterns: [strings],
-};
-export const pythonExpression: TokenPattern = {
-    // All valid Python expressions
-    patterns: [pythonExpressionBase, pythonMemberAccess, charactersPatten],
-};
-
-export const semicolon: TokenPattern = {
-    patterns: [
-        {
-            token: MetaTokenType.Invalid,
-            match: /\\;$/g,
-        },
-    ],
-};
-
-export const pythonLiteral: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonIllegalOperator: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonOperator: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonCurlyBraces: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonItemAccess: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonList: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonOddFunctionCall: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonRoundBraces: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonFunctionCall: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonBuiltinFunctions: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonBuiltinTypes: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonBuiltinExceptions: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonMagicNames: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonSpecialNames: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonIllegalNames: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonSpecialVariables: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonEllipsis: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonPunctuation: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonLineContinuation: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonBuiltinPossibleCallables: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonFunctionArguments: TokenPattern = {
-    patterns: [charactersPatten],
-};
-export const pythonNumber: TokenPattern = {
-    patterns: [charactersPatten],
-};
-
-export const pythonPatterns: TokenRepoPattern = {
-    patterns: [],
-};
diff --git a/src/tokenizer/renpy-token-patterns.g.ts b/src/tokenizer/renpy-token-patterns.g.ts
new file mode 100644
index 0000000..18a72c7
--- /dev/null
+++ b/src/tokenizer/renpy-token-patterns.g.ts
@@ -0,0 +1,1728 @@
+/* eslint-disable no-useless-escape */
+/* eslint-disable no-useless-backreference */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+// THIS FILE HAS BEEN GENERATED BY THE `syntax-to-token-pattern.py` GENERATOR
+// DO NOT EDIT THIS FILE DIRECTLY! INSTEAD RUN THE PYTHON SCRIPT.
+// ANY MANUAL EDITS MADE TO THIS FILE WILL BE OVERWRITTEN. YOU HAVE BEEN WARNED.
+// Last generated: 01/06/2023 14:57:48 (UTC+0)
+
+import { MetaTokenType, CharacterTokenType, LiteralTokenType, KeywordTokenType, EscapedCharacterTokenType, EntityTokenType, OperatorTokenType } from "./renpy-tokens";
+import { TokenPattern } from "./token-pattern-types";
+
+export const statements: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const expressions: TokenPattern = {
+    patterns: [
+    ]
+};
+
+export const invalidToken: TokenPattern = {
+    debugName: "invalidToken",
+
+    token: MetaTokenType.Invalid, /*invalid.unknown.token.renpy*/
+    match: /.+/g,
+};
+
+export const newLine: TokenPattern = {
+    debugName: "newLine",
+
+    token: CharacterTokenType.NewLine, /*punctuation.new-line.renpy*/
+    match: /\r\n|\r|\n/g,
+};
+
+export const whitespace: TokenPattern = {
+    debugName: "whitespace",
+
+    token: CharacterTokenType.Whitespace, /*punctuation.whitespace.renpy*/
+    match: /[ \t]+/g,
+};
+
+export const fallbackCharacters: TokenPattern = {
+    // NOTE: Having these patterns separated increases performance. Benchmark before making a change!
+    patterns: [
+        newLine,
+        whitespace,
+        {
+            debugName: "fallbackCharacters.patterns![2]",
+
+            token: CharacterTokenType.OpenParentheses, /*punctuation.parenthesis.begin.renpy*/
+            match: /\(/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![3]",
+
+            token: CharacterTokenType.CloseParentheses, /*punctuation.parenthesis.end.renpy*/
+            match: /\)/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![4]",
+
+            token: CharacterTokenType.OpenBracket, /*punctuation.bracket.begin.renpy*/
+            match: /{/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![5]",
+
+            token: CharacterTokenType.CloseBracket, /*punctuation.bracket.end.renpy*/
+            match: /}/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![6]",
+
+            token: CharacterTokenType.OpenSquareBracket, /*punctuation.square-bracket.begin.renpy*/
+            match: /\[/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![7]",
+
+            token: CharacterTokenType.CloseSquareBracket, /*punctuation.square-bracket.end.renpy*/
+            match: /\]/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![8]",
+
+            token: CharacterTokenType.Period, /*punctuation.period.renpy*/
+            match: /\./g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![9]",
+
+            token: CharacterTokenType.Colon, /*punctuation.colon.renpy*/
+            match: /:/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![10]",
+
+            token: CharacterTokenType.Semicolon, /*punctuation.semicolon.renpy*/
+            match: /;/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![11]",
+
+            token: CharacterTokenType.Comma, /*punctuation.comma.renpy*/
+            match: /,/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![12]",
+
+            token: CharacterTokenType.Hashtag, /*punctuation.hashtag.renpy*/
+            match: /#/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![13]",
+
+            token: CharacterTokenType.Quote, /*punctuation.quote.renpy*/
+            match: /'/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![14]",
+
+            token: CharacterTokenType.DoubleQuote, /*punctuation.double-quote.renpy*/
+            match: /"/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![15]",
+
+            token: CharacterTokenType.BackQuote, /*punctuation.back-quote.renpy*/
+            match: /`/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![16]",
+
+            token: CharacterTokenType.Backslash, /*punctuation.backslash.renpy*/
+            match: /\\/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![17]",
+
+            token: CharacterTokenType.ForwardSlash, /*punctuation.forward-slash.renpy*/
+            match: /\//g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![18]",
+
+            token: CharacterTokenType.EqualsSymbol, /*punctuation.equals-symbol.renpy*/
+            match: /=/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![19]",
+
+            token: MetaTokenType.Invalid, /*invalid.illegal.word.renpy*/
+            match: /\b\w+\b/g,
+        },
+        {
+            debugName: "fallbackCharacters.patterns![20]",
+
+            token: CharacterTokenType.Unknown, /*punctuation.unknown.renpy*/
+            match: /./g,
+        },
+    ]
+};
+
+export const literal: TokenPattern = {
+    patterns: [
+        {
+            debugName: "literal.patterns![0]",
+
+            // Python literals
+            token: MetaTokenType.ConstantLiteral, /*constant.language.renpy*/
+            match: /\b(?<!\.)(True|False|None)\b/g,
+        },
+    ]
+};
+
+export const numFloat: TokenPattern = {
+    debugName: "numFloat",
+
+    token: LiteralTokenType.Float, /*constant.numeric.float.renpy*/
+    match: /(?<!\w)(?:\.[0-9]*|[0-9]*\.[0-9]*|[0-9]*\.)\b/g,
+};
+
+export const numInt: TokenPattern = {
+    debugName: "numInt",
+
+    token: LiteralTokenType.Integer, /*constant.numeric.integer.renpy*/
+    match: /(?<![\w.])(?:[1-9]*|0+|0([0-9]+)(?![eE.]))\b/dg,
+    captures: {
+        1: { token: MetaTokenType.Invalid, /*invalid.illegal.integer.renpy*/ },
+    },
+};
+
+export const keywords: TokenPattern = {
+    // Fallback patterns for unmatched keywords
+    patterns: [
+        {
+            debugName: "keywords.patterns![0]",
+
+            // Control flow keywords
+            token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.renpy*/
+            match: /\b(?<!\.)(?:pass|return|pause)\b/g,
+        },
+        {
+            debugName: "keywords.patterns![1]",
+
+            // Control flow keywords with block
+            contentToken: MetaTokenType.PythonLine, /*meta.embedded.line.python*/
+            begin: /\b(?<!\.)(?:(if|elif|else)|(for|while))\b/dg,
+            beginCaptures: {
+                1: { token: KeywordTokenType.If, /*keyword.control.conditional.renpy*/ },
+                2: { token: MetaTokenType.ControlFlowKeyword, /*keyword.control.flow.renpy*/ },
+            },
+            end: /:|$/dgm,
+            endCaptures: {
+                0: { token: CharacterTokenType.Colon, /*punctuation.section.block.begin.renpy*/ },
+            },
+            patterns: [expressions]
+        },
+        {
+            debugName: "keywords.patterns![2]",
+
+            // Python statement keywords
+            token: KeywordTokenType.OtherPython, /*keyword.other.python.renpy*/
+            match: /\b(?<!\.)(define|default|early|hide|in|init|python)\b/g,
+        },
+        {
+            debugName: "keywords.patterns![3]",
+
+            // Renpy keywords
+            token: KeywordTokenType.Other, /*keyword.other.renpy*/
+            match: /\b(?<!\.)(?:camera|image|label|layeredimage|menu|nvl[ \t]+clear|play|queue|scene|screen|show|transform|translate|voice(?:[ \t]+sustain)?|window|frame)\b/g,
+        },
+        {
+            debugName: "keywords.patterns![4]",
+
+            // [TODO: Should probably only be a keyword in the expression] Renpy sub expression keywords
+            token: KeywordTokenType.Other, /*keyword.other.renpy*/
+            match: /\b(?<!\.)(?:set|expression|at|with|from)\b/g,
+        },
+    ]
+};
+
+export const comments: TokenPattern = {
+    patterns: [
+        {
+            debugName: "comments.patterns![0]",
+
+            token: MetaTokenType.Comment, /*comment.line.number-sign.renpy*/
+            match: /(?<=^[ \t]*)(#[ \t]*(?:end)?region)\b.*$/dgm,
+            captures: {
+                1: { token: MetaTokenType.CommentRegionTag, /*punctuation.definition.tag.region*/ },
+            },
+        },
+        {
+            debugName: "comments.patterns![1]",
+
+            token: MetaTokenType.Comment, /*comment.line.number-sign.renpy*/
+            match: /(#)(.*)$/dgm,
+            captures: {
+                1: { token: CharacterTokenType.Hashtag, /*punctuation.definition.comment.renpy*/ },
+                2: {
+                    patterns: [
+                        {
+                            debugName: "comments.patterns![1].captures![2].patterns![0]",
+
+                            // Code Tags
+                            match: /(?:\b(NOTE|XXX|HACK|FIXME|BUG|TODO)\b)/dg,
+                            captures: {
+                                1: { token: MetaTokenType.CommentCodeTag, /*keyword.codetag.notation.renpy*/ },
+                            },
+                        },
+                    ]
+                },
+            },
+        },
+    ]
+};
+
+export const escapedChar: TokenPattern = {
+    debugName: "escapedChar",
+
+    match: /(\\")|(\\')|(\\ )|(\\n)|(\\\\)|(\[\[)|({{)/dg,
+    captures: {
+        1: { token: EscapedCharacterTokenType.EscDoubleQuote, /*constant.character.escape.double-quote.python.renpy*/ },
+        2: { token: EscapedCharacterTokenType.EscQuote, /*constant.character.escape.quote.python.renpy*/ },
+        3: { token: EscapedCharacterTokenType.EscWhitespace, /*constant.character.escape.whitespace.python.renpy*/ },
+        4: { token: EscapedCharacterTokenType.EscNewline, /*constant.character.escape.newline.python.renpy*/ },
+        5: { token: EscapedCharacterTokenType.EscBackslash, /*constant.character.escape.backslash.python.renpy*/ },
+        6: { token: EscapedCharacterTokenType.EscOpenBracket, /*constant.character.escape.open.bracket.python.renpy*/ },
+        7: { token: EscapedCharacterTokenType.EscOpenSquareBracket, /*constant.character.escape.open.square-bracket.python.renpy*/ },
+    },
+};
+
+export const constantPlaceholder: TokenPattern = {
+    debugName: "constantPlaceholder",
+
+    // Python value interpolation using [ ... ]
+    token: MetaTokenType.ConstantCaps, /*constant.other.placeholder.tags.renpy*/
+    match: /(\[)(.*?)(\])(?![^\[]*?\])/dg,
+    captures: {
+        1: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.renpy*/ },
+        2: {
+            token: MetaTokenType.PythonLine, /*meta.embedded.line.python*/
+            patterns: [
+            ]
+        },
+        3: { token: MetaTokenType.Placeholder, /*constant.character.format.placeholder.other.renpy*/ },
+    },
+};
+
+export const escapedUnicodeChar: TokenPattern = {
+    debugName: "escapedUnicodeChar",
+
+    match: /(\\U[0-9A-Fa-f]{8})|(\\u[0-9A-Fa-f]{4})|(\\N\{[a-zA-Z ]+\})/dg,
+    captures: {
+        1: { token: MetaTokenType.EscapeSequence, /*constant.character.unicode.16-bit-hex.python.renpy*/ },
+        2: { token: MetaTokenType.EscapeSequence, /*constant.character.unicode.32-bit-hex.python.renpy*/ },
+        3: { token: MetaTokenType.EscapeSequence, /*constant.character.unicode.name.python.renpy*/ },
+    },
+};
+
+export const hexLiteral: TokenPattern = {
+    // Note: This pattern has no end check. Only use as include pattern!
+    patterns: [
+        {
+            debugName: "hexLiteral.patterns![0]",
+
+            // rgb, rgba, rrggbb, rrggbbaa
+            token: LiteralTokenType.Color, /*constant.color.renpy*/
+            match: /#(?:[a-f0-9]{8}|[a-f0-9]{6}|[a-f0-9]{3,4})\b/gi,
+        },
+        {
+            debugName: "hexLiteral.patterns![1]",
+
+            token: MetaTokenType.Invalid, /*invalid.illegal.unexpected-number-of-hex-values.renpy*/
+            match: /#[a-f0-9]+\b/gi,
+        },
+        {
+            debugName: "hexLiteral.patterns![2]",
+
+            token: LiteralTokenType.Color, /*constant.color.renpy*/
+            match: /(?:#[a-f0-9]*)?(.+)/dgi,
+            captures: {
+                1: { token: MetaTokenType.Invalid, /*invalid.illegal.character-not-allowed-here.renpy*/ },
+            },
+        },
+    ]
+};
+
+export const stringsInterior: TokenPattern = {
+    patterns: [
+        newLine,
+        escapedChar,
+        constantPlaceholder,
+    ]
+};
+
+export const stringTags: TokenPattern = {
+    patterns: [
+        {
+            debugName: "stringTags.patterns![0]",
+
+            // Valid tags without params (self-closing)
+            token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.self-closing.renpy*/
+            match: /({)\s*(nw|done|fast|p|w|clear)\s*(})/dg,
+            captures: {
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+        },
+        {
+            debugName: "stringTags.patterns![1]",
+
+            // Valid tags with numeric params (self-closing)
+            token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.self-closing.renpy*/
+            match: /({)\s*(p|w)(=)(\+?)(\d*(?:.\d+)?)\s*(})/dg,
+            captures: {
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: OperatorTokenType.Assignment, /*punctuation.separator.key-value.renpy keyword.operator.assignment.renpy*/ },
+                4: { token: OperatorTokenType.Plus, /*keyword.operator.arithmetic.plus.renpy*/ },
+                5: { token: LiteralTokenType.Float, /*support.constant.property-value.renpy constant.numeric.float.renpy*/ },
+                6: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+        },
+        {
+            debugName: "stringTags.patterns![2]",
+
+            // Valid tags with numeric params (self-closing)
+            token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.self-closing.renpy*/
+            match: /({)\s*(v?space)(=)(\+?)(\d+)\s*(})/dg,
+            captures: {
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: OperatorTokenType.Assignment, /*punctuation.separator.key-value.renpy keyword.operator.assignment.renpy*/ },
+                4: { token: OperatorTokenType.Plus, /*keyword.operator.arithmetic.plus.renpy*/ },
+                5: { token: LiteralTokenType.Integer, /*support.constant.property-value.renpy constant.numeric.integer.renpy*/ },
+                6: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+        },
+        {
+            debugName: "stringTags.patterns![3]",
+
+            // Comment tag (self-closing)
+            token: MetaTokenType.StringTag, /*meta.string.tag.comment.self-closing.renpy*/
+            match: /({)\s*(#)\s*(.*?)\s*(})/dg,
+            captures: {
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: CharacterTokenType.Hashtag, /*comment.line.number-sign.renpy punctuation.definition.comment.renpy*/ },
+                3: { token: MetaTokenType.Comment, /*comment.line.number-sign.renpy*/ },
+                4: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+        },
+        {
+            debugName: "stringTags.patterns![4]",
+
+            // Valid tags with file param
+            token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.self-closing.renpy*/
+            match: /({)\s*(image)(=)([\w.]+)\s*(})/dg,
+            captures: {
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: OperatorTokenType.Assignment, /*punctuation.separator.key-value.renpy keyword.operator.assignment.renpy*/ },
+                4: { token: LiteralTokenType.String, /*support.constant.property-value.renpy string.unquoted.renpy*/ },
+                5: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+        },
+        {
+            debugName: "stringTags.patterns![5]",
+
+            // Valid tags without params (close required)
+            contentToken: MetaTokenType.TaggedString, /*renpy.meta.${2:/downcase} meta.tagged.string.renpy*/
+            begin: /({)\s*(u|i|b|s|plain|alt|noalt|art|rb|rt)\s*(})/dg,
+            beginCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.start.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            end: /({\/)\s*(\2)\s*(})/dg,
+            endCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.end.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            patterns: [stringsInterior]
+        },
+        {
+            debugName: "stringTags.patterns![6]",
+
+            // Valid tags with numeric params (close required)
+            contentToken: MetaTokenType.TaggedString, /*renpy.meta.${2:/downcase} meta.tagged.string.renpy*/
+            begin: /({)\s*(alpha|cps|k)(=)(?:(\*)|(\-)|(\+))?(\d*(?:.\d+)?)\s*(})/dg,
+            beginCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.start.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: OperatorTokenType.Assignment, /*punctuation.separator.key-value.renpy keyword.operator.assignment.renpy*/ },
+                4: { token: OperatorTokenType.Multiply, /*keyword.operator.arithmetic.Multiply.renpy*/ },
+                5: { token: OperatorTokenType.Minus, /*keyword.operator.arithmetic.Minus.renpy*/ },
+                6: { token: OperatorTokenType.Plus, /*keyword.operator.arithmetic.Plus.renpy*/ },
+                7: { token: MetaTokenType.ConstantNumeric, /*support.constant.property-value.renpy constant.numeric.renpy*/ },
+                8: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            end: /({\/)\s*(\2)\s*(})/dg,
+            endCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.end.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            patterns: [stringsInterior]
+        },
+        {
+            debugName: "stringTags.patterns![7]",
+
+            // Valid tags with numeric params (close required)
+            contentToken: MetaTokenType.TaggedString, /*renpy.meta.${2:/downcase} meta.tagged.string.renpy*/
+            begin: /({)\s*(size)(=)([\-+]?)(\d+)\s*(})/dg,
+            beginCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.start.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: OperatorTokenType.Assignment, /*punctuation.separator.key-value.renpy keyword.operator.assignment.renpy*/ },
+                4: { token: MetaTokenType.ArithmeticOperator, /*keyword.operator.arithmetic.renpy*/ },
+                5: { token: LiteralTokenType.Integer, /*support.constant.property-value.renpy constant.numeric.integer.renpy*/ },
+                6: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            end: /({\/)\s*(\2)\s*(})/dg,
+            endCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.end.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            patterns: [stringsInterior]
+        },
+        {
+            debugName: "stringTags.patterns![8]",
+
+            // Valid tags with file param (close required)
+            token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.self-closing.renpy*/
+            begin: /({)\s*(font)(=)([\w.]+)\s*(})/dg,
+            beginCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.start.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: OperatorTokenType.Assignment, /*punctuation.separator.key-value.renpy keyword.operator.assignment.renpy*/ },
+                4: { token: LiteralTokenType.String, /*support.constant.property-value.renpy string.unquoted.renpy*/ },
+                5: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            end: /({\/)\s*(\2)\s*(})/dg,
+            endCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.end.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            patterns: [stringsInterior]
+        },
+        {
+            debugName: "stringTags.patterns![9]",
+
+            // Color tag
+            contentToken: MetaTokenType.TaggedString, /*renpy.meta.${2:/downcase}.${4:/downcase} meta.tagged.string.renpy*/
+            begin: /({)\s*(color|outlinecolor)(=)(#?[a-zA-Z0-9]+)\s*(})/dg,
+            beginCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.start.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: OperatorTokenType.Assignment, /*punctuation.separator.key-value.renpy keyword.operator.assignment.renpy*/ },
+                4: {
+                    token: LiteralTokenType.Color, /*constant.color.renpy*/
+                    patterns: [hexLiteral]
+                },
+                5: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            end: /({\/)\s*(\2)\s*(})/dg,
+            endCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.end.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            patterns: [stringsInterior]
+        },
+        {
+            debugName: "stringTags.patterns![10]",
+
+            // a tag
+            contentToken: MetaTokenType.TaggedString, /*renpy.meta.${2:/downcase} meta.tagged.string.renpy*/
+            begin: /({)\s*(a)(=)(.*?)\s*(})/dg,
+            beginCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.start.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: OperatorTokenType.Assignment, /*punctuation.separator.key-value.renpy keyword.operator.assignment.renpy*/ },
+                4: {
+                    token: LiteralTokenType.String, /*support.constant.property-value.renpy string.unquoted.renpy*/
+                    patterns: [
+                    ]
+                },
+                5: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            end: /({\/)\s*(\2)\s*(})/dg,
+            endCaptures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.end.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+            patterns: [stringsInterior]
+        },
+        {
+            debugName: "stringTags.patterns![11]",
+
+            // Unknown tag (Single line support only cus \R does not work) (Since we don't know if a tag is self closing, we can't assume that an end pattern exists)
+            match: /({)[ \t]*(\w+)\b(?:(=)(.*?))?\s*(})((?:.|\R)+?)\s*({\/)\s*(\2)\s*(})/dg,
+            captures: {
+                1: { token: CharacterTokenType.OpenBracket, /*meta.string.tag.${2:/downcase}.start.renpy punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*meta.string.tag.${2:/downcase}.start.renpy renpy.meta.u entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: OperatorTokenType.Assignment, /*meta.string.tag.${2:/downcase}.start.renpy punctuation.separator.key-value.renpy keyword.operator.assignment.renpy*/ },
+                4: { token: MetaTokenType.ConstantCaps, /*meta.string.tag.${2:/downcase}.start.renpy constant.other.placeholder.tags.renpy*/ },
+                5: { token: CharacterTokenType.CloseBracket, /*meta.string.tag.${2:/downcase}.start.renpy punctuation.definition.tag.end.renpy*/ },
+                6: { token: MetaTokenType.TaggedString, /*renpy.meta.string.tag.custom.${2:/downcase } meta.tagged.string.renpy*/
+                    patterns: [stringsInterior]
+                },
+                7: { token: CharacterTokenType.OpenBracket, /*meta.string.tag.${2:/downcase}.end.renpy punctuation.definition.tag.begin.renpy*/ },
+                8: { token: EntityTokenType.TagName, /*meta.string.tag.${2:/downcase}.end.renpy renpy.meta.u entity.name.tag.${2:/downcase}.renpy*/ },
+                9: { token: CharacterTokenType.CloseBracket, /*meta.string.tag.${2:/downcase}.end.renpy punctuation.definition.tag.end.renpy*/ },
+            },
+        },
+        {
+            debugName: "stringTags.patterns![12]",
+
+            // Unknown tag start
+            match: /({)\s*(\w*)(?:(=)(.*?))?\s*(})/dg,
+            captures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.start.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*renpy.meta.u entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: OperatorTokenType.Assignment, /*punctuation.separator.key-value.renpy keyword.operator.assignment.renpy*/ },
+                4: {
+                    token: MetaTokenType.ConstantCaps, /*support.constant.property-value.renpy constant.other.placeholder.tags.renpy*/
+                    patterns: [
+                    ]
+                },
+                5: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+        },
+        {
+            debugName: "stringTags.patterns![13]",
+
+            // Unknown tag end
+            match: /({\/)\s*(\w*?)\b\s*(})/dg,
+            captures: {
+                0: { token: MetaTokenType.StringTag, /*meta.string.tag.${2:/downcase}.end.renpy*/ },
+                1: { token: CharacterTokenType.OpenBracket, /*punctuation.definition.tag.begin.renpy*/ },
+                2: { token: EntityTokenType.TagName, /*renpy.meta.u entity.name.tag.${2:/downcase}.renpy*/ },
+                3: { token: CharacterTokenType.CloseBracket, /*punctuation.definition.tag.end.renpy*/ },
+            },
+        },
+    ]
+};
+
+export const strings: TokenPattern = {
+    debugName: "strings",
+
+    token: LiteralTokenType.String, /*string.quoted.renpy*/
+    begin: /"""|"|'''|'|```|`/dg,
+    beginCaptures: {
+        0: { token: MetaTokenType.StringBegin, /*punctuation.definition.string.begin.renpy*/ },
+    },
+    end: /(?<![^\\]\\)(((?<=\0)\0)|\0)/dg,
+    endCaptures: {
+        1: { token: MetaTokenType.StringEnd, /*punctuation.definition.string.end.renpy*/ },
+        2: { token: MetaTokenType.EmptyString, /*meta.empty-string.renpy*/ },
+    },
+    patterns: [stringsInterior]
+};
+
+export const pythonStatements: TokenPattern = {
+    patterns: [
+        {
+            debugName: "pythonStatements.patterns![0]",
+
+            match: /^([ \t]*)(init)[ \t]+(offset)[ \t]*(=)[ \t]*(-)?([^#]*?)$/dgm,
+            captures: {
+                1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.renpy*/ },
+                2: { token: KeywordTokenType.Init, /*keyword.init.renpy*/ },
+                3: { token: KeywordTokenType.Offset, /*keyword.offset.renpy*/ },
+                4: { token: OperatorTokenType.Assignment, /*keyword.operator.assignment.renpy*/ },
+                5: { token: OperatorTokenType.Minus, /*keyword.operator.arithmetic.minus.renpy*/ },
+                6: {
+                    patterns: [
+                        numInt,
+                        invalidToken,
+                    ]
+                },
+            },
+        },
+        {
+            debugName: "pythonStatements.patterns![1]",
+
+            // Renpy python block
+            contentToken: MetaTokenType.PythonBlock, /*meta.embedded.block.python*/
+            begin: /^([ \t]+)?(?:(init)(?:[ \t]+(-)?(\d+))?[ \t]+)?(python)[ \t]*(.*)?(:)/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.embedded.leading.renpy*/ },
+                2: { token: KeywordTokenType.Init, /*keyword.init.renpy*/ },
+                3: { token: OperatorTokenType.Minus, /*keyword.operator.arithmetic.minus.renpy*/ },
+                4: { token: LiteralTokenType.Integer, /*constant.numeric.integer.renpy*/ },
+                5: { token: KeywordTokenType.Python, /*keyword.python.renpy*/ },
+                6: {
+                    token: MetaTokenType.Arguments, /*meta.python.block.arguments.renpy*/
+                    patterns: [
+                        {
+                            debugName: "pythonStatements.patterns![1].beginCaptures![6].patterns![0]",
+
+                            // in statement
+                            match: /(?:\s*(in)\s*([a-zA-Z_]\w*)\b)/dg,
+                            captures: {
+                                1: { token: KeywordTokenType.In, /*keyword.control.flow.in.renpy*/ },
+                                2: { token: EntityTokenType.NamespaceName, /*entity.name.namespace*/ },
+                            },
+                        },
+                        {
+                            debugName: "pythonStatements.patterns![1].beginCaptures![6].patterns![1]",
+
+                            // keywords
+                            match: /\b(hide)|(early)|(in)\b/dg,
+                            captures: {
+                                1: { token: KeywordTokenType.Hide, /*keyword.hide.renpy*/ },
+                                2: { token: KeywordTokenType.Early, /*keyword.early.renpy*/ },
+                                3: { token: KeywordTokenType.In, /*keyword.control.flow.in.renpy*/ },
+                            },
+                        },
+                    ]
+                },
+                7: { token: CharacterTokenType.Colon, /*punctuation.section.python.begin.renpy*/ },
+            },
+            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+            patterns: [
+            ]
+        },
+        {
+            debugName: "pythonStatements.patterns![2]",
+
+            // Match begin and end of python one line statements
+            contentToken: MetaTokenType.PythonLine, /*meta.embedded.line.python*/
+            begin: /(?<=^[ \t]*)(?:(\$)|(define)|(default))(?=[ \t])/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.DollarSign, /*keyword.dollar.sign.renpy*/ },
+                2: { token: KeywordTokenType.Define, /*keyword.define.renpy*/ },
+                3: { token: KeywordTokenType.Default, /*keyword.default.renpy*/ },
+            },
+            end: /$/gm,
+            patterns: [
+                {
+                    debugName: "pythonStatements.patterns![2].patterns![0]",
+
+                    // Type the first name as a variable (Probably not needed, but python doesn't seem to catch it)
+                    token: EntityTokenType.VariableName, /*variable.other.renpy*/
+                    match: /(?<!\.)\b([a-zA-Z_]\w*)(?=\s=\s)/g,
+                },
+                strings,
+                whitespace,
+            ]
+        },
+    ]
+};
+
+export const sayStatements: TokenPattern = {
+    patterns: [
+        {
+            debugName: "sayStatements.patterns![0]",
+
+            token: MetaTokenType.SayStatement, /*meta.say.statement.renpy*/
+            contentToken: LiteralTokenType.String, /*renpy.meta.say.$1 string.quoted.renpy*/
+            begin: /(?<=^[ \t]+)(?:([a-zA-Z_]\w*)\b|"([a-zA-Z_]\w*)\b")((?:[ \t]+(?:@|\w+))*)?[ \t]*("""|"|'''|'|```|`)/dgm,
+            beginCaptures: {
+                1: {
+                    token: EntityTokenType.VariableName, /*renpy.meta.character.$1 variable.other.renpy*/
+                    patterns: [
+                        {
+                            debugName: "sayStatements.patterns![0].beginCaptures![1].patterns![0]",
+
+                            token: KeywordTokenType.Extend, /*keyword.extend.renpy*/
+                            match: /extend/g,
+                        },
+                        {
+                            debugName: "sayStatements.patterns![0].beginCaptures![1].patterns![1]",
+
+                            token: KeywordTokenType.Voice, /*keyword.voice.renpy*/
+                            match: /voice/g,
+                        },
+                        {
+                            debugName: "sayStatements.patterns![0].beginCaptures![1].patterns![2]",
+
+                            // Match special characters
+                            token: EntityTokenType.VariableName, /*variable.other.constant.renpy*/
+                            match: /adv|nvl|narrator|name_only|centered|vcentered/g,
+                        },
+                    ]
+                },
+                2: { token: MetaTokenType.CharacterNameString, /*meta.string.character.$2.renpy*/ },
+                3: {
+                    token: MetaTokenType.Arguments, /*meta.arguments.renpy*/
+                    patterns: [
+                        {
+                            debugName: "sayStatements.patterns![0].beginCaptures![3].patterns![0]",
+
+                            token: KeywordTokenType.At, /*keyword.at.renpy*/
+                            match: /@/g,
+                        },
+                    ]
+                },
+                4: { token: MetaTokenType.StringBegin, /*string.quoted.renpy punctuation.definition.string.begin.renpy*/ },
+            },
+            end: /(?<![^\\]\\)(((?<=\4)\4)|\4)[ \t]*(\(.*?\)(?![^\(]*?\)))?/dg,
+            endCaptures: {
+                1: { token: MetaTokenType.StringEnd, /*string.quoted.renpy punctuation.definition.string.end.renpy*/ },
+                2: { token: MetaTokenType.EmptyString, /*meta.empty-string.renpy*/ },
+                3: {
+                    patterns: [
+                    ]
+                },
+            },
+            patterns: [stringsInterior]
+        },
+        {
+            debugName: "sayStatements.patterns![1]",
+
+            token: MetaTokenType.SayNarrator, /*meta.say.narrator.renpy*/
+            contentToken: LiteralTokenType.String, /*string.quoted.narrator.renpy*/
+            begin: /(?<=^[ \t]+)("""|"|'''|'|```|`)/dgm,
+            beginCaptures: {
+                1: { token: MetaTokenType.StringBegin, /*string.quoted.renpy punctuation.definition.string.begin.renpy*/ },
+            },
+            end: /(?<![^\\]\\)(((?<=\1)\1)|\1)[ \t]*(\(.*?\)(?![^\(]*?\)))?/dg,
+            endCaptures: {
+                1: { token: MetaTokenType.StringEnd, /*string.quoted.renpy punctuation.definition.string.end.renpy*/ },
+                2: { token: MetaTokenType.EmptyString, /*meta.empty-string.renpy*/ },
+                3: {
+                    patterns: [
+                    ]
+                },
+            },
+            patterns: [stringsInterior]
+        },
+    ]
+};
+
+export const pause: TokenPattern = {
+    debugName: "pause",
+
+    match: /^([ \t]+)(pause)\b([ \t]+[^#\n]*)?$/dgm,
+    captures: {
+        1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.renpy*/ },
+        2: { token: KeywordTokenType.Pause, /*keyword.control.flow.pause.renpy*/ },
+        3: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.renpy*/ },
+        4: {
+            token: MetaTokenType.Arguments, /*meta.pause.arguments.renpy*/
+            patterns: [
+                whitespace,
+                numFloat,
+                numInt,
+                invalidToken,
+            ]
+        },
+    },
+};
+
+export const transform: TokenPattern = {
+    debugName: "transform",
+
+    begin: /^([ \t]+)?(transform)\b[ \t]*(.*)?(:)/dgm,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.renpy*/ },
+        2: { token: KeywordTokenType.Transform, /*keyword.transform.renpy*/ },
+        3: {
+            patterns: [
+                {
+                    debugName: "transform.beginCaptures![3].patterns![0]",
+
+                    token: EntityTokenType.VariableName, /*variable.name.transform.renpy*/
+                    match: /\b([a-zA-Z_]\w*)\b/g,
+                },
+            ]
+        },
+        4: { token: CharacterTokenType.Colon, /*punctuation.section.atl.begin.renpy*/ },
+    },
+    end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+    patterns: [
+    ]
+};
+
+export const atStatement: TokenPattern = {
+    debugName: "atStatement",
+
+    token: MetaTokenType.AtStatement, /*meta.at.statement.renpy*/
+    match: /\b(at)\b[ \t]*(.+)?/dg,
+    captures: {
+        1: { token: KeywordTokenType.At, /*keyword.control.flow.at.renpy*/ },
+        2: {
+            token: MetaTokenType.AtParameters, /*meta.at.parameters.renpy*/
+            patterns: [statements]
+        },
+    },
+};
+
+export const asStatement: TokenPattern = {
+    debugName: "asStatement",
+
+    token: MetaTokenType.AsStatement, /*meta.as.statement.renpy*/
+    match: /\b(as)\b[ \t]*(.+)?/dg,
+    captures: {
+        1: { token: KeywordTokenType.As, /*keyword.control.flow.as.renpy*/ },
+        2: {
+            token: MetaTokenType.AsParameters, /*meta.as.parameters.renpy*/
+            patterns: [statements]
+        },
+    },
+};
+
+export const withStatement: TokenPattern = {
+    debugName: "withStatement",
+
+    token: MetaTokenType.WithStatement, /*meta.with.statement.renpy*/
+    match: /\b(with)\b[ \t]*(.+)?/dg,
+    captures: {
+        1: { token: KeywordTokenType.With, /*keyword.control.flow.with.renpy*/ },
+        2: {
+            token: MetaTokenType.WithParameters, /*meta.with.parameters.renpy*/
+            patterns: [expressions]
+        },
+    },
+};
+
+export const behind: TokenPattern = {
+    debugName: "behind",
+
+    token: MetaTokenType.BehindStatement, /*meta.behind.statement.renpy*/
+    match: /\b(behind)\b[ \t]*(.+)?/dg,
+    captures: {
+        1: { token: KeywordTokenType.Behind, /*keyword.control.flow.behind.renpy*/ },
+        2: {
+            token: MetaTokenType.BehindParameters, /*meta.behind.parameters.renpy*/
+            patterns: [statements]
+        },
+    },
+};
+
+export const onlayer: TokenPattern = {
+    debugName: "onlayer",
+
+    token: MetaTokenType.OnlayerStatement, /*meta.onlayer.statement.renpy*/
+    match: /\b(onlayer)\b[ \t]*(.+)?/dg,
+    captures: {
+        1: { token: KeywordTokenType.Onlayer, /*keyword.control.flow.onlayer.renpy*/ },
+        2: {
+            token: MetaTokenType.OnlayerParameters, /*meta.onlayer.parameters.renpy*/
+            patterns: [statements]
+        },
+    },
+};
+
+export const zorder: TokenPattern = {
+    debugName: "zorder",
+
+    token: MetaTokenType.ZorderStatement, /*meta.zorder.statement.renpy*/
+    match: /\b(zorder)\b[ \t]*(.+)?/dg,
+    captures: {
+        1: { token: KeywordTokenType.Zorder, /*keyword.control.flow.zorder.renpy*/ },
+        2: {
+            token: MetaTokenType.ZorderParameters, /*meta.zorder.parameters.renpy*/
+            patterns: [statements]
+        },
+    },
+};
+
+export const image: TokenPattern = {
+    patterns: [
+        {
+            debugName: "image.patterns![0]",
+
+            token: MetaTokenType.ImageStatement, /*meta.image.statement.renpy*/
+            contentToken: MetaTokenType.ATLBlock, /*meta.atl-block.renpy*/
+            begin: /^([ \t]+)?(image)\b[ \t]*([a-zA-Z_0-9 ]*)(:)/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.renpy*/ },
+                2: { token: KeywordTokenType.Image, /*keyword.image.renpy*/ },
+                3: { token: EntityTokenType.ImageName, /*entity.name.type.image.renpy*/ },
+                4: { token: CharacterTokenType.Colon, /*punctuation.section.atl.begin.renpy*/ },
+            },
+            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+            patterns: [
+            ]
+        },
+        {
+            debugName: "image.patterns![1]",
+
+            token: MetaTokenType.ImageStatement, /*meta.image.statement.renpy*/
+            begin: /(?<=^[ \t]*)(image)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Image, /*keyword.image.renpy*/ },
+            },
+            end: /(?=\b(at)\b|#|=)|$/gm,
+            patterns: [
+                strings,
+                {
+                    debugName: "image.patterns![1].patterns![1]",
+
+                    token: EntityTokenType.ImageName, /*entity.name.type.image.renpy*/
+                    match: /\b(?:[a-zA-Z_0-9]+)\b[ \t]*/g,
+                },
+            ]
+        },
+        atStatement,
+        withStatement,
+    ]
+};
+
+export const show: TokenPattern = {
+    patterns: [
+        {
+            debugName: "show.patterns![0]",
+
+            token: MetaTokenType.ShowStatement, /*meta.show.statement.renpy*/
+            contentToken: MetaTokenType.ATLBlock, /*meta.atl-block.renpy*/
+            begin: /^([ \t]+)?(show)\b[ \t]*([a-zA-Z_0-9 ]*)(:)/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.renpy*/ },
+                2: { token: KeywordTokenType.Show, /*keyword.show.renpy*/ },
+                3: { token: EntityTokenType.ImageName, /*entity.name.type.image.renpy*/ },
+                4: { token: CharacterTokenType.Colon, /*punctuation.section.atl.begin.renpy*/ },
+            },
+            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+            patterns: [
+            ]
+        },
+        {
+            debugName: "show.patterns![1]",
+
+            token: MetaTokenType.ShowStatement, /*meta.show.statement.renpy*/
+            begin: /(?<=^[ \t]*)(show)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Show, /*keyword.show.renpy*/ },
+            },
+            end: /(?=\b(at|as|behind|onlayer|expression|with|zorder)\b|#)|$/gm,
+            patterns: [
+                strings,
+                {
+                    debugName: "show.patterns![1].patterns![1]",
+
+                    token: EntityTokenType.ImageName, /*entity.name.type.image.renpy*/
+                    match: /\b(?:[a-zA-Z_0-9]+)\b[ \t]*/g,
+                },
+            ]
+        },
+        atStatement,
+        asStatement,
+        withStatement,
+        behind,
+        onlayer,
+        zorder,
+    ]
+};
+
+export const scene: TokenPattern = {
+    patterns: [
+        {
+            debugName: "scene.patterns![0]",
+
+            token: MetaTokenType.SceneStatement, /*meta.scene.statement.renpy*/
+            contentToken: MetaTokenType.ATLBlock, /*meta.atl-block.renpy*/
+            begin: /^([ \t]+)?(scene)\b[ \t]*([a-zA-Z_0-9 ]*)(:)/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.renpy*/ },
+                2: { token: KeywordTokenType.Scene, /*keyword.scene.renpy*/ },
+                3: { token: EntityTokenType.ImageName, /*entity.name.type.image.renpy*/ },
+                4: { token: CharacterTokenType.Colon, /*punctuation.section.atl.begin.renpy*/ },
+            },
+            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+            patterns: [
+            ]
+        },
+        {
+            debugName: "scene.patterns![1]",
+
+            token: MetaTokenType.SceneStatement, /*meta.scene.statement.renpy*/
+            begin: /(?<=^[ \t]*)(scene)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Scene, /*keyword.scene.renpy*/ },
+            },
+            end: /(?=\b(at|as|behind|onlayer|expression|with|zorder)\b|#)|$/gm,
+            patterns: [
+                strings,
+                {
+                    debugName: "scene.patterns![1].patterns![1]",
+
+                    token: EntityTokenType.ImageName, /*entity.name.type.image.renpy*/
+                    match: /\b(?:[a-zA-Z_0-9]+)\b[ \t]*/g,
+                },
+            ]
+        },
+        atStatement,
+        asStatement,
+        withStatement,
+        behind,
+        onlayer,
+        zorder,
+    ]
+};
+
+export const camera: TokenPattern = {
+    patterns: [
+        {
+            debugName: "camera.patterns![0]",
+
+            token: MetaTokenType.CameraStatement, /*meta.camera.statement.renpy*/
+            contentToken: MetaTokenType.ATLBlock, /*meta.atl-block.renpy*/
+            begin: /^([ \t]+)?(camera)\b[ \t]*(:)/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.renpy*/ },
+                2: { token: KeywordTokenType.Camera, /*keyword.camera.renpy*/ },
+                3: { token: EntityTokenType.ImageName, /*entity.name.type.image.renpy*/ },
+                4: { token: CharacterTokenType.Colon, /*punctuation.section.atl.begin.renpy*/ },
+            },
+            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+            patterns: [
+            ]
+        },
+        {
+            debugName: "camera.patterns![1]",
+
+            token: MetaTokenType.CameraStatement, /*meta.camera.statement.renpy*/
+            begin: /(?<=^[ \t]*)(camera)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Camera, /*keyword.camera.renpy*/ },
+            },
+            end: /(?=\b(at|with)\b|#)|$/gm,
+            patterns: [
+                {
+                    debugName: "camera.patterns![1].patterns![0]",
+
+                    token: EntityTokenType.ImageName, /*entity.name.type.image.renpy*/
+                    match: /\b(?:[a-zA-Z_0-9]+)\b[ \t]*/g,
+                },
+            ]
+        },
+        atStatement,
+        withStatement,
+    ]
+};
+
+export const styleOld: TokenPattern = {
+    debugName: "styleOld",
+
+    match: /^\s*(style)\s+([a-zA-Z_][a-zA-Z_0-9]*)/dgm,
+    captures: {
+        1: { token: KeywordTokenType.Python, /*keyword.python.renpy*/ },
+        2: { token: EntityTokenType.TagName, /*entity.name.tag.python.renpy.style.renpy*/ },
+    },
+};
+
+export const useOld: TokenPattern = {
+    debugName: "useOld",
+
+    match: /^\s*(use)\s+([a-zA-Z_][a-zA-Z_0-9]*)/dgm,
+    captures: {
+        1: { token: KeywordTokenType.Python, /*keyword.python.renpy*/ },
+        2: { token: EntityTokenType.ClassName, /*entity.name.class.python.renpy.screen.renpy*/ },
+    },
+};
+
+export const builtinScreens: TokenPattern = {
+    debugName: "builtinScreens",
+
+    // TODO: Should combine this with builtin-labels
+    token: EntityTokenType.FunctionName, /*support.function.builtin.renpy*/
+    match: /(?<!\.)\b(?:start|quit|after_load|splashscreen|before_main_menu|main_menu|after_warp|hide_windows)\b/g,
+};
+
+export const screenLanguage: TokenPattern = {
+    // https://www.renpy.org/doc/html/screens.html#screen-language
+    patterns: [
+    ]
+};
+
+export const screenDefName: TokenPattern = {
+    // TODO: Should combine this with label-def-name
+    patterns: [
+        builtinScreens,
+        {
+            debugName: "screenDefName.patterns![2]",
+
+            match: /(?<=^|[ \t])(\b(?:[a-zA-Z_]\w*)\b)?(\.)?(\b(?:[a-zA-Z_]\w*)\b)/dgm,
+            captures: {
+                1: { token: EntityTokenType.FunctionName, /*entity.name.function.renpy*/ },
+                2: { token: CharacterTokenType.Period, /*punctuation.separator.period.renpy*/ },
+                3: { token: EntityTokenType.FunctionName, /*entity.name.function.renpy*/ },
+            },
+        },
+    ]
+};
+
+export const screenSimpleExpression: TokenPattern = {
+    patterns: [expressions]
+};
+
+export const screenKeywords: TokenPattern = {
+    // https://www.renpy.org/doc/html/screens.html#screen-statement
+    patterns: [
+        {
+            debugName: "screenKeywords.patterns![0]",
+
+            contentToken: MetaTokenType.ScreenSensitive, /*meta.screen.sensitive.renpy*/
+            begin: /(?<=^[ \t]*)(sensitive)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Sensitive, /*keyword.sensitive.renpy*/ },
+            },
+            end: /$/gm,
+            patterns: [screenSimpleExpression]
+        },
+        {
+            debugName: "screenKeywords.patterns![1]",
+
+            token: KeywordTokenType.Other, /*keyword.other.renpy*/
+            match: /\b(?<!\.)(?:modal|sensitive|tag|zorder|variant|layer|roll_forward|text)\b/g,
+        },
+        {
+            debugName: "screenKeywords.patterns![2]",
+
+            token: KeywordTokenType.Other, /*keyword.other.renpy*/
+            match: /\b(?<!\.)(?:style|style_group|style_prefix)\b/g,
+        },
+        {
+            debugName: "screenKeywords.patterns![3]",
+
+            token: KeywordTokenType.Other, /*keyword.other.renpy*/
+            match: /\b(?<!\.)(?:has|vbox|label|add|xfill)\b/g,
+        },
+    ]
+};
+
+export const screenFrame: TokenPattern = {
+    debugName: "screenFrame",
+
+    contentToken: MetaTokenType.ScreenFrame, /*meta.screen.frame.renpy*/
+    begin: /^([ \t]+)?(frame)\b[ \t]*(:)/dgm,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.block.renpy*/ },
+        2: { token: KeywordTokenType.Frame, /*keyword.frame.renpy*/ },
+        3: { token: CharacterTokenType.Colon, /*punctuation.section.block.begin.renpy*/ },
+    },
+    end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+    patterns: [screenLanguage]
+};
+
+export const screenWindow: TokenPattern = {
+    debugName: "screenWindow",
+
+    contentToken: MetaTokenType.ScreenWindow, /*meta.screen.window.renpy*/
+    begin: /^([ \t]+)?(window)\b[ \t]*(:)/dgm,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.block.renpy*/ },
+        2: { token: KeywordTokenType.Window, /*keyword.window.renpy*/ },
+        3: { token: CharacterTokenType.Colon, /*punctuation.section.block.begin.renpy*/ },
+    },
+    end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+    patterns: [screenLanguage]
+};
+
+export const screenText: TokenPattern = {
+    debugName: "screenText",
+
+    contentToken: MetaTokenType.ScreenText, /*meta.screen.text.renpy*/
+    begin: /^([ \t]+)?(text)\b[ \t]*(:)/dgm,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.block.renpy*/ },
+        2: { token: KeywordTokenType.Text, /*keyword.text.renpy*/ },
+        3: { token: CharacterTokenType.Colon, /*punctuation.section.block.begin.renpy*/ },
+    },
+    end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+    patterns: [
+        {
+            debugName: "screenText.patterns![0]",
+
+            token: MetaTokenType.ScreenText, /*meta.screen.text.renpy*/
+            contentToken: MetaTokenType.ATLBlock, /*meta.atl-block.renpy*/
+            begin: /^([ \t]+)?(text)\b[ \t]*([a-zA-Z_0-9 ]*)(:)/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.renpy*/ },
+                2: { token: KeywordTokenType.Text, /*keyword.text.renpy*/ },
+                3: { token: EntityTokenType.TextName, /*entity.name.type.text.renpy*/ },
+                4: { token: CharacterTokenType.Colon, /*punctuation.section.atl.begin.renpy*/ },
+            },
+            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+            patterns: [
+            ]
+        },
+        {
+            debugName: "screenText.patterns![1]",
+
+            token: MetaTokenType.ScreenText, /*meta.screen.text.renpy*/
+            begin: /(?<=^[ \t]*)(text)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Text, /*keyword.text.renpy*/ },
+            },
+            end: /(?=\b(at)\b|#|=)|$/gm,
+            patterns: [
+                strings,
+                {
+                    debugName: "screenText.patterns![1].patterns![1]",
+
+                    token: EntityTokenType.TextName, /*entity.name.type.text.renpy*/
+                    match: /\b(?:[a-zA-Z_0-9]+)\b[ \t]*/g,
+                },
+            ]
+        },
+        atStatement,
+    ]
+};
+
+export const screen: TokenPattern = {
+    patterns: [
+        {
+            debugName: "screen.patterns![0]",
+
+            // See https://www.renpy.org/doc/html/screens.html
+            contentToken: MetaTokenType.ScreenBlock, /*meta.screen.block.renpy*/
+            begin: /^([ \t]+)?(screen)\b[ \t]*(.*?)(:)/dgm,
+            beginCaptures: {
+                1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.leading.block.renpy*/ },
+                2: { token: KeywordTokenType.Def, /*storage.type.function.renpy*/ },
+                3: {
+                    patterns: [
+                        screenDefName,
+                        invalidToken,
+                    ]
+                },
+                4: { token: CharacterTokenType.Colon, /*punctuation.section.block.begin.renpy*/ },
+            },
+            end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+            patterns: [screenLanguage]
+        },
+    ]
+};
+
+export const builtinLabels: TokenPattern = {
+    debugName: "builtinLabels",
+
+    token: EntityTokenType.FunctionName, /*support.function.builtin.renpy*/
+    match: /(?<!\.)\b(?:start|quit|after_load|splashscreen|before_main_menu|main_menu|after_warp|hide_windows)\b/g,
+};
+
+export const labelName: TokenPattern = {
+    patterns: [
+        builtinLabels,
+        {
+            debugName: "labelName.patterns![2]",
+
+            token: EntityTokenType.FunctionName, /*entity.name.function.renpy*/
+            match: /\b(?:[a-zA-Z_]\w*)\b/g,
+        },
+    ]
+};
+
+export const labelCall: TokenPattern = {
+    debugName: "labelCall",
+
+    // Note: label params are only allowed at the end of the access expression
+    token: MetaTokenType.LabelCall, /*meta.function-call.label.renpy*/
+    begin: /\b(?=([a-zA-Z_]\w*)\s*(\())/g,
+    end: /(\))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*punctuation.definition.arguments.end.renpy*/ },
+    },
+    patterns: [labelName]
+};
+
+export const labelAccess: TokenPattern = {
+    debugName: "labelAccess",
+
+    // Note: Labels can't be nested twice in a row!
+    token: MetaTokenType.LabelAccess, /*meta.member.access.label.renpy*/
+    begin: /(\.)\s*(?!\.)/dg,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Period, /*punctuation.separator.period.renpy*/ },
+    },
+    end: /(?<=\S)(?=\W)|(^|(?<=\s))(?=[^\\\w\s])|$/gm,
+    patterns: [
+        labelCall,
+        labelName,
+    ]
+};
+
+export const labelDefName: TokenPattern = {
+    // Note: Labels can't be nested twice in a row!
+    patterns: [
+        builtinLabels,
+        {
+            debugName: "labelDefName.patterns![2]",
+
+            match: /(?<=^|[ \t])(\b(?:[a-zA-Z_]\w*)\b)?(\.)?(\b(?:[a-zA-Z_]\w*)\b)/dgm,
+            captures: {
+                1: { token: EntityTokenType.FunctionName, /*entity.name.function.renpy*/ },
+                2: { token: CharacterTokenType.Period, /*punctuation.separator.period.renpy*/ },
+                3: { token: EntityTokenType.FunctionName, /*entity.name.function.renpy*/ },
+            },
+        },
+    ]
+};
+
+export const label: TokenPattern = {
+    debugName: "label",
+
+    token: MetaTokenType.LabelStatement, /*meta.label.statement.renpy*/
+    match: /(?<=^[ \t]*)(label)\b[ \t]*(.*?)(?:[ \t]*(hide))?(:)/dgm,
+    captures: {
+        1: { token: KeywordTokenType.Label, /*storage.type.function.label.renpy*/ },
+        2: {
+            patterns: [
+                labelDefName,
+                invalidToken,
+            ]
+        },
+        3: { token: KeywordTokenType.Hide, /*keyword.hide.renpy*/ },
+        4: { token: CharacterTokenType.Colon, /*punctuation.section.label.begin.renpy*/ },
+    },
+};
+
+export const returnStatements: TokenPattern = {
+    debugName: "returnStatements",
+
+    begin: /(?<=^[ \t]+)(return)\b[ \t]*/dgm,
+    beginCaptures: {
+        1: { token: KeywordTokenType.Return, /*keyword.control.flow.return.renpy*/ },
+    },
+    end: /$/gm,
+    patterns: [expressions]
+};
+
+export const callJumpExpression: TokenPattern = {
+    debugName: "callJumpExpression",
+
+    begin: /\b(?<!\.)(expression)\b/dg,
+    beginCaptures: {
+        1: { token: KeywordTokenType.Expression, /*keyword.expression.renpy*/ },
+    },
+    end: /(?=\b(?<!\.)(?:pass|from)\b)|$/gm,
+    patterns: [expressions]
+};
+
+export const jump: TokenPattern = {
+    debugName: "jump",
+
+    token: MetaTokenType.JumpStatement, /*meta.jump.statement.renpy*/
+    begin: /(?<=^[ \t]+)(jump)\b[ \t]*/dgm,
+    beginCaptures: {
+        1: { token: KeywordTokenType.Jump, /*keyword.control.flow.jump.renpy*/ },
+    },
+    end: /(?=#)|$/dgm,
+    endCaptures: {
+        1: { token: MetaTokenType.Invalid, /*invalid.illegal.renpy*/ },
+    },
+    patterns: [
+        callJumpExpression,
+        {
+            debugName: "jump.patterns![1]",
+
+            // Label expression
+            begin: /(?=[a-zA-Z_.])/g,
+            end: /(?![a-zA-Z_.])(?![ \t]*\.[ \t]*)/g,
+            patterns: [
+                labelAccess,
+                labelName,
+            ]
+        },
+    ]
+};
+
+export const callPass: TokenPattern = {
+    debugName: "callPass",
+
+    begin: /\b(?<!\.)(pass)\b[ \t]*(?=\()/dg,
+    beginCaptures: {
+        1: { token: KeywordTokenType.Pass, /*keyword.pass.renpy*/ },
+    },
+    end: /(\))/dg,
+    endCaptures: {
+        1: { token: CharacterTokenType.CloseParentheses, /*punctuation.definition.arguments.end.renpy*/ },
+    },
+    patterns: [
+    ]
+};
+
+export const callFrom: TokenPattern = {
+    debugName: "callFrom",
+
+    begin: /\b(?<!\.)(from)\b[ \t]*/dg,
+    beginCaptures: {
+        1: { token: KeywordTokenType.From, /*keyword.control.flow.from.renpy*/ },
+    },
+    end: /(?=\W|$)/gm,
+    patterns: [labelName]
+};
+
+export const call: TokenPattern = {
+    debugName: "call",
+
+    token: MetaTokenType.CallStatement, /*meta.call.statement.renpy*/
+    begin: /(?<=^[ \t]+)(call)\b[ \t]*/dgm,
+    beginCaptures: {
+        1: { token: KeywordTokenType.Call, /*keyword.control.flow.call.renpy*/ },
+    },
+    end: /(?=#)|$/dgm,
+    endCaptures: {
+        1: { token: MetaTokenType.Invalid, /*invalid.illegal.renpy*/ },
+    },
+    patterns: [
+        callJumpExpression,
+        callPass,
+        {
+            debugName: "call.patterns![2]",
+
+            // Label expression
+            begin: /(?=[a-zA-Z_.])/g,
+            end: /(?![a-zA-Z_.])(?![ \t]*\.[ \t]*)/g,
+            patterns: [
+                labelCall,
+                labelAccess,
+                labelName,
+            ]
+        },
+        callFrom,
+    ]
+};
+
+export const menuOption: TokenPattern = {
+    debugName: "menuOption",
+
+    contentToken: MetaTokenType.MenuOptionBlock, /*meta.menu-option.block.renpy*/
+    begin: /^([ \t]+)?((?:".*")|(?:'.*')|(?:""".*"""))[ \t]*(.+)?(:)/dgm,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.menu-option.leading.renpy*/ },
+        2: {
+            token: MetaTokenType.MenuOption, /*meta.menu-option.renpy*/
+            patterns: [strings]
+        },
+        3: {
+            token: MetaTokenType.PythonLine, /*meta.embedded.line.python*/
+            patterns: [
+                {
+                    debugName: "menuOption.beginCaptures![3].patterns![1]",
+
+                    // if condition
+                    match: /\b(if)[ \t]+(.+)?/dg,
+                    captures: {
+                        1: { token: KeywordTokenType.If, /*keyword.control.conditional.renpy*/ },
+                        2: {
+                            patterns: [
+                            ]
+                        },
+                    },
+                },
+                {
+                    debugName: "menuOption.beginCaptures![3].patterns![2]",
+
+                    token: MetaTokenType.Invalid, /*invalid.illegal.unexpected-characters-in-menu-arguments.renpy*/
+                    match: /[^ \t]+/g,
+                },
+            ]
+        },
+        4: { token: CharacterTokenType.Colon, /*punctuation.section.menu-option.begin.renpy*/ },
+    },
+    end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+    patterns: [
+    ]
+};
+
+export const menuSet: TokenPattern = {
+    debugName: "menuSet",
+
+    match: /(?<=^[ \t]+)(set)[ \t]+(.+)?/dgm,
+    captures: {
+        1: { token: KeywordTokenType.Set, /*keyword.set.renpy*/ },
+        2: {
+            token: MetaTokenType.PythonLine, /*meta.embedded.line.python*/
+            patterns: [
+            ]
+        },
+    },
+};
+
+export const menu: TokenPattern = {
+    debugName: "menu",
+
+    token: MetaTokenType.MenuStatement, /*meta.menu.statement.renpy*/
+    contentToken: MetaTokenType.MenuBlock, /*meta.menu.block.renpy*/
+    begin: /^([ \t]+)?(menu)[ \t]*(.+)?(:)/dgm,
+    beginCaptures: {
+        1: { token: CharacterTokenType.Whitespace, /*punctuation.whitespace.menu.leading.renpy*/ },
+        2: { token: KeywordTokenType.Def, /*storage.type.function.renpy*/ },
+        3: {
+            patterns: [
+                {
+                    debugName: "menu.beginCaptures![3].patterns![0]",
+
+                    // Menu name
+                    token: EntityTokenType.FunctionName, /*entity.name.function.renpy*/
+                    match: /[a-zA-Z_.]\w*/g,
+                },
+            ]
+        },
+        4: { token: CharacterTokenType.Colon, /*punctuation.section.menu.begin.renpy*/ },
+    },
+    end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
+    patterns: [
+        comments,
+        menuOption,
+        sayStatements,
+        menuSet,
+        fallbackCharacters,
+    ]
+};
+
+export const builtinAudioChannels: TokenPattern = {
+    debugName: "builtinAudioChannels",
+
+    token: MetaTokenType.BuiltinType, /*support.type.audio.channel.renpy*/
+    match: /(?<!\.)\b(?:music|sound|voice|audio)\b/g,
+};
+
+export const audioChannel: TokenPattern = {
+    patterns: [
+        builtinAudioChannels,
+        {
+            debugName: "audioChannel.patterns![1]",
+
+            token: EntityTokenType.AudioName, /*entity.name.type.audio.channel.renpy*/
+            match: /.+/g,
+        },
+    ]
+};
+
+export const audioParams: TokenPattern = {
+    patterns: [
+        {
+            debugName: "audioParams.patterns![0]",
+
+            token: KeywordTokenType.OtherAudio, /*keyword.other.audio.renpy*/
+            match: /\b(?<!\.)(?:fadeout|fadein|volume|loop|noloop)\b/g,
+        },
+    ]
+};
+
+export const play: TokenPattern = {
+    patterns: [
+        {
+            debugName: "play.patterns![0]",
+
+            token: MetaTokenType.PlayAudioStatement, /*meta.play.audio.statement.renpy*/
+            begin: /(?<=^[ \t]*)(play)\b[ \t]+\b([a-zA-Z_0-9]*)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Play, /*keyword.play.renpy*/ },
+                2: { patterns: [audioChannel] },
+            },
+            end: /(?=[ \t]*#)|$/gm,
+            patterns: [
+                strings,
+                audioParams,
+            ]
+        },
+    ]
+};
+
+export const queue: TokenPattern = {
+    patterns: [
+        {
+            debugName: "queue.patterns![0]",
+
+            token: MetaTokenType.QueueAudioStatement, /*meta.queue.audio.statement.renpy*/
+            begin: /(?<=^[ \t]*)(queue)\b[ \t]+\b([a-zA-Z_0-9]*)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Queue, /*keyword.queue.renpy*/ },
+                2: { patterns: [audioChannel] },
+            },
+            end: /(?=[ \t]*#)|$/gm,
+            patterns: [
+                strings,
+                audioParams,
+            ]
+        },
+    ]
+};
+
+export const stop: TokenPattern = {
+    patterns: [
+        {
+            debugName: "stop.patterns![0]",
+
+            token: MetaTokenType.StopAudioStatement, /*meta.stop.audio.statement.renpy*/
+            begin: /(?<=^[ \t]*)(stop)\b[ \t]+\b([a-zA-Z_0-9]*)\b[ \t]*/dgm,
+            beginCaptures: {
+                1: { token: KeywordTokenType.Stop, /*keyword.stop.renpy*/ },
+                2: { patterns: [audioChannel] },
+            },
+            end: /(?=[ \t]*#)|$/gm,
+            patterns: [
+                {
+                    debugName: "stop.patterns![0].patterns![0]",
+
+                    token: KeywordTokenType.Fadeout, /*keyword.fadeout.renpy*/
+                    match: /\b(?<!\.)(?:fadeout)\b/g,
+                },
+            ]
+        },
+    ]
+};
+
+export const audio: TokenPattern = {
+    patterns: [
+        play,
+        queue,
+        stop,
+    ]
+};
+
+export const renpyStatements: TokenPattern = {
+    patterns: [
+        label,
+        menu,
+        image,
+        audio,
+        pause,
+        transform,
+        scene,
+        camera,
+        show,
+        withStatement,
+        styleOld,
+        useOld,
+        screen,
+        returnStatements,
+        jump,
+        call,
+    ]
+};
+
+export const basePatterns: TokenPattern = {
+    patterns: [
+        statements,
+        expressions,
+    ]
+};
+
+// Push pattern references that were not defined on include
+statements.patterns!.push(renpyStatements, pythonStatements, keywords, sayStatements);
+expressions.patterns!.push(comments, strings, literal, fallbackCharacters);
+stringsInterior.patterns!.splice(2, 0, stringTags);
+screenLanguage.patterns!.push(screenFrame, screenWindow, screenText, screenKeywords, screenSimpleExpression);
+menuOption.patterns!.push(basePatterns);
\ No newline at end of file
diff --git a/src/tokenizer/renpy-tokens.ts b/src/tokenizer/renpy-tokens.ts
index e51deca..55dc2cf 100644
--- a/src/tokenizer/renpy-tokens.ts
+++ b/src/tokenizer/renpy-tokens.ts
@@ -10,6 +10,7 @@ export const enum TokenTypeIndex {
     CharactersStart = 4001,
     EscapedCharacterStart = 5001,
     MetaStart = 6001,
+    DeprecatedTokenID = 9997,
     UnknownCharacterID = 9998,
     InvalidTokenID = 9999,
 }
@@ -52,17 +53,24 @@ export const enum KeywordTokenType {
     // Renpy sub expression keywords
     Set,
     Expression,
-    At,
-    As,
-    With,
-    OnLayer,
-    ZOrder,
-    Behind,
     Animation,
     From,
     Time,
     Repeat,
     DollarSign,
+    Sensitive,
+    Text,
+    Other,
+    OtherPython,
+    OtherAudio,
+
+    // Renpy control flow keywords
+    At,
+    As,
+    With,
+    Onlayer,
+    Zorder,
+    Behind,
 
     // Conditional control flow keywords
     If,
@@ -70,6 +78,7 @@ export const enum KeywordTokenType {
     Else,
 
     // Control flow keywords
+    In, // in
     For,
     While,
     Pass,
@@ -89,15 +98,33 @@ export const enum KeywordTokenType {
     Event,
     On,
     Function,
+
+    // Python keywords
+    Import,
+    Class,
+    Metaclass,
+    Lambda,
+    Async,
+    Def,
+    Global,
+    Nonlocal,
 }
 
 export const enum EntityTokenType {
-    Class = TokenTypeIndex.EntityStart,
-    Namespace,
+    ClassName = TokenTypeIndex.EntityStart,
+    InheritedClassName,
+    TypeName,
+    NamespaceName,
     FunctionName,
-    Tag,
+    TagName,
     VariableName,
 
+    // Renpy entities
+    ImageName,
+    TextName,
+    AudioName,
+    CharacterName,
+
     // ATL entities
     EventName,
     PropertyName,
@@ -134,7 +161,7 @@ export const enum OperatorTokenType {
     BitwiseRightShift, // >>
 
     // Assignment operators
-    Assign, // =
+    Assignment, // =
     PlusAssign, // +=
     MinusAssign, // -=
     MultiplyAssign, // *=
@@ -163,8 +190,21 @@ export const enum OperatorTokenType {
     Is, // is
     IsNot, // is not
 
-    In, // in
     NotIn, // not in
+
+    Unpacking, // * or **
+    PositionalParameter, // /
+
+    // Regex operators
+    Quantifier, // [+*?]\??
+    Disjunction, // |
+    Negation, // ^
+    Lookahead, // (?=
+    LookaheadNegative, // (?!
+    Lookbehind, // (?<=
+    LookbehindNegative, // (?<!
+    Conditional, // ?
+    ConditionalNegative, // ?!
 }
 
 export const enum CharacterTokenType {
@@ -180,7 +220,7 @@ export const enum CharacterTokenType {
     CloseSquareBracket, // ]
 
     // Other characters
-    WhiteSpace, // Tab or space
+    Whitespace, // Tab or space
     NewLine,
 
     Period, // .
@@ -188,6 +228,10 @@ export const enum CharacterTokenType {
     Semicolon, // ;
     Comma, // ,
     Hashtag, // #
+    Caret, // ^
+    DollarSymbol, // $
+    AtSymbol, // @
+    EqualsSymbol, // =
 
     Quote, // '
     DoubleQuote, // "
@@ -211,16 +255,31 @@ export const enum EscapedCharacterTokenType {
 
 export const enum MetaTokenType {
     Invalid = TokenTypeIndex.InvalidTokenID,
+    Deprecated = TokenTypeIndex.DeprecatedTokenID,
+
     Comment = TokenTypeIndex.MetaStart,
-    CodeBlock,
+    CommentCodeTag,
+    CommentRegionTag, // #region / #endregion
+    TypehintComment,
+    TypehintDirective,
+    TypehintIgnore,
+    TypehintType,
+    TypehintPunctuation,
+    TypehintVariable,
+    Docstring,
+
+    StringBegin,
+    StringEnd,
 
+    CodeBlock,
     PythonLine,
     PythonBlock,
     Arguments,
 
-    CommentCodeTag,
     EmptyString,
+    StringTag,
     TagBlock,
+    TaggedString,
     Placeholder,
 
     MenuStatement,
@@ -228,28 +287,48 @@ export const enum MetaTokenType {
     MenuOption,
     MenuOptionBlock,
 
+    LabelStatement,
+    LabelCall,
+    LabelAccess,
+
+    BehindStatement,
+    OnlayerStatement,
+    ZorderStatement,
+    AtStatement,
+    AsStatement,
+    WithStatement,
+
+    ImageStatement,
     CameraStatement,
     SceneStatement,
     ShowStatement,
-    ImageStatement,
-
-    NarratorSayStatement,
-    SayStatement,
-    CharacterNameString,
 
     CallStatement,
     JumpStatement,
 
     PlayAudioStatement,
+    QueueAudioStatement,
     StopAudioStatement,
 
-    LabelStatement,
-    LabelCall,
-    LabelAccess,
+    ScreenStatement,
+    ScreenSensitive,
+    ScreenFrame,
+    ScreenWindow,
+    ScreenText,
+    ScreenBlock,
 
-    AtStatement,
-    AsStatement,
-    WithStatement,
+    NarratorSayStatement,
+    SayStatement,
+    CharacterNameString,
+    SayNarrator,
+    SayCharacter,
+
+    AtParameters,
+    AsParameters,
+    BehindParameters,
+    OnlayerParameters,
+    WithParameters,
+    ZorderParameters,
 
     ATLBlock,
     ATLChoiceBlock,
@@ -259,6 +338,57 @@ export const enum MetaTokenType {
     ATLFunction,
     ATLWarper,
     ATLOn,
+
+    MemberAccess,
+    ItemAccess,
+    IndexedName,
+    Attribute,
+    ClassDefinition,
+    ClassInheritance,
+    FunctionDefinition,
+    LambdaFunction,
+    FunctionLambdaParameters,
+    FunctionParameters,
+    FunctionDecorator,
+    FunctionCall,
+    FunctionCallGeneric,
+
+    Fstring,
+
+    // Temporary tokens for python parsing
+    ControlFlowKeyword,
+    LogicalOperatorKeyword,
+    Operator,
+    ArithmeticOperator,
+    BitwiseOperatorKeyword,
+    ComparisonOperatorKeyword,
+    ConstantLiteral,
+    ConstantNumeric,
+    ConstantCaps,
+    BuiltinExceptionType,
+    BuiltinType,
+    MagicVariable,
+
+    EscapeSequence,
+
+    FormatPercent,
+    FormatBrace,
+
+    StringStorageType,
+    FormatStorageType,
+    ImaginaryNumberStorageType,
+    NumberStorageType,
+    ClassStorageType,
+
+    // Regex
+    CommentBegin,
+    CommentEnd,
+
+    Backreference,
+    BackreferenceNamed,
+    CharacterSet,
+    Named,
+    ModifierFlagStorageType,
 }
 
 export type TokenType = KeywordTokenType | EntityTokenType | MetaTokenType | LiteralTokenType | OperatorTokenType | CharacterTokenType | EscapedCharacterTokenType;
diff --git a/src/tokenizer/token-definitions.ts b/src/tokenizer/token-definitions.ts
index 687914c..7c8573c 100644
--- a/src/tokenizer/token-definitions.ts
+++ b/src/tokenizer/token-definitions.ts
@@ -1,9 +1,28 @@
 // Workspace and file functions
 "use strict";
 
-import { Position, Range } from "vscode";
+import { Position, Range as VSRange } from "vscode";
 import { CharacterTokenType, MetaTokenType, TokenType, TokenTypeIndex } from "./renpy-tokens";
 import { TokenPattern, TokenRangePattern, TokenMatchPattern, TokenRepoPattern } from "./token-pattern-types";
+import { Vector } from "../utilities/vector";
+
+export class Range {
+    start: number;
+    end: number;
+
+    constructor(start: number, end: number) {
+        this.start = start;
+        this.end = end;
+    }
+
+    overlaps(other: Range): boolean {
+        return this.start <= other.end && other.start <= this.end;
+    }
+
+    contains(position: number): boolean {
+        return position >= this.start && position <= this.end;
+    }
+}
 
 export class TokenPosition {
     line: number;
@@ -53,8 +72,6 @@ export class TokenPosition {
 
 export class Token {
     readonly tokenType: TokenType;
-
-    // README: The tokenizer abuses that 'startPos' and 'endPos' are reference objects to move the positions!
     readonly startPos: TokenPosition;
     readonly endPos: TokenPosition;
 
@@ -64,7 +81,7 @@ export class Token {
         this.endPos = endPos;
     }
 
-    public getRange() {
+    public getVSCodeRange() {
         const start = new Position(this.startPos.line, this.startPos.character);
         const end = new Position(this.endPos.line, this.endPos.character);
 
@@ -72,7 +89,11 @@ export class Token {
             console.warn(`Empty token detected at L: ${start.line + 1}, C: ${start.character + 1} !`);
         }
 
-        return new Range(start, end);
+        return new VSRange(start, end);
+    }
+
+    public getRange() {
+        return new Range(this.startPos.charStartOffset, this.endPos.charStartOffset);
     }
 
     public isKeyword() {
@@ -123,3 +144,76 @@ export function isMatchPattern(p: TokenPattern): p is TokenMatchPattern {
 export function isRepoPattern(p: TokenPattern): p is TokenRepoPattern {
     return !isRangePattern(p) && (p as TokenRepoPattern).patterns !== undefined;
 }
+
+export class TreeNode {
+    public token: Token | null;
+    public children: Vector<TreeNode>;
+
+    constructor(token: Token | null = null) {
+        this.token = token;
+        this.children = new Vector<TreeNode>();
+    }
+
+    public addChild(child: TreeNode): void {
+        this.children.pushBack(child);
+    }
+
+    public hasChildren(): boolean {
+        return !this.children.isEmpty();
+    }
+
+    public isEmpty(): boolean {
+        return this.token === null && !this.hasChildren();
+    }
+
+    // Recursively iterate over all children
+    public forEach(callback: (node: TreeNode) => void): void {
+        this.children.forEach((child) => {
+            callback(child);
+            child.forEach(callback);
+        });
+    }
+
+    public filter(callback: (node: TreeNode) => boolean): TreeNode[] {
+        const result: TreeNode[] = [];
+        this.forEach((node) => {
+            if (callback(node)) {
+                result.push(node);
+            }
+        });
+        return result;
+    }
+
+    public count(): number {
+        // Recursively iterate over all children
+        let count = 0;
+        this.forEach(() => {
+            ++count;
+        });
+        return count;
+    }
+}
+
+export class TokenTree {
+    public root: TreeNode;
+
+    constructor() {
+        this.root = new TreeNode();
+    }
+
+    public isEmpty(): boolean {
+        return !this.root.hasChildren();
+    }
+
+    public forEach(callback: (node: TreeNode) => void): void {
+        this.root.forEach(callback);
+    }
+
+    public filter(callback: (node: TreeNode) => boolean): TreeNode[] {
+        return this.root.filter(callback);
+    }
+
+    public count(): number {
+        return this.root.count();
+    }
+}
diff --git a/src/tokenizer/token-pattern-types.ts b/src/tokenizer/token-pattern-types.ts
index 9c10a95..76d82a0 100644
--- a/src/tokenizer/token-pattern-types.ts
+++ b/src/tokenizer/token-pattern-types.ts
@@ -1,6 +1,10 @@
 import { TokenType } from "./renpy-tokens";
 
-export interface TokenCapturePattern {
+interface TokenPatternDebugInfo {
+    readonly debugName?: string;
+}
+
+export interface TokenCapturePattern extends TokenPatternDebugInfo {
     readonly token?: TokenType;
     readonly patterns?: TokenPatternArray;
 }
@@ -54,9 +58,5 @@ export interface TokenMatchPattern {
     endCaptures?: never;
 }
 
-interface TokenPatternDebugInfo {
-    readonly debugName?: string;
-}
-
 export declare type TokenPattern = (TokenRangePattern | TokenMatchPattern | TokenRepoPattern) & TokenPatternDebugInfo;
 export declare type TokenPatternArray = Array<TokenPattern>;
diff --git a/src/tokenizer/token-patterns.g.ts b/src/tokenizer/token-patterns.g.ts
new file mode 100644
index 0000000..cd6791a
--- /dev/null
+++ b/src/tokenizer/token-patterns.g.ts
@@ -0,0 +1,59 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+// THIS FILE HAS BEEN GENERATED BY THE `syntax-to-token-pattern.py` GENERATOR
+// DO NOT EDIT THIS FILE DIRECTLY! INSTEAD RUN THE PYTHON SCRIPT.
+// ANY MANUAL EDITS MADE TO THIS FILE WILL BE OVERWRITTEN. YOU HAVE BEEN WARNED.
+// Last generated: 01/06/2023 14:57:48 (UTC+0)
+
+import * as AtlPatterns from "./atl-token-patterns.g";
+import * as RenpyPatterns from "./renpy-token-patterns.g";
+import * as PythonPatterns from "./python-token-patterns.g";
+
+// Push all RenpyPatterns external includes
+RenpyPatterns.keywords.patterns![1].patterns!.push(PythonPatterns.expression);
+RenpyPatterns.constantPlaceholder.captures![2].patterns!.push(PythonPatterns.expression);
+RenpyPatterns.pythonStatements.patterns![1].patterns!.push(PythonPatterns.python);
+RenpyPatterns.pythonStatements.patterns![2].patterns!.splice(2, 0, PythonPatterns.expression);
+RenpyPatterns.sayStatements.patterns![0].endCaptures![3].patterns!.push(PythonPatterns.functionArguments);
+RenpyPatterns.sayStatements.patterns![1].endCaptures![3].patterns!.push(PythonPatterns.functionArguments);
+RenpyPatterns.transform.patterns!.push(AtlPatterns.atl);
+RenpyPatterns.image.patterns![0].patterns!.push(AtlPatterns.atl);
+RenpyPatterns.show.patterns![0].patterns!.push(AtlPatterns.atl);
+RenpyPatterns.scene.patterns![0].patterns!.push(AtlPatterns.atl);
+RenpyPatterns.camera.patterns![0].patterns!.push(AtlPatterns.atl);
+RenpyPatterns.screenDefName.patterns!.splice(0, 0, PythonPatterns.builtinPossibleCallables);
+RenpyPatterns.screenSimpleExpression.patterns!.push(PythonPatterns.literal, PythonPatterns.memberAccess, PythonPatterns.illegalOperator, PythonPatterns.operator, PythonPatterns.curlyBraces, PythonPatterns.itemAccess, PythonPatterns.list, PythonPatterns.oddFunctionCall, PythonPatterns.roundBraces, PythonPatterns.functionCall, PythonPatterns.builtinFunctions, PythonPatterns.builtinTypes, PythonPatterns.builtinExceptions, PythonPatterns.magicNames, PythonPatterns.specialNames, PythonPatterns.illegalNames, PythonPatterns.specialVariables, PythonPatterns.ellipsis, PythonPatterns.punctuation, PythonPatterns.lineContinuation);
+RenpyPatterns.screenText.patterns![0].patterns!.push(AtlPatterns.atl);
+RenpyPatterns.screen.patterns![0].beginCaptures![3].patterns!.splice(1, 0, PythonPatterns.parameters);
+RenpyPatterns.labelName.patterns!.splice(0, 0, PythonPatterns.builtinPossibleCallables);
+RenpyPatterns.labelCall.patterns!.splice(0, 0, PythonPatterns.specialVariables);
+RenpyPatterns.labelCall.patterns!.push(PythonPatterns.functionArguments);
+RenpyPatterns.labelDefName.patterns!.splice(0, 0, PythonPatterns.builtinPossibleCallables);
+RenpyPatterns.label.captures![2].patterns!.splice(1, 0, PythonPatterns.parameters);
+RenpyPatterns.returnStatements.patterns!.push(PythonPatterns.expression);
+RenpyPatterns.callJumpExpression.patterns!.push(PythonPatterns.expression);
+RenpyPatterns.callPass.patterns!.push(PythonPatterns.functionArguments);
+RenpyPatterns.menuOption.beginCaptures![3].patterns!.splice(0, 0, PythonPatterns.functionArguments);
+RenpyPatterns.menuOption.beginCaptures![3].patterns![1].captures![2].patterns!.push(PythonPatterns.expressionBare);
+RenpyPatterns.menuSet.captures![2].patterns!.push(PythonPatterns.expressionBare);
+RenpyPatterns.menu.beginCaptures![3].patterns!.push(PythonPatterns.functionArguments);
+RenpyPatterns.audioParams.patterns!.push(PythonPatterns.number);
+RenpyPatterns.play.patterns![0].patterns!.push(PythonPatterns.expression);
+RenpyPatterns.queue.patterns![0].patterns!.push(PythonPatterns.expression);
+RenpyPatterns.stop.patterns![0].patterns!.push(PythonPatterns.number);
+
+// Push all AtlPatterns external includes
+AtlPatterns.atlSimpleExpression.patterns!.splice(0, 0, RenpyPatterns.expressions);
+AtlPatterns.atlSimpleExpression.patterns!.push(PythonPatterns.literal, PythonPatterns.memberAccess, PythonPatterns.illegalOperator, PythonPatterns.operator, PythonPatterns.curlyBraces, PythonPatterns.itemAccess, PythonPatterns.list, PythonPatterns.oddFunctionCall, PythonPatterns.roundBraces, PythonPatterns.functionCall, PythonPatterns.builtinFunctions, PythonPatterns.builtinTypes, PythonPatterns.builtinExceptions, PythonPatterns.magicNames, PythonPatterns.specialNames, PythonPatterns.illegalNames, PythonPatterns.specialVariables, PythonPatterns.ellipsis, PythonPatterns.punctuation, PythonPatterns.lineContinuation);
+AtlPatterns.atlExpression.patterns!.push(PythonPatterns.expression);
+AtlPatterns.atlEventName.patterns!.splice(0, 0, PythonPatterns.builtinPossibleCallables);
+AtlPatterns.atlEventDefName.patterns!.splice(0, 0, PythonPatterns.builtinPossibleCallables);
+AtlPatterns.atlOn.beginCaptures![3].patterns!.push(RenpyPatterns.comments);
+AtlPatterns.atlFunction.captures![2].patterns!.splice(0, 0, PythonPatterns.builtinPossibleCallables);
+AtlPatterns.atlWarperName.patterns!.splice(0, 0, PythonPatterns.builtinPossibleCallables);
+
+// Push all PythonPatterns external includes
+PythonPatterns.stringUnicodeGuts.patterns!.splice(0, 0, RenpyPatterns.stringsInterior);
+
+
+export { AtlPatterns, RenpyPatterns, PythonPatterns };
\ No newline at end of file
diff --git a/src/tokenizer/token-patterns.ts b/src/tokenizer/token-patterns.ts
deleted file mode 100644
index ceb3fe0..0000000
--- a/src/tokenizer/token-patterns.ts
+++ /dev/null
@@ -1,953 +0,0 @@
-/* eslint-disable no-useless-escape */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable no-useless-backreference */
-
-import { CharacterTokenType, LiteralTokenType, EntityTokenType, KeywordTokenType, MetaTokenType, OperatorTokenType } from "./renpy-tokens";
-import { comments, expressions, newLine, statements, charactersPatten, whiteSpace, numFloat, numInt, invalidToken, strings, stringsInterior } from "./common-token-patterns";
-import { atl } from "./atl-token-patterns";
-import { pythonBuiltinPossibleCallables, pythonExpression, pythonExpressionBare, pythonFunctionArguments, pythonNumber, pythonSpecialVariables } from "./python-token-patterns";
-import { TokenPattern } from "./token-pattern-types";
-// NOTE: These patterns are converted from the tmLanguage file.
-// ANY CHANGES MADE HERE SHOULD BE PORTED TO THAT FILE AS WELL
-// Copy the patterns (the contents of the repository group) over and apply the following find and replace patterns:
-
-// find: ^( +)"(\w+?)(?:[\-_](\w+?))?(?:[\-_](\w+?))?(?:[\-_](\w+?))?": \{$\n((?:^.*$\n)+?)^\1\},?
-// replace with: const \L$2\u$3\u$4\u$5: TokenPattern = {\n$6};
-
-// find: \{ "include": "#?(\w+?)(?:[\-_](\w+?))?(?:[\-_](\w+?))?(?:[\-_](\w+?))?" \}
-// find: \{ "include": "([\w\.]+)#?(\w+?)(?:[\-_](\w+?))?(?:[\-_](\w+?))?(?:[\-_](\w+?))?" \}
-// replace with: \L$1\u$2\u$3\u$4
-
-// find: (?<=^ *|\{ )"comment": "(.*?)"(?=,$| \}),?
-// replace with: // $1
-
-// find: (?<=^ *|\{ )"name": "(.*?)"(?=,$| \})
-// replace with: token: "$1"
-
-// find: (?<=^ *|\{ )"contentName": "(.*?)"(?=,$| \})
-// replace with: contentToken: "$1"
-
-// find: (?<=^ *|\{ )"(.*?)"(?=: [{["])
-// replace with: $1
-
-// find: (?<=(?:^ *|\{ )(?:match|begin|end): /.*?)\\\\(?=.*?/dg,?$)
-// replace with: \
-
-// find: (?<=(?:^ *|\{ )(?:match|begin|end): )"(.*?)"(?=,?$)
-// replace with: /$1/dg
-
-// Result should be manually fixed
-// Make sure to include this in internal captures to detect all newline tokens
-
-const lineContinuationPattern = /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])|\Z/gm;
-
-export const basePatterns: TokenPattern = {
-    debugName: "basePatterns",
-
-    patterns: [statements, expressions],
-};
-
-const literal: TokenPattern = {
-    debugName: "literal",
-
-    patterns: [
-        {
-            // Python literals,
-            token: LiteralTokenType.Boolean,
-            match: /\b(?<!\.)(True|False|None)\b/g,
-        },
-    ],
-};
-
-const pythonParameters: TokenPattern = {
-    debugName: "pythonParameters",
-
-    patterns: [whiteSpace],
-};
-
-const pythonSource: TokenPattern = {
-    debugName: "pythonSource",
-
-    patterns: [comments, strings, whiteSpace, newLine],
-};
-
-const pythonStatements: TokenPattern = {
-    debugName: "pythonStatements",
-
-    patterns: [
-        {
-            match: /^[ \t]*(init)[ \t]+(offset)[ \t]*(=)[ \t]*(-)?([^#]*?)$/dgm,
-            captures: {
-                0: { patterns: [whiteSpace] },
-                1: { token: KeywordTokenType.Init },
-                2: { token: KeywordTokenType.Offset },
-                3: { token: OperatorTokenType.Assign },
-                4: { token: OperatorTokenType.Minus },
-                5: {
-                    patterns: [numInt, invalidToken],
-                },
-            },
-        },
-        {
-            // Renpy python block
-            token: MetaTokenType.CodeBlock,
-            contentToken: MetaTokenType.PythonBlock,
-
-            begin: /^([ \t]+)?(?:(init)(?:[ \t]+(-)?(\d+))?[ \t]+)?(python)[ \t]*(.*)?(:)/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: {}, // required for end match, but is already named by capture[0]
-                2: { token: KeywordTokenType.Init },
-                3: { token: OperatorTokenType.Minus },
-                4: { token: LiteralTokenType.Integer },
-                5: { token: KeywordTokenType.Python },
-                6: {
-                    token: MetaTokenType.Arguments,
-                    patterns: [
-                        {
-                            // in statement
-                            match: /(?:\s*(in)\s*([a-zA-Z_]\w*)\b)/dg,
-                            captures: {
-                                1: { token: OperatorTokenType.In },
-                                2: { token: EntityTokenType.Namespace },
-                            },
-                        },
-                        {
-                            // keywords
-                            match: /\b(hide)|(early)|(in)\b/dg,
-                            captures: {
-                                1: { token: KeywordTokenType.Hide },
-                                2: { token: KeywordTokenType.Early },
-                                3: { token: OperatorTokenType.In },
-                            },
-                        },
-                    ],
-                },
-                7: { token: CharacterTokenType.Colon },
-            },
-            end: lineContinuationPattern,
-            patterns: [pythonSource],
-        },
-        {
-            // Match begin and end of python one line statements
-            contentToken: MetaTokenType.PythonLine,
-            begin: /^[ \t]*(?:(\$)|(define)|(default))(?=[ \t])/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: { token: KeywordTokenType.DollarSign },
-                2: { token: KeywordTokenType.Define },
-                3: { token: KeywordTokenType.Default },
-            },
-            end: /$/gm,
-            patterns: [
-                {
-                    // Type the first name as a variable (Probably not needed, but python doesn't seem to catch it)
-                    match: /(?<!\.)\b([a-zA-Z_]\w*)(?=\s=\s)/g,
-                    token: EntityTokenType.VariableName,
-                },
-                pythonExpression,
-            ],
-        },
-    ],
-};
-
-const sayStatements: TokenPattern = {
-    debugName: "sayStatements",
-
-    patterns: [
-        {
-            token: MetaTokenType.SayStatement,
-            contentToken: LiteralTokenType.String,
-            begin: /(?<=^[ \t]+)(?:([a-zA-Z_]\w*)\b|"([a-zA-Z_]\w*)\b")((?:[ \t]+(?:@|\w+))*)?[ \t]*("""|"|'''|'|```|`)/dgm,
-            beginCaptures: {
-                1: {
-                    token: EntityTokenType.VariableName,
-                    patterns: [
-                        {
-                            match: /extend/g,
-                            token: KeywordTokenType.Extend,
-                        },
-                        {
-                            match: /voice/g,
-                            token: KeywordTokenType.Voice,
-                        },
-                        {
-                            // Match special characters,
-                            match: /adv|nvl|narrator|name_only|centered|vcentered/g,
-                            token: EntityTokenType.VariableName,
-                        },
-                        invalidToken,
-                    ],
-                },
-                2: {
-                    token: MetaTokenType.CharacterNameString,
-                },
-                3: {
-                    token: MetaTokenType.Arguments,
-                    patterns: [
-                        {
-                            token: KeywordTokenType.At,
-                            match: /@/g,
-                        },
-                    ],
-                },
-                4: { token: CharacterTokenType.Quote },
-            },
-            end: /(?<!\\)(((?<=\4)\4)|\4)[ \t]*(\(.*?\)(?![^\(]*?\)))?/dg,
-            endCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: { token: CharacterTokenType.Quote },
-                2: { token: MetaTokenType.EmptyString },
-                3: { patterns: [pythonFunctionArguments] },
-            },
-            patterns: [stringsInterior],
-        },
-        {
-            begin: /(?<=^[ \t]+)(?=["'`])/gm,
-            end: /(?<!\\)(?<=["'`])[ \t]*(\(.*?\)(?![^\(]*?\)))?/dg,
-            endCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: { patterns: [pythonFunctionArguments] },
-            },
-            patterns: [
-                {
-                    token: LiteralTokenType.String,
-                    contentToken: MetaTokenType.NarratorSayStatement,
-                    begin: /"""|"|'''|'|```|`/dg,
-                    beginCaptures: {
-                        0: { token: CharacterTokenType.Quote },
-                    },
-                    end: /(?<!\\)(((?<=\0)\0)|\0)/dg,
-                    endCaptures: {
-                        1: { token: CharacterTokenType.Quote },
-                        2: { token: MetaTokenType.EmptyString },
-                    },
-                    patterns: [stringsInterior],
-                },
-            ],
-        },
-    ],
-};
-
-const menuOption: TokenPattern = {
-    debugName: "menuOption",
-
-    contentToken: MetaTokenType.MenuOptionBlock,
-    begin: /^([ \t]+)((?:".*")|(?:'.*')|(?:""".*"""))[ \t]*(.+)?(:)/dgm,
-    beginCaptures: {
-        0: { patterns: [whiteSpace] },
-        1: {}, // required for end match, but is already named by capture[0]
-        2: {
-            token: MetaTokenType.MenuOption,
-            patterns: [strings],
-        },
-        3: {
-            token: MetaTokenType.PythonLine,
-            patterns: [
-                pythonFunctionArguments,
-                {
-                    // if condition
-                    match: /\b(if)[ \t]+(.+)?/dg,
-                    captures: {
-                        1: { token: KeywordTokenType.If },
-                        2: {
-                            patterns: [pythonExpressionBare],
-                        },
-                    },
-                },
-                {
-                    match: /[^ \t]+/g,
-                    token: MetaTokenType.Invalid,
-                },
-            ],
-        },
-        4: { token: CharacterTokenType.Colon },
-    },
-    end: lineContinuationPattern,
-    patterns: [basePatterns],
-};
-const menuSet: TokenPattern = {
-    debugName: "menuSet",
-
-    match: /^[ \t]+(set)[ \t]+(.+)?/dgm,
-    captures: {
-        0: { patterns: [whiteSpace] },
-        1: { token: KeywordTokenType.Set },
-        2: {
-            // set arguments
-            token: MetaTokenType.PythonLine,
-            patterns: [pythonExpressionBare],
-        },
-    },
-};
-const menu: TokenPattern = {
-    debugName: "menu",
-
-    token: MetaTokenType.MenuStatement,
-    contentToken: MetaTokenType.MenuBlock,
-    begin: /^([ \t]+)?(menu)[ \t]*(.+)?(:)/dgm,
-    beginCaptures: {
-        0: { patterns: [whiteSpace] },
-        1: {}, // required for end match, but is already named by capture[0]
-        2: { token: KeywordTokenType.Menu },
-        3: {
-            // Menu arguments
-            token: MetaTokenType.Arguments,
-            patterns: [
-                {
-                    // Menu name
-                    match: /[a-zA-Z_.]\w*/g,
-                    token: EntityTokenType.FunctionName,
-                },
-                pythonFunctionArguments,
-            ],
-        },
-        4: { token: CharacterTokenType.Colon },
-    },
-    end: lineContinuationPattern,
-    patterns: [comments, menuOption, sayStatements, menuSet, charactersPatten],
-};
-
-const keywords: TokenPattern = {
-    debugName: "keywords",
-
-    patterns: [
-        {
-            // Control flow keywords
-            match: /\b(?<!\.)(?:(pass)|(return))\b/dg,
-            captures: {
-                1: { token: KeywordTokenType.Pass },
-                2: { token: KeywordTokenType.Return },
-            },
-        },
-        {
-            // Control flow keywords with block
-            begin: /\b(?<!\.)(?:(if)|(elif)|(else)|(for)|(while))\b/dg,
-            contentToken: MetaTokenType.PythonLine,
-            beginCaptures: {
-                1: { token: KeywordTokenType.If },
-                2: { token: KeywordTokenType.Elif },
-                3: { token: KeywordTokenType.Else },
-                4: { token: KeywordTokenType.For },
-                5: { token: KeywordTokenType.While },
-            },
-            end: /:/dg,
-            endCaptures: {
-                0: { token: CharacterTokenType.Colon },
-            },
-            patterns: [expressions, pythonExpression],
-        },
-        {
-            // Python statement keywords
-            match: /\b(?:(init)|(python)|(hide)|(early)|(in)|(define)|(default))\b/dg,
-            captures: {
-                1: {
-                    token: KeywordTokenType.Init,
-                },
-                2: {
-                    token: KeywordTokenType.Python,
-                },
-                3: {
-                    token: KeywordTokenType.Hide,
-                },
-                4: {
-                    token: KeywordTokenType.Early,
-                },
-                5: {
-                    token: OperatorTokenType.In,
-                },
-                6: {
-                    token: KeywordTokenType.Define,
-                },
-                7: {
-                    token: KeywordTokenType.Default,
-                },
-            },
-        },
-        {
-            // Renpy keywords
-            match: /\b(?:(camera)|(image)|(label)|(layeredimage)|(menu)|(nvl[ \\t]+clear)|(play)|(queue)|(scene)|(screen)|(show)|(transform)|(translate)|(voice(?:[ \\t]+sustain)?)|(window)|(frame))\b/dg,
-            captures: {
-                1: { token: KeywordTokenType.Camera },
-                2: { token: KeywordTokenType.Image },
-                3: { token: KeywordTokenType.Label },
-                4: { token: KeywordTokenType.LayeredImage },
-                5: { token: KeywordTokenType.Menu },
-                6: { token: KeywordTokenType.NVLClear },
-                7: { token: KeywordTokenType.Play },
-                8: { token: KeywordTokenType.Queue },
-                9: { token: KeywordTokenType.Scene },
-                10: { token: KeywordTokenType.Screen },
-                11: { token: KeywordTokenType.Show },
-                12: { token: KeywordTokenType.Transform },
-                13: { token: KeywordTokenType.Translate },
-                14: { token: KeywordTokenType.Voice },
-                15: { token: KeywordTokenType.Window },
-                16: { token: KeywordTokenType.Frame },
-            },
-        },
-        {
-            match: /^[ \t]+(pause)\b[ \t]*([^#]*?)$/dgm,
-            captures: {
-                0: { patterns: [whiteSpace] },
-                1: { token: KeywordTokenType.Pause },
-                2: {
-                    patterns: [numFloat, numInt, invalidToken],
-                },
-            },
-        },
-        {
-            // [TODO: Should probably only be a keyword in the expression]Renpy sub expression keywords
-            match: /\b(?:(set)|(expression)|(at)|(with)|(from))\b/dg,
-            captures: {
-                1: {
-                    token: KeywordTokenType.Set,
-                },
-                2: {
-                    token: KeywordTokenType.Expression,
-                },
-                3: {
-                    token: KeywordTokenType.At,
-                },
-                4: {
-                    token: KeywordTokenType.With,
-                },
-                5: {
-                    token: KeywordTokenType.From,
-                },
-            },
-        },
-    ],
-};
-
-const transform: TokenPattern = {
-    debugName: "transform",
-
-    begin: /^([ \t]+)?(transform)\b[ \t]*(.*)?(:)/dgm,
-    beginCaptures: {
-        1: { token: CharacterTokenType.WhiteSpace },
-        2: { token: KeywordTokenType.Transform },
-        3: {
-            patterns: [
-                {
-                    token: EntityTokenType.VariableName,
-                    match: /\b([[:alpha:]_]\w*)\b/g,
-                },
-            ],
-        },
-        4: { token: CharacterTokenType.Colon },
-    },
-    end: /^(?=(?!\1)[ \t]*[^\s#]|\1[^\s#])/gm,
-    patterns: [atl],
-};
-
-const withStatement: TokenPattern = {
-    debugName: "withStatement",
-
-    token: MetaTokenType.CodeBlock,
-    match: /\b(with)\b[ \t]*(.+)?/dg,
-    captures: {
-        1: { token: KeywordTokenType.With },
-        2: {
-            token: MetaTokenType.Arguments,
-            patterns: [expressions],
-        },
-    },
-};
-const at: TokenPattern = {
-    debugName: "at",
-
-    token: MetaTokenType.CodeBlock,
-    match: /\b(at)\b[ \t]*(.+)?/dg,
-    captures: {
-        1: { token: KeywordTokenType.At },
-        2: {
-            token: MetaTokenType.Arguments,
-            patterns: [statements],
-        },
-    },
-};
-const as: TokenPattern = {
-    debugName: "as",
-
-    token: MetaTokenType.CodeBlock,
-    match: /\b(as)\b[ \t]*(.+)?/dg,
-    captures: {
-        1: { token: KeywordTokenType.As },
-        2: {
-            token: MetaTokenType.Arguments,
-            patterns: [statements],
-        },
-    },
-};
-const behind: TokenPattern = {
-    debugName: "behind",
-
-    token: MetaTokenType.CodeBlock,
-    match: /\b(behind)\b[ \t]*(.+)?/dg,
-    captures: {
-        1: { token: KeywordTokenType.Behind },
-        2: {
-            token: MetaTokenType.Arguments,
-            patterns: [statements],
-        },
-    },
-};
-const onlayer: TokenPattern = {
-    debugName: "onlayer",
-
-    token: MetaTokenType.CodeBlock,
-    match: /\b(onlayer)\b[ \t]*(.+)?/dg,
-    captures: {
-        1: { token: KeywordTokenType.OnLayer },
-        2: {
-            token: MetaTokenType.Arguments,
-            patterns: [statements],
-        },
-    },
-};
-const zorder: TokenPattern = {
-    debugName: "zorder",
-
-    token: MetaTokenType.CodeBlock,
-    match: /\b(zorder)\b[ \t]*(.+)?/dg,
-    captures: {
-        1: { token: KeywordTokenType.ZOrder },
-        2: {
-            token: MetaTokenType.Arguments,
-            patterns: [statements],
-        },
-    },
-};
-
-const image: TokenPattern = {
-    debugName: "image",
-
-    patterns: [
-        {
-            token: MetaTokenType.ImageStatement,
-            contentToken: MetaTokenType.ATLBlock,
-            begin: /^([ \t]+)?(image)\b[ \t]*([a-zA-Z_0-9 ]*?)[ \t]*(:)/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: {}, // required for end match, but is already named by capture[0]
-                2: { token: KeywordTokenType.Image },
-                3: { token: EntityTokenType.VariableName },
-                4: { token: CharacterTokenType.Colon },
-            },
-            end: lineContinuationPattern,
-            patterns: [atl],
-        },
-        {
-            debugName: "imageStatement",
-            token: MetaTokenType.ImageStatement,
-            begin: /^[ \t]*(image)\b[ \t]*/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: { token: KeywordTokenType.Image },
-            },
-            end: /(?!\G)(?=\b(at)\b|#|=)|$/gm,
-            patterns: [
-                strings,
-                {
-                    match: /\b([a-zA-Z_0-9]+)\b([ \t]+)?/dg,
-                    captures: {
-                        1: { token: EntityTokenType.VariableName },
-                        2: { token: CharacterTokenType.WhiteSpace },
-                    },
-                },
-            ],
-        },
-        at,
-        withStatement,
-    ],
-};
-const show: TokenPattern = {
-    debugName: "show",
-
-    patterns: [
-        {
-            token: MetaTokenType.ShowStatement,
-            contentToken: MetaTokenType.ATLBlock,
-            begin: /^([ \t]+)?(show)\b[ \t]*([a-zA-Z_0-9 ]*?)[ \t]*(:)/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: {}, // required for end match, but is already named by capture[0]
-                2: { token: KeywordTokenType.Show },
-                3: { token: EntityTokenType.VariableName },
-                4: { token: CharacterTokenType.Colon },
-            },
-            end: lineContinuationPattern,
-            patterns: [atl],
-        },
-        {
-            token: MetaTokenType.ShowStatement,
-            begin: /^[ \t]*(show)\b[ \t]*/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: { token: KeywordTokenType.Show },
-            },
-            end: /(?=\b(at|as|behind|onlayer|expression|with|zorder)\b|#)|$/gm,
-            patterns: [
-                strings,
-                {
-                    match: /\b([a-zA-Z_0-9]+)\b([ \t]+)?/dg,
-                    captures: {
-                        1: { token: EntityTokenType.VariableName },
-                        2: { token: CharacterTokenType.WhiteSpace },
-                    },
-                },
-                invalidToken,
-            ],
-        },
-        at,
-        as,
-        withStatement,
-        behind,
-        onlayer,
-        zorder,
-    ],
-};
-const scene: TokenPattern = {
-    debugName: "scene",
-
-    patterns: [
-        {
-            token: MetaTokenType.SceneStatement,
-            contentToken: MetaTokenType.ATLBlock,
-            begin: /^([ \t]+)?(scene)\b[ \t]*([a-zA-Z_0-9 ]*?)[ \t]*(:)/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: {}, // required for end match, but is already named by capture[0]
-                2: { token: KeywordTokenType.Scene },
-                3: { token: EntityTokenType.VariableName },
-                4: { token: CharacterTokenType.Colon },
-            },
-            end: lineContinuationPattern,
-            patterns: [atl],
-        },
-        {
-            token: MetaTokenType.SceneStatement,
-            begin: /^[ \t]*(scene)\b[ \t]*/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: { token: KeywordTokenType.Scene },
-            },
-            end: /(?=\b(at|as|behind|onlayer|expression|with|zorder)\b|#)|$/gm,
-            patterns: [
-                strings,
-                {
-                    match: /\b([a-zA-Z_0-9]+)\b([ \t]+)?/dg,
-                    captures: {
-                        1: { token: EntityTokenType.VariableName },
-                        2: { token: CharacterTokenType.WhiteSpace },
-                    },
-                },
-            ],
-        },
-        at,
-        as,
-        withStatement,
-        behind,
-        onlayer,
-        zorder,
-    ],
-};
-const camera: TokenPattern = {
-    debugName: "camera",
-
-    patterns: [
-        {
-            token: MetaTokenType.CameraStatement,
-            contentToken: MetaTokenType.ATLBlock,
-            begin: /^([ \t]+)?(camera)\b[ \t]*(:)/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: {}, // required for end match, but is already named by capture[0]
-                2: { token: KeywordTokenType.Camera },
-                3: { token: EntityTokenType.VariableName },
-                4: { token: CharacterTokenType.Colon },
-            },
-            end: lineContinuationPattern,
-            patterns: [atl],
-        },
-        {
-            token: MetaTokenType.CameraStatement,
-            begin: /^[ \t]*(camera)\b[ \t]*/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: { token: KeywordTokenType.Camera },
-            },
-            end: /(?=\b(at|with)\b|#)|$/gm,
-            patterns: [
-                {
-                    match: /\b([a-zA-Z_0-9]+)\b([ \t]+)?/dg,
-                    captures: {
-                        1: { token: EntityTokenType.VariableName },
-                        2: { token: CharacterTokenType.WhiteSpace },
-                    },
-                },
-            ],
-        },
-        at,
-        withStatement,
-    ],
-};
-
-const builtinLabels: TokenPattern = {
-    debugName: "builtinLabels",
-
-    token: EntityTokenType.FunctionName,
-    match: /(?<!\.)\b(?:start|quit|after_load|splashscreen|before_main_menu|main_menu|after_warp|hide_windows)\b/g,
-};
-const labelName: TokenPattern = {
-    debugName: "labelName",
-
-    patterns: [
-        pythonBuiltinPossibleCallables,
-        builtinLabels,
-        {
-            token: EntityTokenType.FunctionName,
-            match: /\b(?:[a-zA-Z_]\w*)\b/g,
-        },
-    ],
-};
-const labelCall: TokenPattern = {
-    debugName: "labelCall",
-
-    // Note: label params are only allowed at the end of the access expression,
-    token: MetaTokenType.LabelCall,
-    begin: /\b(?=([a-zA-Z_]\w*)\s*(\())/g,
-    end: /(\))/dg,
-    endCaptures: {
-        1: { token: CharacterTokenType.CloseParentheses },
-    },
-    patterns: [pythonSpecialVariables, labelName, pythonFunctionArguments],
-};
-const labelAccess: TokenPattern = {
-    debugName: "labelAccess",
-
-    // Note: Labels can't be nested twice in a row!,
-    token: MetaTokenType.LabelAccess,
-    begin: /(\.)\s*(?!\.)/dg,
-    beginCaptures: {
-        1: { token: CharacterTokenType.Period },
-    },
-    end: /(?<=\S)(?=\W)|(^|(?<=\s))(?=[^\\\w\s])|$/gm,
-    patterns: [labelCall, labelName],
-};
-const labelDefName: TokenPattern = {
-    debugName: "labelDefName",
-
-    // Note: Labels can't be nested twice in a row!,
-    patterns: [
-        pythonBuiltinPossibleCallables,
-        builtinLabels,
-        {
-            match: /(?<=^|[ \t])(\b(?:[a-zA-Z_]\w*)\b)?(\.)?(\b(?:[a-zA-Z_]\w*)\b)/dgm,
-            captures: {
-                1: { token: EntityTokenType.FunctionName },
-                2: { token: CharacterTokenType.Period },
-                3: { token: EntityTokenType.FunctionName },
-            },
-        },
-    ],
-};
-const label: TokenPattern = {
-    debugName: "label",
-
-    token: MetaTokenType.LabelStatement,
-    match: /^[ \t]*(label)\b[ \t]*(.*?)([ \t]*hide)?(:)/dgm,
-    captures: {
-        0: { patterns: [whiteSpace] },
-        1: { token: KeywordTokenType.Label },
-        2: {
-            patterns: [labelDefName, pythonParameters, invalidToken],
-        },
-        3: { token: KeywordTokenType.Hide },
-        4: { token: CharacterTokenType.Colon },
-    },
-};
-
-const callJumpExpression: TokenPattern = {
-    debugName: "callJumpExpression",
-
-    begin: /\b(?<!\.)(expression)\b/dg,
-    beginCaptures: {
-        1: { token: KeywordTokenType.Expression },
-    },
-    end: /(?=\b(?<!\.)(?:pass|from)\b)|$/gm,
-    patterns: [expressions, pythonExpression],
-};
-const callPass: TokenPattern = {
-    debugName: "callPass",
-
-    begin: /\b(?<!\.)(pass)\b[ \t]*(?=\()/dg,
-    beginCaptures: {
-        0: { patterns: [whiteSpace] },
-        1: { token: KeywordTokenType.Pass },
-    },
-    end: /(\))/dg,
-    endCaptures: {
-        1: { token: CharacterTokenType.CloseParentheses },
-    },
-    patterns: [pythonFunctionArguments],
-};
-const callFrom: TokenPattern = {
-    debugName: "callFrom",
-
-    begin: /\b(?<!\.)(from)\b[ \t]*/dg,
-    beginCaptures: {
-        0: { patterns: [whiteSpace] },
-        1: { token: KeywordTokenType.From },
-    },
-    end: /(?=\W|$)/gm,
-    patterns: [labelName],
-};
-const call: TokenPattern = {
-    debugName: "call",
-
-    token: MetaTokenType.CallStatement,
-    begin: /^[ \t]+(call)\b[ \t]*/dgm,
-    beginCaptures: {
-        0: { patterns: [whiteSpace] },
-        1: { token: KeywordTokenType.Call },
-    },
-    end: /(?=#|$)/dgm,
-    endCaptures: {
-        1: { token: MetaTokenType.Invalid },
-    },
-    patterns: [
-        callJumpExpression,
-        callPass,
-        {
-            // Label expression,
-            begin: /\G/g,
-            end: /(?!\G)(?![ \t]*\.[ \t]*)/g,
-            patterns: [labelCall, labelAccess, labelName],
-        },
-        callFrom,
-    ],
-};
-const jump: TokenPattern = {
-    debugName: "jump",
-
-    token: MetaTokenType.JumpStatement,
-    begin: /^[ \t]+(jump)\b[ \t]*/dgm,
-    beginCaptures: {
-        0: { patterns: [whiteSpace] },
-        1: { token: KeywordTokenType.Jump },
-    },
-    end: /(?!\G)[ \t]*(.*?)?(?=#|$)/dgm,
-    endCaptures: {
-        0: { patterns: [whiteSpace] },
-        1: { token: MetaTokenType.Invalid },
-    },
-    patterns: [
-        callJumpExpression,
-        {
-            // Label expression,
-            begin: /\G/g,
-            end: /(?!\G)(?![ \t]*\.[ \t]*)/g,
-            patterns: [labelAccess, labelName],
-        },
-    ],
-};
-const returnStatements: TokenPattern = {
-    debugName: "returnStatements",
-
-    begin: /^[ \t]+(return)\b[ \t]*/dgm,
-    beginCaptures: {
-        0: { patterns: [whiteSpace] },
-        1: { token: KeywordTokenType.Return },
-    },
-    end: /$/gm,
-    patterns: [expressions, pythonExpression],
-};
-
-const builtinAudioChannels: TokenPattern = {
-    debugName: "builtinAudioChannels",
-
-    token: EntityTokenType.PropertyName,
-    match: /(?<!\.)\b(?:music|sound|voice|audio)\b/g,
-};
-const audioParams: TokenPattern = {
-    debugName: "audioParams",
-
-    patterns: [
-        {
-            token: EntityTokenType.PropertyName,
-            match: /\b(?<!\.)(?:fadeout|fadein|volume|loop|noloop)\b/g,
-        },
-        pythonNumber,
-    ],
-};
-const play: TokenPattern = {
-    debugName: "play",
-
-    patterns: [
-        {
-            token: MetaTokenType.PlayAudioStatement,
-            begin: /^[ \t]*(play|queue)\b[ \t]+\b([a-zA-Z_0-9]*)\b[ \t]*/dgm,
-            beginCaptures: {
-                0: { patterns: [whiteSpace] },
-                1: { token: KeywordTokenType.Play },
-                2: {
-                    patterns: [
-                        builtinAudioChannels,
-                        {
-                            match: /.*/g,
-                            token: EntityTokenType.VariableName,
-                        },
-                    ],
-                },
-            },
-            end: /(?=[ \t]*#)|$/gm,
-            patterns: [strings, audioParams, pythonExpression],
-        },
-    ],
-};
-const stop: TokenPattern = {
-    debugName: "stop",
-
-    patterns: [
-        {
-            token: MetaTokenType.StopAudioStatement,
-            begin: /^[ \t]*(stop)\b[ \t]+\b([a-zA-Z_0-9]*)\b[ \t]*/dgm,
-            beginCaptures: {
-                1: { token: KeywordTokenType.Stop },
-                2: {
-                    patterns: [
-                        builtinAudioChannels,
-                        {
-                            match: /.*/g,
-                            token: EntityTokenType.VariableName,
-                        },
-                    ],
-                },
-            },
-            end: /(?=[ \t]*#)|$/gm,
-            patterns: [
-                {
-                    match: /\b(?<!\.)(?:fadeout)\b/g,
-                    token: KeywordTokenType.Fadeout,
-                },
-                pythonNumber,
-            ],
-        },
-    ],
-};
-const audio: TokenPattern = {
-    debugName: "audio",
-
-    patterns: [play, stop],
-};
-
-const renpyStatements: TokenPattern = {
-    debugName: "renpyStatements",
-
-    patterns: [label, menu, image, audio, transform, scene, camera, show, withStatement, returnStatements, jump, call],
-};
-
-statements.patterns!.push(renpyStatements, pythonStatements, keywords, sayStatements);
-expressions.patterns!.push(comments, strings, literal, charactersPatten);
diff --git a/src/tokenizer/tokenizer.ts b/src/tokenizer/tokenizer.ts
index e5d8e14..0361496 100644
--- a/src/tokenizer/tokenizer.ts
+++ b/src/tokenizer/tokenizer.ts
@@ -1,25 +1,56 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { assert } from "console";
 import { performance } from "perf_hooks";
-import { TextDocument, Uri } from "vscode";
-import { Token, isRangePattern, isMatchPattern, isRepoPattern, TokenPosition } from "./token-definitions";
-import { basePatterns } from "./token-patterns";
+import { TextDocument, Uri, Range as VSRange } from "vscode";
+import { Token, isRangePattern, isMatchPattern, isRepoPattern, TokenPosition, TokenTree, TreeNode, Range } from "./token-definitions";
+import { RenpyPatterns } from "./token-patterns.g";
 import { Stack } from "../utilities/stack";
 import { Vector } from "../utilities/vector";
-import { CharacterTokenType } from "./renpy-tokens";
 import { TokenPatternCapture, TokenCapturePattern, TokenRepoPattern, TokenRangePattern, TokenMatchPattern } from "./token-pattern-types";
 
-type ScanResult = { pattern: ExTokenPattern; matchBegin: RegExpExecArray; matchEnd?: RegExpExecArray } | null;
-type TokenCache = { readonly documentVersion: number; readonly tokens: Token[] };
+const cloneScanResult = (obj: ScanResult | undefined): ScanResult | undefined => {
+    if (obj === undefined) return undefined;
+    if (obj === null) return null;
+    return { ...obj };
+};
+
+const cloneCache = (obj: Array<ScanResult | undefined>): Array<ScanResult | undefined> => {
+    const clone = new Array<ScanResult | undefined>(obj.length);
+    for (let i = 0; i < obj.length; ++i) {
+        clone[i] = cloneScanResult(obj[i]);
+    }
+    return clone;
+};
+
+interface MatchScanResult {
+    pattern: ExTokenPattern;
+    matchBegin: RegExpExecArray;
+    matchEnd?: never;
+    expanded?: never;
+    contentMatches?: never;
+    source?: never;
+}
+interface RangeScanResult {
+    pattern: ExTokenPattern;
+    matchBegin: RegExpExecArray;
+    matchEnd: RegExpExecArray | null;
+    expanded: boolean;
+    contentMatches: Stack<ScanResult> | null;
+    source: string;
+}
+type ScanResult = MatchScanResult | RangeScanResult | null;
+type TokenCache = { readonly documentVersion: number; readonly tokens: TokenTree };
 
 const tokenCache = new Map<Uri, TokenCache>();
 const runBenchmark = false;
 let uniquePatternCount = -1;
 
-export function tokenizeDocument(document: TextDocument): Token[] {
+export function tokenizeDocument(document: TextDocument): TokenTree {
     setupAndValidatePatterns();
 
-    if (runBenchmark) benchmark(document);
+    if (runBenchmark) {
+        benchmark(document);
+    }
 
     const cachedTokens = tokenCache.get(document.uri);
     if (cachedTokens?.documentVersion === document.version) {
@@ -29,9 +60,8 @@ export function tokenizeDocument(document: TextDocument): Token[] {
     console.log(`Running tokenizer on document: ${document.fileName}`);
     const tokenizer = new DocumentTokenizer(document);
     console.log(`Tokenizer completed!`);
-    const tokens = tokenizer.tokens.toArray();
-    tokenCache.set(document.uri, { documentVersion: document.version, tokens: tokens });
-    return tokens;
+    tokenCache.set(document.uri, { documentVersion: document.version, tokens: tokenizer.tokens });
+    return tokenizer.tokens;
 }
 
 export function clearTokenCache() {
@@ -86,9 +116,10 @@ function setupAndValidatePatterns() {
 
     uniquePatternCount = 0;
     const stack = new Stack<ExTokenPattern>(32);
-    stack.push(basePatterns as ExTokenRepoPattern);
+    stack.push(RenpyPatterns.basePatterns as ExTokenRepoPattern);
 
     const mFlagRe = /(?<!\[)[\^$]/g;
+    const gAnchorRe = /\(\\G\)|\(\?!\\G\)/g;
     while (!stack.isEmpty()) {
         const p = stack.pop()!;
         assert(p !== undefined, "This pattern is undefined! Please make sure that circular includes are added after both patterns are defined.");
@@ -103,10 +134,17 @@ function setupAndValidatePatterns() {
             for (let i = 0; i < p.patterns.length; ++i) stack.push(p.patterns[i]);
         } else if (isRangePattern(p)) {
             p._patternType = TokenPatternType.RangePattern;
-            if (p.begin.source.match(mFlagRe)) {
+            let reBeginSource = p.begin.source;
+
+            if (reBeginSource.match(mFlagRe)) {
                 assert(p.begin.multiline, "To match this pattern the 'm' flag is required on the begin RegExp!");
             }
 
+            if (gAnchorRe.test(reBeginSource)) {
+                console.warn("\\G anchor is not supported and will be ignored!");
+                reBeginSource = reBeginSource.replace(gAnchorRe, "");
+            }
+
             assert(p.begin.global && p.end.global, "To match this pattern the 'g' flag is required on the begin and end RegExp!");
             if (p.beginCaptures) {
                 assert(p.begin.hasIndices, "To match this begin pattern the 'd' flag is required!");
@@ -138,14 +176,21 @@ function setupAndValidatePatterns() {
 
             let reEndSource = p.end.source;
 
-            if (reEndSource.match(mFlagRe)) {
+            if (mFlagRe.test(reEndSource)) {
                 assert(p.end.multiline, "To match this pattern the 'm' flag is required on the end RegExp!");
             }
 
+            if (gAnchorRe.test(reEndSource)) {
+                console.warn("\\G anchor is not supported and will be ignored!");
+                reEndSource = reEndSource.replace(gAnchorRe, "");
+            }
+
             p._hasBackref = /\\\d+/.test(reEndSource);
             //reEndSource = reEndSource.replaceAll("\\A", "¨0");
-            reEndSource = reEndSource.replaceAll("\\Z", "$(?!\r\n|\r|\n)"); // This assumes (CR)LF without trailing new line right?...
+            reEndSource = reEndSource.replaceAll("\\Z", "$(?!\r\n|\r|\n)");
             reEndSource = reEndSource.replaceAll("\\R", "(?!\r\n|\r|\n)");
+
+            p.begin = new RegExp(reBeginSource, p.begin.flags);
             p.end = new RegExp(reEndSource, p.end.flags);
         } else if (isMatchPattern(p)) {
             p._patternType = TokenPatternType.MatchPattern;
@@ -176,12 +221,49 @@ export function escapeRegExpCharacters(value: string): string {
 
 class DocumentTokenizer {
     private readonly backrefReplaceRe = /\\(\d+)/g;
-    public readonly tokens: Vector<Token> = new Vector<Token>(16384);
+    public readonly tokens: TokenTree = new TokenTree();
+    private readonly document: TextDocument;
 
     constructor(document: TextDocument) {
+        this.document = document;
         const text = document.getText();
-        const carret = new TokenPosition(0, 0, 0);
-        this.executePattern(basePatterns as ExTokenRepoPattern, text, carret);
+        this.executePattern(RenpyPatterns.basePatterns as ExTokenRepoPattern, text, new Range(0, text.length), this.tokens.root);
+    }
+
+    private checkTokenTreeCoverage(root: TreeNode, matchRange: Range): { valid: boolean; gaps: Range[] } {
+        // Collect all token ranges
+        const tokenRanges = new Vector<Range>(root.count());
+        if (root.token) {
+            tokenRanges.pushBack(root.token.getRange());
+        }
+        root.forEach((node) => {
+            if (node.token) {
+                tokenRanges.pushBack(node.token.getRange());
+            }
+        });
+
+        // Sort the token ranges by their start position
+        tokenRanges.sort((a, b) => a.start - b.start);
+
+        // Check if the combined ranges of all tokens overlap the entire character range of the match
+        let currentEnd = matchRange.start;
+        const gaps: Range[] = [];
+        for (const range of tokenRanges) {
+            if (!matchRange.contains(range.start)) {
+                // The start of the next token range is outside the match range
+                return { valid: false, gaps };
+            }
+            if (range.start > currentEnd) {
+                // There is a gap between the current end position and the start of the next token range
+                gaps.push(new Range(currentEnd, range.start));
+            }
+            currentEnd = Math.max(currentEnd, range.end);
+        }
+        if (currentEnd < matchRange.end) {
+            // The last token range does not extend to the end of the match
+            gaps.push(new Range(currentEnd, matchRange.end));
+        }
+        return { valid: gaps.length === 0, gaps };
     }
 
     /**
@@ -190,159 +272,195 @@ class DocumentTokenizer {
      * @param match The match to apply the captures on
      * @param caret The reader head position within the document
      */
-    private applyCaptures(captures: TokenPatternCapture, match: RegExpExecArray, caret: TokenPosition) {
-        // TODO: Match 0 is like a second iteration on the previously matched text.
-        // What needs to happen is that all matches from the first iteration are merged with the matches from the second iteration.
-        const originalCaret = caret.clone();
+    private applyCaptures(captures: TokenPatternCapture, match: RegExpExecArray, source: string, parentNode: TreeNode) {
+        let rootNode = parentNode;
 
-        let lastMatchEnd = match.index;
-        for (let i = 1; i < match.indices!.length; i++) {
-            if (match.indices![i] === undefined) continue; // If the object at i is undefined, the capture is empty
+        if (captures[0] !== undefined) {
+            // If capture 0 is used, treat it as a wrapper token.
+            rootNode = new TreeNode();
+            parentNode.addChild(rootNode);
+        }
 
-            if (captures[i] === undefined) {
-                console.warn(`There is no pattern defined for capture group '${i}', on a pattern that matched '${match[i]}' near L:${caret.line + 1} C:${caret.character + 1}.\nThis should probably be added or be a non-capturing group.`);
-                continue;
+        for (let i = 1; i < match.indices!.length; i++) {
+            if (match.indices![i] === undefined) {
+                continue; // If the object at i is undefined, the capture is empty
             }
 
-            const p = captures[i];
-            const content = match[i];
-
-            // Update the position carets
             const [startPos, endPos] = match.indices![i];
 
-            // Check for missing characters in a match
-            const matchOffset = startPos - lastMatchEnd;
-            if (matchOffset !== 0) {
-                // TODO: Fix match 0 pattern capture to include the missing tokens
-                /*console.warn(
-                    `A capture was misaligned (expected: ${startPos}, got: ${lastMatchEnd}) on a pattern that matched '${content}' near L:${caret.line + 1} C:${
-                        caret.character + 1
-                    }.\nYou should probably update the pattern to capture everything.\nApplying a fix...`
-                );*/
-                caret.advance(matchOffset);
+            if (captures[i] === undefined) {
+                const pos = this.positionAt(startPos);
+                console.warn(`There is no pattern defined for capture group '${i}', on a pattern that matched '${match[i]}' near L:${pos.line + 1} C:${pos.character + 1}.\nThis should probably be added or be a non-capturing group.`);
+                continue;
             }
-            lastMatchEnd = endPos;
-
-            const startCaret = caret.clone();
-            const endCaret = caret.clone();
-            endCaret.advance(content.length); // Move caret to end of the current match
 
+            const p = captures[i];
+            const captureNode = new TreeNode();
             if (p.token) {
-                if (p.token === CharacterTokenType.NewLine) endCaret.nextLine();
-                this.tokens.pushBack(new Token(p.token, startCaret, endCaret));
+                captureNode.token = new Token(p.token, this.positionAt(startPos), this.positionAt(endPos));
             }
 
             if (p.patterns) {
-                const captureCaret = startCaret.clone();
-                this.executePattern(p as ExTokenRepoPattern, content, captureCaret);
-
-                assert(captureCaret.charStartOffset === endCaret.charStartOffset, "The token read position was misaligned by the capture context!");
-
-                if (captureCaret.line !== endCaret.line) {
-                    // Note: Moving the endCaret will also move the token, since this is a reference object
-                    endCaret.setValue(captureCaret);
-                }
+                this.executePattern(p as ExTokenRepoPattern, source, new Range(startPos, endPos), captureNode);
             }
 
-            caret.setValue(endCaret);
+            if (!captureNode.isEmpty()) {
+                rootNode.addChild(captureNode);
+            }
         }
-        // TODO: This also gets misaligned if the whole match is a token and contains additional captures
-        // TODO: The system should be updated to build a token list/tree. When that's done we can simply compare and merge the tokens instead of this hack.
-        // Special case for captures[0] which is the entire match
+
         if (captures[0] !== undefined) {
             const p = captures[0];
             const content = match[0];
 
-            const startCaret = originalCaret.clone();
-            const endCaret = originalCaret.clone();
-            endCaret.advance(content.length); // Move caret to end of the current match
+            const startPos = match.index;
+            const endPos = startPos + content.length;
 
             if (p.token) {
-                if (p.token === CharacterTokenType.NewLine) endCaret.nextLine();
-                this.tokens.pushBack(new Token(p.token, startCaret, endCaret));
+                rootNode.token = new Token(p.token, this.positionAt(startPos), this.positionAt(endPos));
             }
 
             if (p.patterns) {
-                const captureCaret = startCaret.clone();
-                this.executePattern(p as ExTokenRepoPattern, content, captureCaret);
-
-                assert(captureCaret.charStartOffset === endCaret.charStartOffset, "The token read position was misaligned by the capture context!");
+                const captureNode = new TreeNode();
+                rootNode.addChild(captureNode);
 
-                if (captureCaret.line !== endCaret.line) {
-                    // Note: Moving the endCaret will also move the token, since this is a reference object
-                    endCaret.setValue(captureCaret);
-                }
+                this.executePattern(p as ExTokenRepoPattern, source, new Range(startPos, endPos), captureNode);
             }
-
-            // TODO: For now assume that having the 0 capture, means all characters have tokens assigned
-            caret.setValue(endCaret);
         }
     }
 
-    private scanMatchPattern(pattern: ExTokenMatchPattern, text: string, matchOffsetStart: number, cache: Array<ScanResult | undefined>): ScanResult {
+    private scanMatchPattern(pattern: ExTokenMatchPattern, source: string, sourceStartOffset: number): MatchScanResult | null {
         const re = pattern.match;
-        re.lastIndex = matchOffsetStart;
-        const match = re.exec(text);
+        re.lastIndex = sourceStartOffset;
+        const match = re.exec(source);
         if (match) {
-            const result = { pattern: pattern, matchBegin: match };
-            cache[pattern._patternId] = result;
+            const result = { pattern, matchBegin: match };
             return result;
         }
 
-        cache[pattern._patternId] = null;
         return null;
     }
 
-    private scanRangePattern(next: ExTokenRangePattern, text: string, matchOffsetStart: number, cache: Array<ScanResult | undefined>): ScanResult {
-        const reBegin = next.begin;
-        reBegin.lastIndex = matchOffsetStart;
-        const matchBegin = reBegin.exec(text);
+    private scanRangePattern(pattern: ExTokenRangePattern, source: string, sourceStartOffset: number): RangeScanResult | null {
+        const reBegin = pattern.begin;
+        reBegin.lastIndex = sourceStartOffset;
+        const matchBegin = reBegin.exec(source);
 
         if (matchBegin) {
-            let reEnd = next.end;
+            return { pattern, matchBegin: matchBegin, matchEnd: null, expanded: false, contentMatches: null, source };
+        }
 
-            // Replace all back references in end source
-            if (next._hasBackref) {
-                let reEndSource = next.end.source;
+        return null;
+    }
 
-                this.backrefReplaceRe.lastIndex = 0;
-                reEndSource = reEndSource.replace(this.backrefReplaceRe, (_, g1) => {
-                    const content = matchBegin.at(parseInt(g1, 10));
-                    if (content !== undefined) return escapeRegExpCharacters(content);
-                    return "";
-                });
+    private expandRangeScanResult(result: RangeScanResult, cache: Array<ScanResult | undefined>) {
+        const p = result.pattern as ExTokenRangePattern;
+        const matchBegin = result.matchBegin;
 
-                reEnd = new RegExp(reEndSource, next.end.flags);
-            }
+        let reEnd = p.end;
+
+        // Replace all back references in end source
+        if (p._hasBackref) {
+            let reEndSource = p.end.source;
 
-            // Start end pattern after the last matched character in the begin pattern
-            reEnd.lastIndex = matchBegin.index + matchBegin[0].length;
-            const matchEnd = reEnd.exec(text);
+            this.backrefReplaceRe.lastIndex = 0;
+            reEndSource = reEndSource.replace(this.backrefReplaceRe, (_, g1) => {
+                const backref = matchBegin.at(parseInt(g1, 10));
+                if (backref !== undefined) {
+                    return escapeRegExpCharacters(backref);
+                }
+                return "";
+            });
 
-            if (matchEnd) {
-                const result = { pattern: next, matchBegin: matchBegin, matchEnd: matchEnd };
-                cache[next._patternId] = result;
-                return result;
+            reEnd = new RegExp(reEndSource, p.end.flags);
+        }
+
+        // Start end pattern after the last matched character in the begin pattern
+        reEnd.lastIndex = matchBegin.index + matchBegin[0].length;
+        let matchEnd = reEnd.exec(result.source);
+        const contentMatches = new Stack<ScanResult>();
+
+        if (matchEnd) {
+            // Check if any child pattern has content that would extend the currently determined end match
+            if (p._patternsRepo) {
+                const contentStartIndex = matchBegin.index + matchBegin[0].length;
+                const contentEndIndex = matchEnd.index;
+                const lastMatchedChar = matchEnd.index + matchEnd[0].length;
+
+                // Scan the content for any matches that would extend beyond the current end match
+                const tempCache = cloneCache(cache);
+                //const tempCache = new Array<ScanResult | undefined>(uniquePatternCount).fill(undefined);
+
+                for (let lastMatchIndex = contentStartIndex; lastMatchIndex < contentEndIndex; ) {
+                    const bestChildMatch = this.scanPattern(p._patternsRepo, result.source, lastMatchIndex, tempCache);
+                    if (!bestChildMatch) {
+                        break; // No more matches
+                    }
+
+                    // Update the last match index to the end of the child match, so the next scan starts after it
+                    const childMatchBegin = bestChildMatch.matchBegin;
+                    if (bestChildMatch.pattern._patternType === TokenPatternType.RangePattern) {
+                        const childMatchEnd = bestChildMatch.matchEnd!;
+                        lastMatchIndex = childMatchEnd.index + childMatchEnd[0].length;
+                    } else {
+                        lastMatchIndex = childMatchBegin.index + childMatchBegin[0].length;
+                    }
+
+                    // Check if the match starts after the currently determined end match start, if so we ignore it
+                    if (childMatchBegin.index >= contentEndIndex) {
+                        continue;
+                    }
+
+                    // To speed up the search, we can add any tokens that are within the content range
+                    contentMatches.push(bestChildMatch);
+
+                    // If the child match last char doesn't extend the current range, we can also ignore it
+                    if (lastMatchIndex <= lastMatchedChar) {
+                        continue;
+                    }
+
+                    // The child match is outside the range, so we should find a new end match
+                    reEnd.lastIndex = lastMatchIndex;
+                    matchEnd = reEnd.exec(result.source);
+
+                    // If no end match could be found, assume the whole pattern is invalid
+                    if (!matchEnd) {
+                        break;
+                    }
+                }
             }
         }
 
-        cache[next._patternId] = null;
-        return null;
+        if (!matchEnd) {
+            // If no end match could be found, we'll need to expand the range to the end of the source
+            const reLastChar = /$(?!\r\n|\r|\n)/g;
+            reLastChar.lastIndex = Math.max(0, result.source.length - 1);
+            matchEnd = reLastChar.exec(result.source);
+        }
+
+        result.matchEnd = matchEnd;
+        result.contentMatches = contentMatches;
+        result.expanded = true;
     }
 
     /**
      * Scans the text for the best matching pattern.
      * @param p The pattern to use for matches
-     * @param text The text to match on
-     * @param matchOffsetStart The character offset in 'text' to start the match at.
+     * @param source The text to match on
+     * @param sourceStartOffset The character offset in 'text' to start the match at.
      */
-    public scanPattern(p: ExTokenRepoPattern, text: string, matchOffsetStart: number, cache: Array<ScanResult | undefined>): ScanResult {
-        if (p.patterns.length === 0) return null;
+    public scanPattern(p: ExTokenRepoPattern, source: string, sourceStartOffset: number, cache: Array<ScanResult | undefined>): ScanResult {
+        if (p.patterns.length === 0) {
+            return null;
+        }
 
         const cachedP = cache[p._patternId];
         if (cachedP !== undefined) {
             // If the cached value is null, no match was found in the entire text
-            if (cachedP === null || cachedP.matchBegin.index >= matchOffsetStart) {
+            if (cachedP === null || cachedP.matchBegin.index >= sourceStartOffset) {
+                if (cachedP?.pattern._patternType === TokenPatternType.RangePattern && !cachedP.expanded) {
+                    this.expandRangeScanResult(cachedP as RangeScanResult, cache);
+                }
                 return cachedP;
             }
         }
@@ -362,28 +480,34 @@ class DocumentTokenizer {
             const cachedResult = cache[next._patternId];
             if (cachedResult !== undefined) {
                 // If the cached value is null, no match was found in the entire text
-                if (cachedResult === null) continue;
-                if (cachedResult.matchBegin.index >= matchOffsetStart) {
+                if (cachedResult === null) {
+                    continue;
+                }
+
+                if (cachedResult.matchBegin.index >= sourceStartOffset) {
                     scanResult = cachedResult;
                 }
             }
 
+            // The result wasn't cached or was invalidated, so we need to scan for the next match
             if (scanResult === null) {
                 switch (next._patternType) {
                     case TokenPatternType.MatchPattern:
-                        scanResult = this.scanMatchPattern(next, text, matchOffsetStart, cache);
+                        scanResult = this.scanMatchPattern(next, source, sourceStartOffset);
                         break;
                     case TokenPatternType.RangePattern:
-                        scanResult = this.scanRangePattern(next, text, matchOffsetStart, cache);
+                        scanResult = this.scanRangePattern(next, source, sourceStartOffset);
                         break;
                     case TokenPatternType.RepoPattern:
-                        scanResult = this.scanPattern(next, text, matchOffsetStart, cache);
-                        cache[next._patternId] = scanResult;
+                        scanResult = this.scanPattern(next, source, sourceStartOffset, cache);
                         break;
                     default:
                         assert(false, "Invalid TokenPatternType found! If this triggers, setupAndValidatePatterns() didn't assign the PatternStateProperties properly.");
                         break;
                 }
+
+                // Cache the result
+                cache[next._patternId] = scanResult;
             }
 
             if (!scanResult) continue;
@@ -398,195 +522,186 @@ class DocumentTokenizer {
             bestResult = scanResult;
 
             // If true, this match is valid at the first possible location. No need to check further.
-            if (bestMatchRating === matchOffsetStart) {
+            if (bestMatchRating === sourceStartOffset) {
                 break;
             }
         }
+
         cache[p._patternId] = bestResult;
+
+        if (bestResult?.pattern._patternType === TokenPatternType.RangePattern && !bestResult.expanded) {
+            this.expandRangeScanResult(bestResult as RangeScanResult, cache);
+        }
+
         return bestResult;
     }
 
+    private executeRangePattern(bestMatch: ScanResult, source: string, parentNode: TreeNode) {
+        if (!bestMatch) {
+            return;
+        }
+        assert(bestMatch.expanded, "A range pattern should always be expanded on execute.");
+
+        const p = bestMatch.pattern as ExTokenRangePattern;
+        const matchBegin = bestMatch.matchBegin;
+        const matchEnd = bestMatch.matchEnd;
+
+        const startPos = matchBegin.index;
+        const endPos = matchEnd!.index + matchEnd![0].length;
+        const contentStart = matchBegin.index + matchBegin[0].length;
+        const contentEnd = matchEnd!.index;
+
+        // p.token matches the whole range including the begin and end match content
+        const rangeNode = new TreeNode();
+        if (p.token) {
+            rangeNode.token = new Token(p.token, this.positionAt(startPos), this.positionAt(endPos));
+        }
+        // Begin captures are only applied to beginMatch[0] content
+        if (p.beginCaptures) {
+            this.applyCaptures(p.beginCaptures, matchBegin, source, rangeNode);
+        }
+
+        // Add an additional node for the content of the range pattern, since the content can be wrapped by an additional token
+        const contentNode = new TreeNode();
+
+        // p.contentToken matches the range 'between'; after the end of beginMatch and before the start of endMatch
+        if (p.contentToken) {
+            contentNode.token = new Token(p.contentToken, this.positionAt(contentStart), this.positionAt(contentEnd));
+        }
+
+        // Patterns are only applied on 'content' (see p.contentToken above)
+        if (p._patternsRepo) {
+            /*while (!bestMatch.contentMatches!.isEmpty()) {
+                const contentScanResult = bestMatch.contentMatches!.pop()!;
+                this.applyScanResult(contentScanResult, source, contentNode);
+            }*/
+
+            this.executePattern(p._patternsRepo, source, new Range(contentStart, matchEnd!.index), contentNode);
+        }
+
+        if (!contentNode.isEmpty()) {
+            rangeNode.addChild(contentNode);
+        }
+
+        // End captures are only applied to endMatch[0] content
+        if (p.endCaptures) {
+            this.applyCaptures(p.endCaptures, matchEnd!, source, rangeNode);
+        }
+
+        //assert(!rangeNode.isEmpty(), "A RangePattern must produce a valid token tree!");
+
+        const coverageResult = this.checkTokenTreeCoverage(rangeNode, new Range(startPos, endPos));
+        if (!coverageResult.valid) {
+            console.warn(`The token tree is not covering the entire match range!`);
+            for (const gap of coverageResult.gaps) {
+                const gapStartPos = this.document.positionAt(gap.start);
+                const gapEndPos = this.document.positionAt(gap.end);
+                const text = this.document.getText(new VSRange(gapStartPos, gapEndPos));
+                console.warn(`Gap from L${gapStartPos.line + 1}:${gapStartPos.character + 1} to L${gapEndPos.line + 1}:${gapEndPos.character + 1}, Text: '${text}'`);
+            }
+        }
+
+        parentNode.addChild(rangeNode);
+    }
+
+    private executeMatchPattern(bestMatch: MatchScanResult, source: string, parentNode: TreeNode) {
+        const p = bestMatch.pattern as ExTokenMatchPattern;
+        const match = bestMatch.matchBegin;
+
+        const contentNode = new TreeNode();
+        const startPos = match.index;
+        const endPos = startPos + match[0].length;
+
+        if (p.token) {
+            contentNode.token = new Token(p.token, this.positionAt(startPos), this.positionAt(endPos));
+        }
+
+        if (p.captures) {
+            this.applyCaptures(p.captures, match, source, contentNode);
+        }
+
+        const coverageResult = this.checkTokenTreeCoverage(contentNode, new Range(startPos, endPos));
+        if (!coverageResult.valid) {
+            console.warn(`The token tree is not covering the entire match range!`);
+            for (const gap of coverageResult.gaps) {
+                const gapStartPos = this.document.positionAt(gap.start);
+                const gapEndPos = this.document.positionAt(gap.end);
+                const text = this.document.getText(new VSRange(gapStartPos, gapEndPos));
+                console.warn(`Gap from L${gapStartPos.line + 1}:${gapStartPos.character + 1} to L${gapEndPos.line + 1}:${gapEndPos.character + 1}, Text: '${text}'`);
+            }
+        }
+
+        assert(p.token || p.captures, "A MatchPattern must have either a token or captures!");
+        assert(!contentNode.isEmpty(), "A MatchPattern must produce a valid token tree!");
+
+        parentNode.addChild(contentNode);
+    }
+
+    private applyScanResult(bestMatch: ScanResult, source: string, parentNode: TreeNode) {
+        const p = bestMatch!.pattern;
+        switch (p._patternType) {
+            case TokenPatternType.RangePattern:
+                this.executeRangePattern(bestMatch as RangeScanResult, source, parentNode);
+                break;
+            case TokenPatternType.MatchPattern:
+                this.executeMatchPattern(bestMatch as MatchScanResult, source, parentNode);
+                break;
+            default:
+                assert(false, "Should not get here!");
+                break;
+        }
+    }
+
     /**
      * Executes the pattern on 'text', adding tokens to the token list.
      * @param pattern The repo pattern to use for matches.
-     * @param text The text to match on.
+     * @param source The text to match on.
      * @param caret The location of the reader head
      * @returns True if the pattern was matched
      * @todo Timeout after it was running too long
      */
-    public executePattern(pattern: ExTokenRepoPattern, text: string, caret: TokenPosition) {
+    public executePattern(pattern: ExTokenRepoPattern, source: string, sourceRange: Range, parentNode: TreeNode) {
+        if (source.length === 0) {
+            return;
+        }
+
         const cache = new Array<ScanResult | undefined>(uniquePatternCount).fill(undefined);
-        const initialCharOffset = caret.charStartOffset;
-        const lastCharIndex = text.length;
+        const lastCharIndex = sourceRange.end;
 
-        for (let lastMatchIndex = 0; lastMatchIndex < lastCharIndex; ) {
-            const bestMatch = this.scanPattern(pattern, text, lastMatchIndex, cache);
+        let lastMatchIndex = sourceRange.start;
+        while (lastMatchIndex < lastCharIndex) {
+            const bestMatch = this.scanPattern(pattern, source, lastMatchIndex, cache);
 
-            if (bestMatch === null) {
+            if (bestMatch === null || bestMatch.matchBegin.index >= lastCharIndex) {
                 // No match was found in the remaining text. Break the loop
-                caret.advance(lastCharIndex - lastMatchIndex);
                 lastMatchIndex = lastCharIndex;
                 continue;
             }
+
             const failSafeIndex = lastMatchIndex; // Debug index to break in case of an infinite loop
 
-            const p = bestMatch.pattern;
-            switch (p._patternType) {
-                case TokenPatternType.RangePattern:
-                    {
-                        const matchBegin = bestMatch.matchBegin;
-                        const matchEnd = bestMatch.matchEnd!;
-                        lastMatchIndex = matchEnd.index + matchEnd[0].length;
-                        const contentLength = matchEnd.index - (matchBegin.index + matchBegin[0].length);
-
-                        // Check for missing characters in a match
-                        const matchOffset = initialCharOffset + matchBegin.index - caret.charStartOffset;
-                        if (matchOffset !== 0) {
-                            /*console.warn(
-                                `A range begin match was misaligned (expected: ${initialCharOffset + matchBegin.index}, got: ${caret.charStartOffset}) on pattern '${p.begin.source}' that matched '${matchBegin[0]}' near L:${caret.line + 1} C:${
-                                    caret.character + 1
-                                }.\nYou probably didn't catch all characters in the match or the match before this one.\nApplying a fix...`;
-                                caret.advance(matchOffset);
-                            );*/
-                        }
-
-                        const startCaret = caret.clone();
-
-                        const contentStartCaret = startCaret.clone();
-                        contentStartCaret.advance(matchBegin[0].length); // Move caret to end of beginMatch
-
-                        const contentEndCaret = contentStartCaret.clone();
-                        contentEndCaret.advance(contentLength); // Move caret to end of content
-
-                        const endCaret = contentEndCaret.clone();
-                        endCaret.advance(matchEnd[0].length); // Move caret to end of match
-
-                        // p.token matches the whole range including the begin and end match content
-                        if (p.token) {
-                            this.tokens.pushBack(new Token(p.token, startCaret, endCaret));
-                        }
-                        // Begin captures are only applied to beginMatch[0] content
-                        if (p.beginCaptures) {
-                            const captureCaret = startCaret.clone();
-                            this.applyCaptures(p.beginCaptures, matchBegin, captureCaret);
-
-                            assert(
-                                captureCaret.charStartOffset === contentStartCaret.charStartOffset,
-                                "The token read position was misaligned by the capture context! This means {p.beginCaptures} is not processing white spaces and new lines (individually!)."
-                            );
-
-                            if (captureCaret.line !== endCaret.line) {
-                                // Line was moved, all characters should reset to 0 and move by content length
-                                contentStartCaret.setValue(captureCaret);
-
-                                contentEndCaret.setValue(contentStartCaret);
-                                contentEndCaret.advance(contentLength); // Move caret to end of content
-
-                                // Note: Moving the endCaret will also move the token, since this is a reference object
-                                endCaret.setValue(contentEndCaret);
-                                endCaret.advance(matchEnd[0].length); // Move caret to end of match
-                            }
-                        }
-
-                        // p.contentToken matches the range 'between'; after the end of beginMatch and before the start of endMatch
-                        if (p.contentToken) {
-                            this.tokens.pushBack(new Token(p.contentToken, contentStartCaret, contentEndCaret));
-                        }
-
-                        // Patterns are only applied on 'content' (see p.contentToken above)
-                        if (p._patternsRepo) {
-                            const captureCaret = contentStartCaret.clone();
-                            const content = text.substring(matchBegin.index + matchBegin[0].length, matchEnd.index);
-                            this.executePattern(p._patternsRepo, content, captureCaret);
-
-                            assert(
-                                captureCaret.charStartOffset === contentEndCaret.charStartOffset,
-                                "The token read position was misaligned by the capture context! This means {p.patterns} is not processing white spaces and new lines (individually!)."
-                            );
-
-                            if (captureCaret.line !== endCaret.line) {
-                                // Line was moved, all characters should reset to 0 and move by content length
-                                contentEndCaret.setValue(captureCaret);
-
-                                // Note: Moving the endCaret will also move the token, since this is a reference object
-                                endCaret.setValue(contentEndCaret);
-                                endCaret.advance(matchEnd[0].length); // Move caret to end of match
-                            }
-                        }
-
-                        // End captures are only applied to endMatch[0] content
-                        if (p.endCaptures) {
-                            const captureCaret = contentEndCaret.clone();
-                            this.applyCaptures(p.endCaptures, matchEnd, captureCaret);
-
-                            assert(
-                                captureCaret.charStartOffset === endCaret.charStartOffset,
-                                "The token read position was misaligned by the capture context! This means {p.endCaptures} is not processing white spaces and new lines (individually!)."
-                            );
-
-                            if (captureCaret.line !== endCaret.line) {
-                                // Line was moved, all characters should reset to 0 and move by content length
-                                // Note: Moving the endCaret will also move the token, since this is a reference object
-                                endCaret.setValue(captureCaret);
-                            }
-                        }
-
-                        caret.setValue(endCaret);
-                    }
-                    break;
-                case TokenPatternType.MatchPattern:
-                    {
-                        const match = bestMatch.matchBegin;
-                        lastMatchIndex = match.index + match[0].length;
-
-                        // Check for missing characters in a match
-                        const matchOffset = initialCharOffset + match.index - caret.charStartOffset;
-                        if (matchOffset !== 0) {
-                            /*console.warn(
-                                `A match was misaligned (expected: ${initialCharOffset + match.index}, got: ${caret.charStartOffset}) on pattern '${p.match.source}' that matched '${match[0]}' near L:${caret.line + 1} C:${
-                                    caret.character + 1
-                                }.\nYou probably didn't catch all characters in the match or the match before this one.\nApplying a fix...`
-                            );*/
-                            caret.advance(matchOffset);
-                        }
-
-                        const startCaret = caret.clone();
-
-                        const endCaret = startCaret.clone();
-                        endCaret.advance(match[0].length); // Move carret to end of match
-
-                        if (p.token) {
-                            if (p.token === CharacterTokenType.NewLine) endCaret.nextLine();
-
-                            this.tokens.pushBack(new Token(p.token, startCaret, endCaret));
-                        }
-
-                        if (p.captures) {
-                            const captureCaret = startCaret.clone();
-                            this.applyCaptures(p.captures, match, captureCaret);
-
-                            assert(captureCaret.charStartOffset === endCaret.charStartOffset, "The token read position was misaligned by the capture context!");
-
-                            // Note: Moving the endCaret will also move the token, since this is a reference object
-                            if (captureCaret.line !== endCaret.line) {
-                                endCaret.setValue(captureCaret);
-                            }
-                        }
-
-                        caret.setValue(endCaret);
-                    }
-                    break;
-                default:
-                    assert(false, "Should not get here!");
-                    break;
+            if (bestMatch.pattern._patternType === TokenPatternType.RangePattern) {
+                assert(bestMatch.expanded, "A RangePattern must be expanded!");
+                const matchEnd = bestMatch.matchEnd!;
+                lastMatchIndex = matchEnd.index + matchEnd[0].length;
+            } else {
+                const matchBegin = bestMatch.matchBegin;
+                lastMatchIndex = matchBegin.index + matchBegin[0].length;
             }
 
+            this.applyScanResult(bestMatch, source, parentNode);
+
             if (failSafeIndex === lastMatchIndex) {
                 console.error("The loop has not advanced since the last cycle. This indicates a programming error. Breaking the loop!");
                 break;
             }
         }
     }
+
+    public positionAt(offset: number): TokenPosition {
+        const pos = this.document.positionAt(offset);
+        return new TokenPosition(pos.line, pos.character, offset);
+    }
 }
 
 // eslint-disable-next-line no-shadow
diff --git a/src/utilities/vector.ts b/src/utilities/vector.ts
index 158aa99..7182e8e 100644
--- a/src/utilities/vector.ts
+++ b/src/utilities/vector.ts
@@ -50,6 +50,17 @@ export class Vector<T> implements Iterable<T> {
         }
     }
 
+    /**
+     * Sort the vector using the specified comparison function
+     * @param compareFn The comparison function to use
+     */
+    public sort(compareFn: (a: T, b: T) => number) {
+        this.buffer.sort((a, b) => {
+            if (a === null || b === null) return 0;
+            return compareFn(a, b);
+        });
+    }
+
     /**
      * Get the item at the end of the vector, and remove it from the vector
      * @returns The item at the end
@@ -135,6 +146,12 @@ export class Vector<T> implements Iterable<T> {
         this.buffer[elementIndexA] = temp;
     }
 
+    public forEach(callback: (item: T) => void) {
+        for (let i = 0; i < this.itemCount; ++i) {
+            callback(this.buffer[i] as T);
+        }
+    }
+
     /**
      * Swap the item at the specified index with the item at the back of the vector
      * @param index The index of the item to swap to the back
diff --git a/syntax-to-token-pattern.py b/syntax-to-token-pattern.py
index 56719d0..7fd47f3 100644
--- a/syntax-to-token-pattern.py
+++ b/syntax-to-token-pattern.py
@@ -1,18 +1,17 @@
+from datetime import datetime
 import json
 import re
 from typing import Any
 
-PATTERN_PREFIX = "python#"
+from dataclasses import dataclass, field
 
-# load the input data from the file
-with open("./syntaxes/renpy.python.tmLanguage.json", "r") as file:
-    data = json.load(file)
-
-# get the repository value
-repository = data.get("repository", {})
-
-# Create an empty list to store the typescript strings
-typescript_entries: list[str] = []
+@dataclass
+class GeneratorState:
+    defined_variables: list[str] = field(default_factory=list[str])
+    used_token_types: list[str] = field(default_factory=list[str])
+    pattern_include_entries: list[str] = field(default_factory=list[str])
+    external_pattern_include_entries: list[str] = field(default_factory=list[str])
+    source_imports: list[str] = field(default_factory=list[str])
 
 def get_indent(indent: int) -> str:
     return " " * indent
@@ -21,48 +20,375 @@ def camelCase(st: str):
     output = ''.join(x for x in st.title() if x.isalnum())
     return output[0].lower() + output[1:]
 
-def get_token_type(name: str) -> str:
-    if "invalid." in name:
-        return "MetaTokenType.Invalid"
-    elif "storage.type.string." in name:
-        return "LiteralTokenType.String"
-
-    tokenPrefix = ""
-    token = name.replace(".python", "")
-
-    if "meta." in token:
-        tokenPrefix = "MetaTokenType."
-        token = token.replace("meta.", "")
-    elif "keyword." in token:
-        tokenPrefix = "KeywordTokenType."
-        token = token.replace("keyword.", "")
-    elif "entity." in token:
-        tokenPrefix = "EntityTokenType."
-        token = token.replace("entity.", "")
+def titleCase(st: str):
+    return ''.join(x for x in st.title() if x.isalnum())
+
+def convert_token_type_split(name: str) -> str:
+    token_parts = name.split(".")
+    if len(token_parts) <= 1:
+        return "Error"
+    
+    def get_part(index: int) -> str:
+        if index >= len(token_parts):
+            return ""
+        return token_parts[index]
+    
+    def get_parts(range: slice) -> str:
+        if range.start >= len(token_parts):
+            return ""
+        return ".".join(token_parts[range])
     
-    return "MetaTokenType.Invalid" # tokenPrefix + camelCase(token)
+    if get_part(0) == "string":
+        if get_part(1) == "quoted" and get_part(2) == "docstring":
+            return "MetaTokenType.Docstring"
+        else:
+            return "LiteralTokenType.String"
+
+    elif get_part(0) == "variable":
+        return "EntityTokenType.VariableName"
+
+    elif get_part(0) == "storage":
+        if get_part(1) == "type":
+            if get_part(2) == "string":
+                return "MetaTokenType.StringStorageType"
+            elif get_part(2) == "format":
+                return "MetaTokenType.FormatStorageType"
+            elif get_part(2) == "class":
+                return "KeywordTokenType.Class"
+            elif get_part(2) == "imaginary":
+                return "MetaTokenType.ImaginaryNumberStorageType"
+            elif get_part(2) == "number":
+                return "MetaTokenType.NumberStorageType"
+            elif get_part(2) == "function":
+                if get_part(3) == "lambda":
+                    return "KeywordTokenType.Lambda"
+                elif get_part(3) == "async":
+                    return "KeywordTokenType.Async"
+                elif get_part(3) == "label":
+                    return "KeywordTokenType.Label"
+                else:
+                    return "KeywordTokenType.Def"
+                
+        elif get_part(1) == "modifier":
+            if get_part(2) == "declaration":
+                return "KeywordTokenType." + titleCase(get_parts(slice(3, -1)))
+            elif get_part(2) == "flag":
+                return "MetaTokenType.ModifierFlagStorageType"
+            
+    elif get_part(0) == "constant":
+        if get_part(1) == "numeric":
+            if get_part(2) == "integer":
+                return "LiteralTokenType.Integer"
+            elif get_part(2) == "float":
+                return "LiteralTokenType.Float"
+            elif get_part(2) == "boolean":
+                return "LiteralTokenType.Boolean"
+            elif get_part(2) == "character":
+                return "LiteralTokenType.Character"
+            elif get_part(2) == "escape":
+                return "LiteralTokenType.Escape"
+            else:
+                return "MetaTokenType.ConstantNumeric"
+            
+        elif get_part(1) == "language":
+            return "MetaTokenType.ConstantLiteral"
+        
+        elif get_part(1) == "color":
+            return "LiteralTokenType.Color"
+
+        elif get_part(1) == "character":
+            if get_part(2) == "escape":
+                if get_part(3) == "python" or get_part(3) == "regexp":
+                    return "MetaTokenType.EscapeSequence"
+                else:
+                    return "EscapedCharacterTokenType.Esc" + titleCase(get_parts(slice(3, -2)))
+            
+            elif get_part(2) == "unicode":
+                return "MetaTokenType.EscapeSequence"
+
+            elif get_part(2) == "set":
+                return "MetaTokenType.CharacterSet"
+            
+            elif get_part(2) == "format" and get_part(3) == "placeholder":
+                return "MetaTokenType.Placeholder"
+                
+        
+        elif get_part(1) == "other":
+            return "MetaTokenType.ConstantCaps"
+
+    elif get_part(0) == "invalid":
+        if get_part(1) == "deprecated":
+            return "MetaTokenType.Deprecated"
+        else:
+            return "MetaTokenType.Invalid"
+        
+    elif get_part(0) == "punctuation":
+        if get_part(1) == "definition":
+            if get_part(2) == "tag" or get_part(2) == "dict" or get_part(2) == "inheritance":
+                if get_part(3) == "begin":
+                    return "CharacterTokenType.OpenBracket"
+                elif get_part(3) == "end":
+                    return "CharacterTokenType.CloseBracket"
+                elif get_part(3) == "region":
+                    return "MetaTokenType.CommentRegionTag"
+                
+            elif get_part(2) == "list":
+                if get_part(3) == "begin":
+                    return "CharacterTokenType.OpenSquareBracket"
+                elif get_part(3) == "end":
+                    return "CharacterTokenType.CloseSquareBracket"
+            
+            elif get_part(2) == "arguments" or get_part(2) == "parameters":
+                if get_part(3) == "begin":
+                    return "CharacterTokenType.OpenParentheses"
+                elif get_part(3) == "end":
+                    return "CharacterTokenType.CloseParentheses"
+
+            elif get_part(2) == "string":
+                if get_part(3) == "begin":
+                    return "MetaTokenType.StringBegin"
+                elif get_part(3) == "end":
+                    return "MetaTokenType.StringEnd"
+            
+            elif get_part(2) == "comment":
+                return "CharacterTokenType.Hashtag"
+            elif get_part(2) == "decorator":
+                return "CharacterTokenType.AtSymbol"
+        
+        elif get_part(1) == "parenthesis":
+            if get_part(2) == "begin":
+                return "CharacterTokenType.OpenParentheses"
+            elif get_part(2) == "end":
+                return "CharacterTokenType.CloseParentheses"
+            
+        elif get_part(1) == "bracket":
+            if get_part(2) == "begin":
+                return "CharacterTokenType.OpenBracket"
+            elif get_part(2) == "end":
+                return "CharacterTokenType.CloseBracket"
+            
+        elif get_part(1) == "square-bracket":
+            if get_part(2) == "begin":
+                return "CharacterTokenType.OpenSquareBracket"
+            elif get_part(2) == "end":
+                return "CharacterTokenType.CloseSquareBracket"
+            
+        elif get_part(1) == "section":
+            if (get_part(2) == "python" or get_part(2) =="block" or \
+                    get_part(2) == "class" or get_part(2) == "function" or \
+                    get_part(2) == "atl" or get_part(2) == "label" or \
+                    get_part(2) == "menu" or get_part(2) == "menu-option"):
+                if get_part(3) == "begin" or get_part(4) == "begin":
+                    return "CharacterTokenType.Colon"
+                
+        elif get_part(1) == "separator":
+            if get_part(2) == "parameters" or get_part(2) == "arguments" or get_part(2) == "element" or get_part(2) == "inheritance":
+                return "CharacterTokenType.Comma"
+            elif get_part(2) == "dict" or get_part(2) == "annotation" or get_part(2) == "slice":
+                return "CharacterTokenType.Colon"
+            elif get_part(2) == "continuation":
+                return "CharacterTokenType.Backslash"
+            elif get_part(2) == "key-value":
+                return "CharacterTokenType.EqualsSymbol"
+            else:
+                return "CharacterTokenType." + titleCase(get_part(2))
+            
+        elif get_part(1) == "character":
+            if get_part(2) == "set":
+                if get_part(3) == "begin":
+                    return "CharacterTokenType.OpenSquareBracket"
+                elif get_part(3) == "end":
+                    return "CharacterTokenType.CloseSquareBracket"
+        
+        elif get_part(1) == "comment":
+            if get_part(2) == "begin":
+                return "MetaTokenType.CommentBegin"
+            elif get_part(2) == "end":
+                return "MetaTokenType.CommentEnd"
+        
+        else:
+            return "CharacterTokenType." + titleCase(get_part(1))
+    
+    elif get_part(0) == "support":
+        if get_part(1) == "type":
+            if get_part(2) == "property-name":
+                return "EntityTokenType.PropertyName"
+            elif get_part(2) == "class":
+                return "EntityTokenType.ClassName"
+            elif get_part(2) == "function":
+                return "EntityTokenType.FunctionName"
+            elif get_part(2) == "variable":
+                return "EntityTokenType.VariableName"
+            elif get_part(2) == "namespace":
+                return "EntityTokenType.NamespaceName"
+            elif get_part(2) == "metaclass":
+                return "KeywordTokenType.Metaclass"
+            elif get_part(2) == "exception":
+                return "MetaTokenType.BuiltinExceptionType"
+            else:
+                return "MetaTokenType.BuiltinType"
+        
+        elif get_part(1) == "variable":
+            return "EntityTokenType.VariableName"
+
+        elif get_part(1) == "function":
+            if get_part(2) == "event":
+                return "EntityTokenType.EventName"
+            else:
+                return "EntityTokenType.FunctionName"
+            
+        elif get_part(1) == "other":
+            if get_part(2) == "match":
+                if get_part(3) == "any":
+                    return "CharacterTokenType.Period"
+                elif get_part(3) == "begin":
+                    return "CharacterTokenType.Caret"
+                elif get_part(3) == "end":
+                    return "CharacterTokenType.DollarSymbol"
+                
+            elif get_part(2) == "escape":
+                return "MetaTokenType.EscapeSequence"
+
+    elif get_part(0) == "comment":
+        if get_part(1) == "typehint":
+            return "MetaTokenType.Typehint" + titleCase(get_part(2))
+        else:
+            return "MetaTokenType.Comment"
+
+    elif get_part(0) == "keyword":
+        if get_part(1) == "operator":
+            if get_part(2) == "arithmetic":
+                if get_part(3) == "python" or get_part(3) == "renpy":
+                    return "MetaTokenType.ArithmeticOperator"
+                else:
+                    return "OperatorTokenType." + titleCase(get_part(3))
+            elif get_part(2) == "logical":
+                    return "MetaTokenType.LogicalOperatorKeyword"
+            elif get_part(2) == "bitwise":
+                    return "MetaTokenType.BitwiseOperatorKeyword"
+            elif get_part(2) == "comparison":
+                    return "MetaTokenType.ComparisonOperatorKeyword"
+            elif get_part(2) == "python":
+                    return "MetaTokenType.Operator"
+            elif get_part(2) == "unpacking":
+                return "OperatorTokenType." + titleCase(get_part(2))
+            else:
+                return "OperatorTokenType." + titleCase(get_parts(slice(2, -1)))
+        
+        elif get_part(1) == "codetag":
+            return "MetaTokenType.CommentCodeTag"
+        
+        elif get_part(1) == "control":
+            if get_part(2) == "flow":
+                if get_part(3) == "python" or get_part(3) == "renpy": # TODO
+                    return "MetaTokenType.ControlFlowKeyword"
+                else:
+                    return "KeywordTokenType." + titleCase(get_part(3))
+            elif get_part(2) == "import":
+                return "KeywordTokenType.Import"
+            elif get_part(2) == "conditional":
+                return "KeywordTokenType.If"
+        
+        elif get_part(1) == "illegal" and get_part(2) == "name":
+            return "MetaTokenType.Invalid"
+        else:
+            return "KeywordTokenType." + titleCase(get_parts(slice(1, -1)))
+
+    elif get_part(0) == "entity":
+        if get_part(1) == "name":
+            if get_part(2) == "type":
+                return "EntityTokenType." + titleCase(get_part(3)) + "Name"
+            else:
+                return "EntityTokenType." + titleCase(get_part(2)) + "Name"
+        
+        elif get_part(1) == "other":
+            if get_part(2) == "inherited-class":
+                return "EntityTokenType.InheritedClassName"
+
+    elif get_part(0) == "meta":
+        if get_part(1) == "embedded":
+            if get_part(2) == "block":
+                return "MetaTokenType.PythonBlock"
+            elif get_part(2) == "line":
+                return "MetaTokenType.PythonLine"
+            
+        elif get_part(1) == "arguments" or get_part(2) == "arguments" or get_part(3) == "arguments":
+            return "MetaTokenType.Arguments"
+        
+        elif get_part(1) == "function-call":
+            if get_part(2) == "label":
+                return "MetaTokenType.LabelCall"
+            else:
+                return "MetaTokenType.FunctionCall"
+            
+        elif get_part(1) == "member":
+            if get_part(2) == "access":
+                if get_part(3) == "label":
+                    return "MetaTokenType.LabelAccess"
+                else:
+                    return "MetaTokenType.MemberAccess"
+        
+        elif get_part(1) == "string":
+            if get_part(2) == "tag":
+                return "MetaTokenType.StringTag"
+            elif get_part(2) == "character":
+                return "MetaTokenType.CharacterNameString"
+            
+        elif (get_part(1) == "class" or get_part(1) == "function") and get_part(2) != "inheritance":
+            return "MetaTokenType." + titleCase(get_part(1)) + "Definition"
+
+        else:
+            return "MetaTokenType." + titleCase(get_parts(slice(1, -1)))
+
+    return "Error" + " /*Error: Could not convert token type*/"
+
+def get_token_type(state: GeneratorState, name: str) -> str:
+    token = name.split(" ")[-1] # Multi-tokens are not yet supported. For now assume the last token is the important one
+    token = convert_token_type_split(token)
+
+    import_token_type = token.split(".")[0]
+    if not import_token_type in state.used_token_types:
+        state.used_token_types.append(import_token_type)
+
+    return token.replace("Atl", "ATL") # Upper case ATL
 
 def get_match_str(match: str, hasCaptures: bool) -> str:
     match = match.replace("/", "\\/") # Escape forward slashes
+
+    iFlagSet = False
+    if "(?i)" in match:
+        iFlagSet = True
+        match = match.replace("(?i)", "")
+
+    match = match.replace("[:alpha:]", "a-zA-Z")
+    match = match.replace("[:alnum:]", "a-zA-Z0-9")
+    match = match.replace("[:upper:]", "A-Z")
+
+    iFlag: str = "i" if iFlagSet else ""
     mFlag: str = "m" if re.search("(?<!\\[)[\\^$]", match) != None else ""
     dFlag: str = "d" if hasCaptures else ""
-    return f"/{match}/{dFlag}g{mFlag}"
+    return f"/{match}/{dFlag}g{iFlag}{mFlag}"
 
-def transform_captures(indent: int, captures: dict[str, Any]) -> str:
+def transform_captures(state: GeneratorState, indent: int, captures: dict[str, Any], access_str: str) -> str:
     typescript_entry = "{\n"
     indent += 4
 
     for key, value in captures.items():
-        typescript_entry += f"{get_indent(indent)}{key}: {transform_pattern(indent, value)},\n"
+        capture_access_str = f"{access_str}[{key}]"
+        typescript_entry += f"{get_indent(indent)}{key}: {transform_pattern(state, indent, value, capture_access_str)},\n"
 
     indent -= 4
     typescript_entry += f"{get_indent(indent)}}},\n"
     return typescript_entry
 
-def transform_pattern(indent: int, value: dict[str, Any]) -> str:
+def transform_pattern(state: GeneratorState, indent: int, value: dict[str, Any], access_str: str) -> str:
     typescript_entry = "{\n"
     indent += 4
 
+    # Add debugName for patterns with regex
+    if "match" in value or "begin" in value or "end" in value:
+        typescript_entry += f"{get_indent(indent)}debugName: \"{access_str}\",\n\n"
+
     # Add comments
     if "comment" in value:
         comment = value["comment"].replace("\n", f"\n{get_indent(indent)}// ")
@@ -71,13 +397,13 @@ def transform_pattern(indent: int, value: dict[str, Any]) -> str:
     # Add token type
     if "name" in value:
         name = value["name"]
-        token = get_token_type(name)
-        typescript_entry += f"{get_indent(indent)}token: {token}, // {name}\n"
+        token = get_token_type(state, name)
+        typescript_entry += f"{get_indent(indent)}token: {token}, /*{name}*/\n"
 
     if "contentName" in value:
         name = value["contentName"]
-        token = get_token_type(name)
-        typescript_entry += f"{get_indent(indent)}contentToken: {token}, // {name}\n"
+        token = get_token_type(state, name)
+        typescript_entry += f"{get_indent(indent)}contentToken: {token}, /*{name}*/\n"
 
     # Add match
     if "match" in value:
@@ -87,7 +413,7 @@ def transform_pattern(indent: int, value: dict[str, Any]) -> str:
     # Iterate through the captures in the value
     if "captures" in value:
         typescript_entry += f"{get_indent(indent)}captures: "
-        typescript_entry += transform_captures(indent, value["captures"])
+        typescript_entry += transform_captures(state, indent, value["captures"], f"{access_str}.captures!")
 
     if "begin" in value:
         match = get_match_str(value["begin"], "beginCaptures" in value)
@@ -96,7 +422,7 @@ def transform_pattern(indent: int, value: dict[str, Any]) -> str:
     # Iterate through the beginCaptures in the value
     if "beginCaptures" in value:
         typescript_entry += f"{get_indent(indent)}beginCaptures: "
-        typescript_entry += transform_captures(indent, value["beginCaptures"])
+        typescript_entry += transform_captures(state, indent, value["beginCaptures"], f"{access_str}.beginCaptures!")
 
     if "end" in value:
         match = get_match_str(value["end"], "endCaptures" in value)
@@ -105,7 +431,7 @@ def transform_pattern(indent: int, value: dict[str, Any]) -> str:
     # Iterate through the endCaptures in the value
     if "endCaptures" in value:
         typescript_entry += f"{get_indent(indent)}endCaptures: "
-        typescript_entry += transform_captures(indent, value["endCaptures"])
+        typescript_entry += transform_captures(state, indent, value["endCaptures"], f"{access_str}.endCaptures!")
 
     # Iterate through the patterns in the value
     if "patterns" in value:
@@ -113,17 +439,85 @@ def transform_pattern(indent: int, value: dict[str, Any]) -> str:
         typescript_entry += f"{get_indent(indent)}patterns: [\n"
         indent += 4
 
+        includes: list[tuple[str, int]] = []
+        external_includes: list[tuple[str, int]] = []
+        last_pattern_index = 0
+
+        # Handle includes first to make sure they are pushed in the correct order
+        for i in range(len(patterns)):
+            pattern = patterns[i]
+
+            if "include" not in pattern:
+                last_pattern_index = i
+                continue
+
+            include: str = pattern["include"]
+
+            if include.startswith("source.renpy"):
+                include_parts = include.split("#")
+
+                source = include_parts[0]
+                reference = include_parts[1] if len(include_parts) > 1 else None
+
+                language = source.split(".")[-1]
+                language_accessor = titleCase(language) + "Patterns."
+
+                if reference == None:
+                    include = language_accessor + language
+                else:
+                    include = language_accessor + camelCase(reference)
+                
+                if language not in state.source_imports:
+                    state.source_imports.append(language)
+                
+                external_includes.append((include, i))
+            else:
+                include = camelCase(include)
+
+                # All includes that have not been defined yet, are pushed at the bottom of the file
+                if include not in state.defined_variables:
+                    includes.append((include, i))
+                else:
+                    last_pattern_index = i
+
+        # Add the includes to the list of includes
+        def process_includes(include_list: list[tuple[str, int]], entries_list: list[str]):
+            push_list: list[str] = []
+            for i in range(len(include_list)):
+                [include, index] = include_list[i]
+                if index < last_pattern_index: # 0 < 0
+                    entries_list.append(f"{access_str}.patterns!.splice({index}, 0, {include});")
+                else:
+                    push_list.append(include)
+
+            if len(push_list) > 0:
+                entries_list.append(f"{access_str}.patterns!.push({', '.join(push_list)});")
+
+        if len(includes) > 0:
+            process_includes(includes, state.pattern_include_entries)
+            last_pattern_index = includes[-1][1]
+
+        if len(external_includes) > 0:
+            process_includes(external_includes, state.external_pattern_include_entries)
+
+        # Now write the pattern source
         for i in range(len(patterns)):
             pattern = patterns[i]
 
             # Handle includes
             if "include" in pattern:
-                include = camelCase(PATTERN_PREFIX + pattern["include"])
-                typescript_entry += f"{get_indent(indent)}{include},\n"
+                include: str = pattern["include"]
+                if include.startswith("source.renpy"):
+                    continue
+
+                include = camelCase(include)
+                if include in state.defined_variables:
+                    typescript_entry += f"{get_indent(indent)}{include},\n"
+                
                 continue
 
             typescript_entry += get_indent(indent)
-            typescript_entry += transform_pattern(indent, pattern)
+            typescript_entry += transform_pattern(state, indent, pattern, f"{access_str}.patterns![{i}]")
             typescript_entry += ",\n"
 
         indent -= 4
@@ -133,22 +527,109 @@ def transform_pattern(indent: int, value: dict[str, Any]) -> str:
     typescript_entry += f"{get_indent(indent)}}}"
     return typescript_entry
 
-
-# Iterate through the repository entries
-for key, value in repository.items():
-    patternName = camelCase(PATTERN_PREFIX + key)
-    typescript_entry = f"export const {patternName}: TokenPattern = "
-
-    typescript_entry += transform_pattern(0, value)
+def generate_file(state: GeneratorState, source_file: str, output_file: str):
     
-    typescript_entry += ";\n"
 
-    # Add the typescript entry to the list of entries
-    typescript_entries.append(typescript_entry)
-
-# Write the typescript entries to a file
-with open("./src/tokenizer/generated.output.ts", "w") as file:
-    contents: str = "import { KeywordTokenType, LiteralTokenType, MetaTokenType } from \"./renpy-tokens\";\n"
-    contents += "import { TokenPattern } from \"./token-pattern-types\";\n\n"
-    contents += "\n".join(typescript_entries)
-    file.write(contents)
+    # load the input data from the file
+    with open(source_file, "r") as file:
+        data = json.load(file)
+    
+    # get the repository value
+    repository = data.get("repository", {})
+
+    # Iterate through the repository entries
+    src_lines: list[str] = []
+    for key, value in repository.items():
+        patternName = camelCase(key)
+
+        # Keep track of the defined variables to reduce the amount of variables we need to push later
+        state.defined_variables.append(patternName)
+
+        typescript_entry = f"export const {patternName}: TokenPattern = "
+
+        typescript_entry += transform_pattern(state, 0, value, patternName)
+        
+        typescript_entry += ";\n"
+
+        # Add the typescript entry to the list of entries
+        src_lines.append(typescript_entry)
+
+    # Write the typescript entries to a file
+    with open(output_file, "w") as file:
+        eslint_comments: list[str] = [
+            "/* eslint-disable no-useless-escape */",
+            "/* eslint-disable no-useless-backreference */",
+            "/* eslint-disable @typescript-eslint/no-non-null-assertion */",
+        ]
+        
+        contents: str = "\n".join(eslint_comments) + "\n\n"
+        contents += "// THIS FILE HAS BEEN GENERATED BY THE `syntax-to-token-pattern.py` GENERATOR\n"
+        contents += "// DO NOT EDIT THIS FILE DIRECTLY! INSTEAD RUN THE PYTHON SCRIPT.\n"
+        contents += "// ANY MANUAL EDITS MADE TO THIS FILE WILL BE OVERWRITTEN. YOU HAVE BEEN WARNED.\n"
+        contents += f"// Last generated: {datetime.utcnow().strftime('%d/%m/%Y %H:%M:%S')} (UTC+0)\n"
+        contents += "\n"
+
+        contents += f"import {{ {', '.join(state.used_token_types)} }} from \"./renpy-tokens\";\n"
+        contents += "import { TokenPattern } from \"./token-pattern-types\";\n\n"
+        contents += "\n".join(src_lines)
+
+        if len(state.pattern_include_entries) > 0:
+            contents += "\n// Push pattern references that were not defined on include\n"
+            contents += "\n".join(state.pattern_include_entries)
+
+        # Remove any newlines from the body of a single line array
+        contents = re.sub(r':\s*\[\n\s*([^,]*),\n?\s*\]', r': [\1]', contents, flags=re.MULTILINE)
+
+        # Remove any newlines from the body of a single line definition
+        contents = re.sub(r':\s*{\n\s*(.*)\n?\s*}', r': { \1 }', contents, flags=re.MULTILINE)
+
+        file.write(contents)
+
+def generate_token_patterns():
+    renpy_state = GeneratorState()
+    atl_state = GeneratorState()
+    python_state = GeneratorState()
+
+    generate_file(renpy_state, "./syntaxes/renpy.tmLanguage.json", "./src/tokenizer/renpy-token-patterns.g.ts")
+    generate_file(atl_state, "./syntaxes/renpy.atl.tmLanguage.json", "./src/tokenizer/atl-token-patterns.g.ts")
+    generate_file(python_state, "./syntaxes/renpy.python.tmLanguage.json", "./src/tokenizer/python-token-patterns.g.ts")
+
+    # Write the typescript entries to a file
+    output_file = "./src/tokenizer/token-patterns.g.ts"
+    with open(output_file, "w") as file:
+        contents = "/* eslint-disable @typescript-eslint/no-non-null-assertion */\n\n"
+        contents += "// THIS FILE HAS BEEN GENERATED BY THE `syntax-to-token-pattern.py` GENERATOR\n"
+        contents += "// DO NOT EDIT THIS FILE DIRECTLY! INSTEAD RUN THE PYTHON SCRIPT.\n"
+        contents += "// ANY MANUAL EDITS MADE TO THIS FILE WILL BE OVERWRITTEN. YOU HAVE BEEN WARNED.\n"
+        contents += f"// Last generated: {datetime.utcnow().strftime('%d/%m/%Y %H:%M:%S')} (UTC+0)\n"
+        contents += "\n"
+
+        # Add all source import from all states, but only the unique ones
+        source_imports = set(renpy_state.source_imports + atl_state.source_imports + python_state.source_imports)
+        
+        for source_import in source_imports:
+            contents += f"import * as {titleCase(source_import)}Patterns from \"./{source_import}-token-patterns.g\";\n"
+
+        def add_entries(entries: list[str], prefix: str) -> str:
+            contents = ""
+            if len(entries) > 0:
+                contents += f"\n// Push all {prefix} external includes\n"
+                for entry in entries:
+                    contents += f"{prefix}.{entry}\n"
+
+            return contents
+
+        contents += add_entries(renpy_state.external_pattern_include_entries, "RenpyPatterns")
+        contents += add_entries(atl_state.external_pattern_include_entries, "AtlPatterns")
+        contents += add_entries(python_state.external_pattern_include_entries, "PythonPatterns")
+
+        exports: list[str] = []
+        for source_import in source_imports:
+            exports.append(f"{titleCase(source_import)}Patterns")
+
+        contents += f"\n\nexport {{ {', '.join(exports)} }};"
+
+        file.write(contents)
+
+# main
+generate_token_patterns()
\ No newline at end of file
diff --git a/syntaxes/renpy.atl.tmLanguage.json b/syntaxes/renpy.atl.tmLanguage.json
new file mode 100644
index 0000000..c0e7ebd
--- /dev/null
+++ b/syntaxes/renpy.atl.tmLanguage.json
@@ -0,0 +1,333 @@
+{
+  "information_for_contributors": ["Please remeber to regenerate the ts token patterns using the 'syntax-to-token-pattern.py' python script"],
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "Ren'Py ATL",
+  "scopeName": "source.renpy.atl",
+  "patterns": [{ "include": "#atl" }],
+  "repository": {
+    "atl": {
+      "comment": "https://www.renpy.org/doc/html/atl.html#atl-syntax-and-semantics",
+      "patterns": [{ "include": "#atl-keywords" }, { "include": "#atl-blocks" }, { "include": "#atl-simple-expression" }, { "include": "#atl-warper" }, { "include": "#atl-event" }, { "include": "#atl-on" }, { "include": "#atl-function" }]
+    },
+    "atl-build-in-properties": {
+      "comment": "https://www.renpy.org/doc/html/atl.html#list-of-transform-properties",
+      "patterns": [
+        {
+          "comment": "Special manipulation keywords",
+          "match": "\\b(?<!\\.)(?:(warp)|(circles)|(clockwise)|(counterclockwise))\\b",
+          "captures": {
+            "1": { "name": "keyword.warp.renpy" },
+            "2": { "name": "keyword.circles.renpy" },
+            "3": { "name": "keyword.clockwise.renpy" },
+            "4": { "name": "keyword.counterclockwise.renpy" }
+          }
+        },
+        {
+          "comment": "position props (int, absolute, or a float)",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:xpos|ypos|xanchor|yanchor|xcenter|ycenter|radius)\\b"
+        },
+        {
+          "comment": "position pair props",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:pos|anchor|xycenter|around|alignaround|matrixanchor)\\b"
+        },
+        {
+          "comment": "float props",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:xalign|yalign|zoom|xzoom|yzoom|alpha|additive|angle|delay|events|zpos)\\b"
+        },
+        {
+          "comment": "float pair props",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:align|knot)\\b"
+        },
+        {
+          "comment": "int props",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:xoffset|yoffset|xtile|ytile)\\b"
+        },
+        {
+          "comment": "int pair props",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:offset)\\b"
+        },
+        {
+          "comment": "boolean props",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:rotate_pad|transform_anchor|nearest|crop_relative|subpixel|zzoom)\\b"
+        },
+        {
+          "comment": "('#float' | None)",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:rotate|xpan|ypan|blur)\\b"
+        },
+        {
+          "comment": "('#position' | None)",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:xsize|ysize)\\b"
+        },
+        {
+          "comment": "('\\(int, int, int, int\\)' | '\\(float, float, float, float\\)' | None)",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:crop)\\b"
+        },
+        {
+          "comment": "('\\(int, int\\)' | None)",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:corner1|corner2)\\b"
+        },
+        {
+          "comment": "('\\(position, position\\)' | None)",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:xysize)\\b"
+        },
+        {
+          "comment": "('#string' | None)",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:fit)\\b"
+        },
+        {
+          "comment": "('\\(int, int\\)' | None)",
+          "name": "invalid.deprecated.renpy",
+          "match": "\\b(?<!\\.)(?:size|maxsize)\\b"
+        },
+        {
+          "comment": "('#Matrix' | '#MatrixColor' | None)",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:matrixcolor)\\b"
+        },
+        {
+          "comment": "('#Matrix' | '#TransformMatrix' | None)",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:matrixtransform)\\b"
+        },
+        {
+          "comment": "('#bool' | '#float' | '\\(float, float, float\\)')",
+          "name": "support.type.property-name.transform.renpy",
+          "match": "\\b(?<!\\.)(?:perspective)\\b"
+        }
+      ]
+    },
+    "atl-simple-expression": {
+      "patterns": [
+        { "include": "source.renpy#expressions" },
+        { "include": "#atl-build-in-properties" },
+        { "include": "source.renpy.python#literal" },
+        { "include": "source.renpy.python#member-access" },
+        { "include": "source.renpy.python#illegal-operator" },
+        { "include": "source.renpy.python#operator" },
+        { "include": "source.renpy.python#curly-braces" },
+        { "include": "source.renpy.python#item-access" },
+        { "include": "source.renpy.python#list" },
+        { "include": "source.renpy.python#odd-function-call" },
+        { "include": "source.renpy.python#round-braces" },
+        { "include": "source.renpy.python#function-call" },
+        { "include": "source.renpy.python#builtin-functions" },
+        { "include": "source.renpy.python#builtin-types" },
+        { "include": "source.renpy.python#builtin-exceptions" },
+        { "include": "source.renpy.python#magic-names" },
+        { "include": "source.renpy.python#special-names" },
+        { "include": "source.renpy.python#illegal-names" },
+        { "include": "source.renpy.python#special-variables" },
+        { "include": "source.renpy.python#ellipsis" },
+        { "include": "source.renpy.python#punctuation" },
+        { "include": "source.renpy.python#line-continuation" }
+      ]
+    },
+    "atl-expression": {
+      "comment": "https://www.renpy.org/doc/html/atl.html#expression-statement",
+      "patterns": [
+        { "include": "#atl-simple-expression" },
+        {
+          "begin": "\\b(with)\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.with.renpy" }
+          },
+          "end": "$",
+          "patterns": [{ "include": "#atl-simple-expression" }]
+        },
+        { "include": "source.renpy.python#expression" }
+      ]
+    },
+    "atl-keywords": {
+      "patterns": [
+        {
+          "comment": "https://www.renpy.org/doc/html/atl.html#animation-statement",
+          "match": "^[ \\t]*(animation)\\b",
+          "captures": {
+            "1": { "name": "keyword.animation.renpy" }
+          }
+        },
+        {
+          "comment": "https://www.renpy.org/doc/html/atl.html#pass-statement",
+          "match": "^[ \\t]*(pass)\\b",
+          "captures": {
+            "1": { "name": "keyword.control.flow.pass.renpy" }
+          }
+        },
+        {
+          "comment": "https://www.renpy.org/doc/html/atl.html#repeat-statement and https://www.renpy.org/doc/html/atl.html#time-statement",
+          "begin": "^[ \\t]*(?:(repeat)|(time)|(pause))\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.control.flow.repeat.renpy" },
+            "2": { "name": "keyword.control.flow.time.renpy" },
+            "3": { "name": "keyword.control.flow.pause.renpy" }
+          },
+          "end": "$",
+          "patterns": [{ "include": "#atl-simple-expression" }]
+        },
+        {
+          "comment": "https://www.renpy.org/doc/html/atl.html#expression-statement",
+          "contentName": "meta.atl.with.renpy",
+          "begin": "^[ \\t]*(with)\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.with.renpy" }
+          },
+          "end": "$",
+          "patterns": [{ "include": "#atl-simple-expression" }]
+        },
+        {
+          "comment": "https://www.renpy.org/doc/html/atl.html#contains-statement",
+          "contentName": "meta.atl.contains.renpy",
+          "begin": "^[ \\t]*(contains)\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.control.flow.contains.renpy" }
+          },
+          "end": "$",
+          "patterns": [{ "include": "#atl-expression" }]
+        }
+      ]
+    },
+    "atl-blocks": {
+      "patterns": [
+        {
+          "comment": "See https://www.renpy.org/doc/html/atl.html",
+          "contentName": "meta.atl.block.renpy",
+          "begin": "^([ \\t]+)?(?:(block)|(parallel)|(contains))\\b[ \\t]*(:)",
+          "beginCaptures": {
+            "1": { "name": "punctuation.whitespace.leading.block.renpy" },
+            "2": { "name": "keyword.block.renpy" },
+            "3": { "name": "keyword.parallel.renpy" },
+            "4": { "name": "keyword.contains.renpy" },
+            "5": { "name": "punctuation.section.block.begin.renpy" }
+          },
+          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+          "patterns": [{ "include": "#atl" }]
+        },
+        {
+          "comment": "https://www.renpy.org/doc/html/atl.html#choice-statement",
+          "contentName": "meta.atl.choice.block.renpy",
+          "begin": "^([ \\t]+)?(choice)\\b[ \\t]*(.+)?(:)",
+          "beginCaptures": {
+            "1": { "name": "punctuation.whitespace.leading.block.renpy" },
+            "2": { "name": "keyword.choice.renpy" },
+            "3": { "patterns": [{ "include": "#atl-simple-expression" }] },
+            "4": { "name": "punctuation.section.block.begin.renpy" }
+          },
+          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+          "patterns": [{ "include": "#atl" }]
+        }
+      ]
+    },
+    "atl-build-in-events": {
+      "comment": "Pre-defined events (https://www.renpy.org/doc/html/atl.html#external-events)",
+      "name": "support.function.event.renpy",
+      "match": "\\b(?<!\\.)(?:start|show|replace|hide|replaced|update|hover|idle|selected_hover|selected_idle)\\b"
+    },
+    "atl-event-name": {
+      "patterns": [
+        { "include": "source.renpy.python#builtin-possible-callables" },
+        { "include": "#atl-build-in-events" },
+        {
+          "name": "entity.name.function.renpy meta.function-call.generic.renpy",
+          "match": "\\b([[:alpha:]_]\\w*)\\b"
+        }
+      ]
+    },
+    "atl-event-def-name": {
+      "patterns": [
+        { "include": "source.renpy.python#builtin-possible-callables" },
+        { "include": "#atl-build-in-events" },
+        {
+          "name": "entity.name.function.renpy",
+          "match": "\\b([[:alpha:]_]\\w*)\\b"
+        }
+      ]
+    },
+    "atl-event": {
+      "comment": "https://www.renpy.org/doc/html/atl.html#event-statement",
+      "name": "meta.atl.event.renpy",
+      "match": "^[ \\t]*(event)\\b[ \\t]*\\b([[:alpha:]_]\\w*)\\b",
+      "captures": {
+        "1": { "name": "keyword.event.renpy" },
+        "2": { "patterns": [{ "include": "#atl-event-name" }] }
+      }
+    },
+    "atl-on": {
+      "comment": "https://www.renpy.org/doc/html/atl.html#on-statement",
+      "contentName": "meta.atl.on.renpy",
+      "begin": "^([ \\t]+)?(on)\\b[ \\t]*(.+)?(:)",
+      "beginCaptures": {
+        "1": { "name": "punctuation.whitespace.leading.block.renpy" },
+        "2": { "name": "keyword.on.renpy" },
+        "3": {
+          "patterns": [
+            { "include": "#atl-event-name" },
+            {
+              "match": "[ \\t]*,[ \\t]*",
+              "name": "punctuation.separator.parameters.renpy"
+            },
+            { "include": "source.renpy#comments" }
+          ]
+        },
+        "4": { "name": "punctuation.section.block.begin.renpy" }
+      },
+      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+      "patterns": [{ "include": "#atl" }]
+    },
+    "atl-function": {
+      "comment": "https://www.renpy.org/doc/html/atl.html#function-statement",
+      "name": "meta.atl.function.renpy",
+      "match": "^[ \\t]*(function)\\b[ \\t]*\\b([[:alpha:]_]\\w*)\\b",
+      "captures": {
+        "1": { "name": "keyword.function.renpy" },
+        "2": {
+          "patterns": [
+            { "include": "source.renpy.python#builtin-possible-callables" },
+            {
+              "name": "entity.name.function.renpy meta.function-call.generic.renpy",
+              "match": "\\b([[:alpha:]_]\\w*)\\b"
+            }
+          ]
+        }
+      }
+    },
+    "atl-build-in-warpers": {
+      "comment": "Pre-defined warpers (https://www.renpy.org/doc/html/atl.html#warpers)",
+      "name": "support.function.renpy",
+      "match": "\\b(?<!\\.)(?:linear|ease|easein|easeout|ease_back|ease_bounce|ease_circ|ease_cubic|ease_elastic|ease_expo|ease_quad|ease_quart|ease_quint|easein_back|easein_bounce|easein_circ|easein_cubic|easein_elastic|easein_expo|easein_quad|easein_quart|easein_quint|easeout_back|easeout_bounce|easeout_circ|easeout_cubic|easeout_elastic|easeout_expo|easeout_quad|easeout_quart|easeout_quint)\\b"
+    },
+    "atl-warper-name": {
+      "patterns": [
+        { "include": "source.renpy.python#builtin-possible-callables" },
+        { "include": "#atl-build-in-warpers" },
+        { "include": "#atl-build-in-properties" },
+        {
+          "name": "entity.name.function.renpy meta.function-call.generic.renpy",
+          "match": "\\b([[:alpha:]_]\\w*)\\b"
+        }
+      ]
+    },
+    "atl-warper": {
+      "comment": "https://www.renpy.org/doc/html/atl.html#warpers",
+      "name": "meta.atl.warper.renpy",
+      "begin": "\\b(?<!\\.)([[:alpha:]_]\\w*)\\b[ \\t]*",
+      "beginCaptures": {
+        "1": { "patterns": [{ "include": "#atl-warper-name" }] }
+      },
+      "end": "(?!\\G)",
+      "patterns": [{ "include": "#atl-simple-expression" }]
+    }
+  }
+}
diff --git a/syntaxes/renpy.python.tmLanguage.json b/syntaxes/renpy.python.tmLanguage.json
index 3cd30da..091b55c 100644
--- a/syntaxes/renpy.python.tmLanguage.json
+++ b/syntaxes/renpy.python.tmLanguage.json
@@ -28,18 +28,22 @@
     "Once accepted there, we are happy to receive an update request.",
     "You can use the following regex to get rid of the newlines and spaces (?<=\"\\(\\?x\\).*)( (?![^\\[]*?\\]))|(?<!\\)\\n(?=.*?\")"
   ],
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
   "version": "https://github.com/MagicStack/MagicPython/commit/7d0f2b22a5ad8fccbd7341bc7b7a715169283044",
   "name": "Ren'Py Python",
   "scopeName": "source.renpy.python",
-  "patterns": [{ "include": "#statement" }, { "include": "#expression" }],
+  "patterns": [{ "include": "#python" }],
   "repository": {
+    "python": {
+      "patterns": [{ "include": "#statement" }, { "include": "#expression" }]
+    },
     "impossible": {
       "comment": "This is a special rule that should be used where no match is desired. It is not a good idea to match something like '1{0}' because in some cases that can result in infinite loops in token generation. So the rule instead matches and impossible expression to allow a match to fail and move to the next token.",
       "match": "$.^"
     },
     "statement": {
       "patterns": [
-        { "include": "#import" },
+        { "include": "#import-statement" },
         { "include": "#class-declaration" },
         { "include": "#function-declaration" },
         { "include": "#generator" },
@@ -64,13 +68,13 @@
           "name": "comment.line.number-sign.renpy",
           "match": "^[ \\t]*(#[ \\t]*(?:end)?region)\\b.*$",
           "captures": {
-            "1": { "name": "punctuation.definition.tag" }
+            "1": { "name": "punctuation.definition.tag.region" }
           }
         },
         {
           "name": "comment.line.number-sign.python",
           "contentName": "meta.typehint.comment.python",
-          "begin": "(?:\\#\\s*(type:)\\s*+(?#wewant`\\s*+`whichispossessivequantifiersincewedonotactuallywanttobacktrackwhenmatchingwhitespacehere)(?!$|\\#))",
+          "begin": "(?:\\#\\s*(type:)\\s*(?!$|\\#))",
           "end": "(?:$|(?=\\#))",
           "beginCaptures": {
             "0": { "name": "meta.typehint.comment.python" },
@@ -79,7 +83,7 @@
           "patterns": [
             {
               "name": "comment.typehint.ignore.notation.python",
-              "match": "\\Gignore(?=\\s*(?:$|\\#))"
+              "match": "ignore(?=\\s*(?:$|\\#))"
             },
             {
               "name": "comment.typehint.type.notation.python",
@@ -164,7 +168,7 @@
       "patterns": [{ "include": "#escape-sequence-unicode" }, { "include": "#escape-sequence" }, { "include": "#string-line-continuation" }]
     },
     "docstring-prompt": {
-      "match": "(?:(?:^|\\G)\\s*(?#'\\G'isnecessaryforST)((?:>>>|\\.\\.\\.)\\s)(?=\\s*\\S))",
+      "match": "(?:\\s*((?:>>>|\\.\\.\\.)\\s)(?=\\s*\\S))",
       "captures": {
         "1": { "name": "keyword.control.flow.python" }
       }
@@ -190,8 +194,11 @@
           "match": "\\b(?<!\\.)(async|continue|del|assert|break|finally|for|from|elif|else|if|except|pass|raise|return|try|while|with)\\b"
         },
         {
-          "name": "storage.modifier.declaration.python",
-          "match": "\\b(?<!\\.)(global|nonlocal)\\b"
+          "match": "\\b(?<!\\.)(?:(global)|(nonlocal))\\b",
+          "captures": {
+            "1": { "name": "storage.modifier.declaration.global.python" },
+            "2": { "name": "storage.modifier.declaration.nonlocal.python" }
+          }
         },
         {
           "name": "storage.type.class.python",
@@ -246,6 +253,7 @@
         { "include": "#member-access" },
         {
           "comment": "Tokenize identifiers to help linters",
+          "name": "variable.name.python",
           "match": "\\b([[:alpha:]_]\\w*)\\b"
         }
       ]
@@ -330,7 +338,7 @@
         },
         {
           "begin": "(\\\\)\\s*$\\n?",
-          "end": "(?=^\\s*$)|(?!(\\s*[rR]?(\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\"))|(\\G$)(?#'\\G'isnecessaryforST))",
+          "end": "(?=^\\s*$)|(?!(\\s*[rR]?(\\'\\'\\'|\\\"\\\"\\\"|\\'|\\\"))|((?<=\\\\\\s*)$))",
           "beginCaptures": {
             "1": { "name": "punctuation.separator.continuation.line.python" }
           },
@@ -343,7 +351,7 @@
       "match": "<<=|>>=|//=|\\*\\*=|\\+=|-=|/=|@=|\\*=|%=|~=|\\^=|&=|\\|=|=(?!=)"
     },
     "operator": {
-      "match": "\\b(?<!\\.)(?:(and|or|not|in|is)(?#1)|(for|if|else|await|(?:yield(?:\\s+from)?))(?#2))(?!\\s*:)\\b|(<<|>>|&|\\||\\^|~)(?#3)|(\\*\\*|\\*|\\+|-|%|//|/|@)(?#4)|(!=|==|>=|<=|<|>)(?#5)|(:=)(?#6)",
+      "match": "\\b(?<!\\.)(?:(and|or|not|in|is)|(for|if|else|await|(?:yield(?:\\s+from)?)))(?!\\s*:)\\b|(<<|>>|&|\\||\\^|~)|(\\*\\*|\\*|\\+|-|%|//|/|@)|(!=|==|>=|<=|<|>)|(:=)",
       "captures": {
         "1": { "name": "keyword.operator.logical.python" },
         "2": { "name": "keyword.control.flow.python" },
@@ -375,7 +383,6 @@
       ]
     },
     "number": {
-      "name": "constant.numeric.python",
       "patterns": [
         { "include": "#number-float" },
         { "include": "#number-dec" },
@@ -551,7 +558,7 @@
       "name": "invalid.illegal.brace.python",
       "match": "(}(?!}))"
     },
-    "import": {
+    "import-statement": {
       "comment": "Import statements used to correctly mark `from`, `import`, and `as`",
       "patterns": [
         {
@@ -754,7 +761,7 @@
     },
     "function-declaration": {
       "name": "meta.function.python",
-      "begin": "\\s*(?:\\b(async)\\s+)?\\b(def)\\s+(?=[[:alpha:]_][[:word:]]*\\s*\\()",
+      "begin": "\\s*(?:\\b(async)\\s+)?\\b(def)\\s+(?=\\w+\\s*\\()",
       "end": "(:|(?=[#'\"\\n]))",
       "beginCaptures": {
         "1": { "name": "storage.type.function.async.python" },
@@ -898,7 +905,7 @@
     "decorator": {
       "name": "meta.function.decorator.python",
       "begin": "^\\s*((@))\\s*(?=[[:alpha:]_]\\w*)",
-      "end": "(\\))#trailingwhitespaceandcommentsarelegal(?:(.*?)(?=\\s*(?:\\#|$)))|(?=\\n|\\#)",
+      "end": "(\\))(?:(.*?)(?=\\s*(?:\\#|$)))|(?=\\n|\\#)",
       "beginCaptures": {
         "1": { "name": "entity.name.function.decorator.python" },
         "2": { "name": "punctuation.definition.decorator.python" }
@@ -1028,7 +1035,7 @@
     },
     "builtin-types": {
       "name": "support.type.python",
-      "match": "(?<!\\.)\\b(bool|bytearray|bytes|classmethod|complex|dict|float|frozenset|int|list|object|property|set|slice|staticmethod|str|tuple|type(?#Although'super'isnotatype,it'srelatedtotypes,andisspecialenoughtobehighlighteddifferentlyfromotherbuilt-ins)|super)\\b"
+      "match": "(?<!\\.)\\b(bool|bytearray|bytes|classmethod|complex|dict|float|frozenset|int|list|object|property|set|slice|staticmethod|str|tuple|type|super)\\b"
     },
     "magic-function-names": {
       "comment": "these methods have magic interpretation by python and are generally calledindirectly through syntactic constructs",
@@ -1171,9 +1178,9 @@
       "name": "meta.backreference.named.regexp",
       "match": "(\\()(\\?P=\\w+(?:\\s+[[:alnum:]]+)?)(\\))",
       "captures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.backreference.named.begin.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.backreference.named.regexp" },
         "2": { "name": "entity.name.tag.named.backreference.regexp" },
-        "3": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.backreference.named.end.regexp" }
+        "3": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.backreference.named.regexp" }
       }
     },
     "regexp-flags": {
@@ -1275,12 +1282,12 @@
           "begin": "(\\[)(\\^)?(\\])?",
           "end": "(\\]|(?=\\'))|((?=(?<!\\\\)\\n))",
           "beginCaptures": {
-            "1": { "name": "punctuation.character.set.begin.regexp constant.other.set.regexp" },
+            "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": "punctuation.character.set.end.regexp constant.other.set.regexp" },
+            "1": { "name": "constant.other.set.regexp punctuation.character.set.end.regexp" },
             "2": { "name": "invalid.illegal.newline.python" }
           },
           "patterns": [
@@ -1298,11 +1305,11 @@
       "begin": "(\\()(\\?P<\\w+(?:\\s+[[:alnum:]]+)?>)",
       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.named.regexp" },
         "2": { "name": "entity.name.tag.named.group.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.named.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-one-regexp-expression" }]
@@ -1325,10 +1332,10 @@
       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookahead.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookahead.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookahead.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp" },
+        "1": { "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.end.lookahead.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-one-regexp-expression" }]
@@ -1338,10 +1345,10 @@
       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookahead.negative.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookahead.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookahead.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp" },
+        "1": { "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.end.lookahead.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-one-regexp-expression" }]
@@ -1351,10 +1358,10 @@
       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookbehind.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookbehind.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookbehind.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp" },
+        "1": { "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.end.lookbehind.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-one-regexp-expression" }]
@@ -1364,10 +1371,10 @@
       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookbehind.negative.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookbehind.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookbehind.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp" },
+        "1": { "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.end.lookbehind.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-one-regexp-expression" }]
@@ -1377,10 +1384,10 @@
       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.conditional.regexp" },
-        "1": { "name": "punctuation.parenthesis.conditional.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.conditional.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp" },
+        "1": { "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.end.conditional.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-one-regexp-expression" }]
@@ -1389,10 +1396,10 @@
       "begin": "\\(\\?:",
       "end": "(\\)|(?=\\'))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
-        "0": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp" }
+        "0": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.non-capturing.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.non-capturing.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-one-regexp-expression" }]
@@ -1437,12 +1444,12 @@
           "begin": "(\\[)(\\^)?(\\])?",
           "end": "(\\]|(?=\\'\\'\\'))",
           "beginCaptures": {
-            "1": { "name": "punctuation.character.set.begin.regexp constant.other.set.regexp" },
+            "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": "punctuation.character.set.end.regexp constant.other.set.regexp" },
+            "1": { "name": "constant.other.set.regexp punctuation.character.set.end.regexp" },
             "2": { "name": "invalid.illegal.newline.python" }
           },
           "patterns": [
@@ -1460,11 +1467,11 @@
       "begin": "(\\()(\\?P<\\w+(?:\\s+[[:alnum:]]+)?>)",
       "end": "(\\)|(?=\\'\\'\\'))",
       "beginCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.named.regexp" },
         "2": { "name": "entity.name.tag.named.group.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.named.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-three-regexp-expression" }, { "include": "#comments-string-single-three" }]
@@ -1487,10 +1494,10 @@
       "end": "(\\)|(?=\\'\\'\\'))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookahead.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookahead.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookahead.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp" },
+        "1": { "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.end.lookahead.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-three-regexp-expression" }, { "include": "#comments-string-single-three" }]
@@ -1500,10 +1507,10 @@
       "end": "(\\)|(?=\\'\\'\\'))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookahead.negative.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookahead.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookahead.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp" },
+        "1": { "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.end.lookahead.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-three-regexp-expression" }, { "include": "#comments-string-single-three" }]
@@ -1513,10 +1520,10 @@
       "end": "(\\)|(?=\\'\\'\\'))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookbehind.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookbehind.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookbehind.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp" },
+        "1": { "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.end.lookbehind.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-three-regexp-expression" }, { "include": "#comments-string-single-three" }]
@@ -1526,10 +1533,10 @@
       "end": "(\\)|(?=\\'\\'\\'))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookbehind.negative.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookbehind.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookbehind.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp" },
+        "1": { "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.end.lookbehind.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-three-regexp-expression" }, { "include": "#comments-string-single-three" }]
@@ -1539,10 +1546,10 @@
       "end": "(\\)|(?=\\'\\'\\'))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.conditional.regexp" },
-        "1": { "name": "punctuation.parenthesis.conditional.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.conditional.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp" },
+        "1": { "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.end.conditional.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-three-regexp-expression" }, { "include": "#comments-string-single-three" }]
@@ -1551,10 +1558,10 @@
       "begin": "\\(\\?:",
       "end": "(\\)|(?=\\'\\'\\'))",
       "beginCaptures": {
-        "0": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp" }
+        "0": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.non-capturing.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.non-capturing.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#single-three-regexp-expression" }, { "include": "#comments-string-single-three" }]
@@ -1598,12 +1605,12 @@
           "begin": "(\\[)(\\^)?(\\])?",
           "end": "(\\]|(?=\"))|((?=(?<!\\\\)\\n))",
           "beginCaptures": {
-            "1": { "name": "punctuation.character.set.begin.regexp constant.other.set.regexp" },
+            "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": "punctuation.character.set.end.regexp constant.other.set.regexp" },
+            "1": { "name": "constant.other.set.regexp punctuation.character.set.end.regexp" },
             "2": { "name": "invalid.illegal.newline.python" }
           },
           "patterns": [
@@ -1621,11 +1628,11 @@
       "begin": "(\\()(\\?P<\\w+(?:\\s+[[:alnum:]]+)?>)",
       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.named.regexp" },
         "2": { "name": "entity.name.tag.named.group.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.named.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-one-regexp-expression" }]
@@ -1648,10 +1655,10 @@
       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookahead.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookahead.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookahead.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp" },
+        "1": { "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.end.lookahead.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-one-regexp-expression" }]
@@ -1661,10 +1668,10 @@
       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookahead.negative.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookahead.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookahead.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp" },
+        "1": { "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.end.lookahead.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-one-regexp-expression" }]
@@ -1674,10 +1681,10 @@
       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookbehind.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookbehind.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookbehind.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp" },
+        "1": { "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.end.lookbehind.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-one-regexp-expression" }]
@@ -1687,10 +1694,10 @@
       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookbehind.negative.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookbehind.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookbehind.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp" },
+        "1": { "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.end.lookbehind.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-one-regexp-expression" }]
@@ -1700,10 +1707,10 @@
       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.conditional.regexp" },
-        "1": { "name": "punctuation.parenthesis.conditional.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.conditional.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp" },
+        "1": { "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.end.conditional.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-one-regexp-expression" }]
@@ -1712,10 +1719,10 @@
       "begin": "\\(\\?:",
       "end": "(\\)|(?=\"))|((?=(?<!\\\\)\\n))",
       "beginCaptures": {
-        "0": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp" }
+        "0": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.non-capturing.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.non-capturing.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-one-regexp-expression" }]
@@ -1760,12 +1767,12 @@
           "begin": "(\\[)(\\^)?(\\])?",
           "end": "(\\]|(?=\"\"\"))",
           "beginCaptures": {
-            "1": { "name": "punctuation.character.set.begin.regexp constant.other.set.regexp" },
+            "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": "punctuation.character.set.end.regexp constant.other.set.regexp" },
+            "1": { "name": "constant.other.set.regexp punctuation.character.set.end.regexp" },
             "2": { "name": "invalid.illegal.newline.python" }
           },
           "patterns": [
@@ -1783,11 +1790,11 @@
       "begin": "(\\()(\\?P<\\w+(?:\\s+[[:alnum:]]+)?>)",
       "end": "(\\)|(?=\"\"\"))",
       "beginCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.named.regexp" },
         "2": { "name": "entity.name.tag.named.group.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.named.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-three-regexp-expression" }, { "include": "#comments-string-double-three" }]
@@ -1810,10 +1817,10 @@
       "end": "(\\)|(?=\"\"\"))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookahead.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookahead.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookahead.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp" },
+        "1": { "name": "keyword.operator.lookahead.regexp punctuation.parenthesis.end.lookahead.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-three-regexp-expression" }, { "include": "#comments-string-double-three" }]
@@ -1823,10 +1830,10 @@
       "end": "(\\)|(?=\"\"\"))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookahead.negative.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookahead.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookahead.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp" },
+        "1": { "name": "keyword.operator.lookahead.negative.regexp punctuation.parenthesis.end.lookahead.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-three-regexp-expression" }, { "include": "#comments-string-double-three" }]
@@ -1836,10 +1843,10 @@
       "end": "(\\)|(?=\"\"\"))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookbehind.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookbehind.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookbehind.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp" },
+        "1": { "name": "keyword.operator.lookbehind.regexp punctuation.parenthesis.end.lookbehind.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-three-regexp-expression" }, { "include": "#comments-string-double-three" }]
@@ -1849,10 +1856,10 @@
       "end": "(\\)|(?=\"\"\"))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.lookbehind.negative.regexp" },
-        "1": { "name": "punctuation.parenthesis.lookbehind.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.lookbehind.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp" },
+        "1": { "name": "keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.end.lookbehind.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-three-regexp-expression" }, { "include": "#comments-string-double-three" }]
@@ -1862,10 +1869,10 @@
       "end": "(\\)|(?=\"\"\"))",
       "beginCaptures": {
         "0": { "name": "keyword.operator.conditional.regexp" },
-        "1": { "name": "punctuation.parenthesis.conditional.begin.regexp" }
+        "1": { "name": "punctuation.parenthesis.begin.conditional.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp" },
+        "1": { "name": "keyword.operator.conditional.negative.regexp punctuation.parenthesis.end.conditional.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-three-regexp-expression" }, { "include": "#comments-string-double-three" }]
@@ -1874,10 +1881,10 @@
       "begin": "\\(\\?:",
       "end": "(\\)|(?=\"\"\"))",
       "beginCaptures": {
-        "0": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp" }
+        "0": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.begin.non-capturing.regexp" }
       },
       "endCaptures": {
-        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp" },
+        "1": { "name": "support.other.parenthesis.regexp punctuation.parenthesis.end.non-capturing.regexp" },
         "2": { "name": "invalid.illegal.newline.python" }
       },
       "patterns": [{ "include": "#double-three-regexp-expression" }, { "include": "#comments-string-double-three" }]
@@ -2144,7 +2151,7 @@
       "beginCaptures": {
         "1": { "name": "invalid.illegal.prefix.python" },
         "2": { "name": "string.interpolated.python string.quoted.single.python storage.type.string.python" },
-        "3": { "name": "punctuation.definition.string.begin.python string.quoted.single.python" }
+        "3": { "name": "string.quoted.single.python punctuation.definition.string.begin.python" }
       },
       "endCaptures": {
         "1": { "name": "punctuation.definition.string.end.python string.interpolated.python string.quoted.single.python" },
@@ -2158,7 +2165,7 @@
       "end": "(\\2)|((?<!\\\\)\\n)",
       "beginCaptures": {
         "1": { "name": "string.interpolated.python string.quoted.raw.single.python storage.type.string.python" },
-        "2": { "name": "punctuation.definition.string.begin.python string.quoted.raw.single.python" }
+        "2": { "name": "string.quoted.raw.single.python punctuation.definition.string.begin.python" }
       },
       "endCaptures": {
         "1": { "name": "punctuation.definition.string.end.python string.interpolated.python string.quoted.raw.single.python" },
@@ -2168,11 +2175,11 @@
     },
     "fstring-single-core": {
       "name": "string.interpolated.python string.quoted.single.python",
-      "match": "(.+?)((?#.*and.*?inmulti-linematchneedspecialhandlingofnewlinesotherwiseSublimeTextandAtomwillmatchslightlydifferently.Theguardfornewlineshastobeseparatefromthelookaheadbecauseofspecial$matchingrule.)($\\n?)|(?=[\\\\\\}\\{]|(['\"])|((?<!\\\\)\\n)))(?#duetohowmultilineregexpsarematchedweneedaspecialcaseformatchinganewlinecharacter)|\\n"
+      "match": "(.+?)(($\\n?)|(?=[\\\\\\}\\{]|(['\"])|((?<!\\\\)\\n)))|\\n"
     },
     "fstring-raw-single-core": {
       "name": "string.interpolated.python string.quoted.raw.single.python",
-      "match": "(.+?)((?#.*and.*?inmulti-linematchneedspecialhandlingofnewlinesotherwiseSublimeTextandAtomwillmatchslightlydifferently.Theguardfornewlineshastobeseparatefromthelookaheadbecauseofspecial$matchingrule.)($\\n?)|(?=[\\\\\\}\\{]|(['\"])|((?<!\\\\)\\n)))(?#duetohowmultilineregexpsarematchedweneedaspecialcaseformatchinganewlinecharacter)|\\n"
+      "match": "(.+?)(($\\n?)|(?=[\\\\\\}\\{]|(['\"])|((?<!\\\\)\\n)))|\\n"
     },
     "fstring-single-brace": {
       "comment": "value interpolation using { ... }",
@@ -2272,7 +2279,7 @@
       "beginCaptures": {
         "1": { "name": "invalid.illegal.prefix.python" },
         "2": { "name": "string.interpolated.python string.quoted.multi.python storage.type.string.python" },
-        "3": { "name": "punctuation.definition.string.begin.python string.quoted.multi.python" }
+        "3": { "name": "string.quoted.multi.python punctuation.definition.string.begin.python" }
       },
       "endCaptures": {
         "1": { "name": "punctuation.definition.string.end.python string.interpolated.python string.quoted.multi.python" },
@@ -2286,7 +2293,7 @@
       "end": "(\\2)",
       "beginCaptures": {
         "1": { "name": "string.interpolated.python string.quoted.raw.multi.python storage.type.string.python" },
-        "2": { "name": "punctuation.definition.string.begin.python string.quoted.raw.multi.python" }
+        "2": { "name": "string.quoted.raw.multi.python punctuation.definition.string.begin.python" }
       },
       "endCaptures": {
         "1": { "name": "punctuation.definition.string.end.python string.interpolated.python string.quoted.raw.multi.python" },
@@ -2296,11 +2303,11 @@
     },
     "fstring-multi-core": {
       "name": "string.interpolated.python string.quoted.multi.python",
-      "match": "(.+?)((?#.*and.*?inmulti-linematchneedspecialhandlingofnewlinesotherwiseSublimeTextandAtomwillmatchslightlydifferently.Theguardfornewlineshastobeseparatefromthelookaheadbecauseofspecial$matchingrule.)($\\n?)|(?=[\\\\\\}\\{]|'''|\"\"\"))(?#duetohowmultilineregexpsarematchedweneedaspecialcaseformatchinganewlinecharacter)|\\n"
+      "match": "(.+?)(($\\n?)|(?=[\\\\\\}\\{]|'''|\"\"\"))|\\n"
     },
     "fstring-raw-multi-core": {
       "name": "string.interpolated.python string.quoted.raw.multi.python",
-      "match": "(.+?)((?#.*and.*?inmulti-linematchneedspecialhandlingofnewlinesotherwiseSublimeTextandAtomwillmatchslightlydifferently.Theguardfornewlineshastobeseparatefromthelookaheadbecauseofspecial$matchingrule.)($\\n?)|(?=[\\\\\\}\\{]|'''|\"\"\"))(?#duetohowmultilineregexpsarematchedweneedaspecialcaseformatchinganewlinecharacter)|\\n"
+      "match": "(.+?)(($\\n?)|(?=[\\\\\\}\\{]|'''|\"\"\"))|\\n"
     },
     "fstring-multi-brace": {
       "comment": "value interpolation using { ... }",
diff --git a/syntaxes/renpy.tmLanguage.json b/syntaxes/renpy.tmLanguage.json
index 765bb56..9c24c3b 100644
--- a/syntaxes/renpy.tmLanguage.json
+++ b/syntaxes/renpy.tmLanguage.json
@@ -1,850 +1,604 @@
 {
-  "information_for_contributors": ["Any changes made to this file should be ported over to token-patterns.ts"],
+  "information_for_contributors": ["Please remember to regenerate the ts token patterns using the 'syntax-to-token-pattern.py' python script"],
   "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
   "name": "Ren'Py",
   "scopeName": "source.renpy",
-  "patterns": [{ "include": "#statements" }, { "include": "#expressions" }],
+  "patterns": [{ "include": "#base-patterns" }],
   "repository": {
     "statements": {
       "patterns": [{ "include": "#renpy-statements" }, { "include": "#python-statements" }, { "include": "#keywords" }, { "include": "#say-statements" }]
     },
     "expressions": {
-      "patterns": [{ "include": "#comments" }, { "include": "#strings" }, { "include": "#literal" }]
+      "patterns": [{ "include": "#comments" }, { "include": "#strings" }, { "include": "#literal" }, { "include": "#fallback-characters" }]
+    },
+    "invalid-token": {
+      "match": ".+",
+      "name": "invalid.unknown.token.renpy"
+    },
+    "new-line": {
+      "match": "\\r\\n|\\r|\\n",
+      "name": "punctuation.new-line.renpy"
+    },
+    "whitespace": {
+      "match": "[ \\t]+",
+      "name": "punctuation.whitespace.renpy"
+    },
+    "fallback-characters": {
+      "comment": "NOTE: Having these patterns separated increases performance. Benchmark before making a change!",
+      "patterns": [
+        { "include": "#new-line" },
+        { "include": "#whitespace" },
+        {
+          "name": "punctuation.parenthesis.begin.renpy",
+          "match": "\\("
+        },
+        {
+          "name": "punctuation.parenthesis.end.renpy",
+          "match": "\\)"
+        },
+
+        {
+          "name": "punctuation.bracket.begin.renpy",
+          "match": "{"
+        },
+        {
+          "name": "punctuation.bracket.end.renpy",
+          "match": "}"
+        },
+
+        {
+          "name": "punctuation.square-bracket.begin.renpy",
+          "match": "\\["
+        },
+        {
+          "name": "punctuation.square-bracket.end.renpy",
+          "match": "\\]"
+        },
+
+        {
+          "name": "punctuation.period.renpy",
+          "match": "\\."
+        },
+        {
+          "name": "punctuation.colon.renpy",
+          "match": ":"
+        },
+        {
+          "name": "punctuation.semicolon.renpy",
+          "match": ";"
+        },
+        {
+          "name": "punctuation.comma.renpy",
+          "match": ","
+        },
+        {
+          "name": "punctuation.hashtag.renpy",
+          "match": "#"
+        },
+
+        {
+          "name": "punctuation.quote.renpy",
+          "match": "'"
+        },
+        {
+          "name": "punctuation.double-quote.renpy",
+          "match": "\""
+        },
+        {
+          "name": "punctuation.back-quote.renpy",
+          "match": "`"
+        },
+
+        {
+          "name": "punctuation.backslash.renpy",
+          "match": "\\\\"
+        },
+        {
+          "name": "punctuation.forward-slash.renpy",
+          "match": "/"
+        },
+
+        {
+          "name": "punctuation.equals-symbol.renpy",
+          "match": "="
+        },
+
+        {
+          "name": "debug.invalid.illegal.unmatched.renpy",
+          "match": "\\b\\w+\\b"
+        },
+        {
+          "name": "punctuation.unknown.renpy",
+          "match": "."
+        }
+      ]
     },
 
+    "literal": {
+      "patterns": [
+        {
+          "comment": "Python literals",
+          "name": "constant.language.renpy",
+          "match": "\\b(?<!\\.)(True|False|None)\\b"
+        }
+      ]
+    },
     "num-float": {
       "match": "(?<!\\w)(?:\\.[0-9]*|[0-9]*\\.[0-9]*|[0-9]*\\.)\\b",
       "name": "constant.numeric.float.renpy"
     },
     "num-int": {
       "match": "(?<![\\w.])(?:[1-9]*|0+|0([0-9]+)(?![eE.]))\\b",
-      "name": "constant.numeric.dec.renpy",
+      "name": "constant.numeric.integer.renpy",
       "captures": {
-        "1": { "name": "invalid.illegal.dec.renpy" }
+        "1": { "name": "invalid.illegal.integer.renpy" }
       }
     },
 
-    "python-statements": {
+    "keywords": {
+      "comment": "Fallback patterns for unmatched keywords",
       "patterns": [
         {
-          "match": "^[ \\t]*(init)[ \\t]+(offset)[ \\t]*(=)[ \\t]*(-)?([^#]*)",
-          "captures": {
-            "1": { "name": "keyword.renpy" },
-            "2": { "name": "keyword.renpy" },
-            "3": { "name": "keyword.operator.assignment.renpy" },
-            "4": { "name": "keyword.operator.arithmetic.renpy" },
-            "5": {
-              "patterns": [
-                { "include": "#num-int" },
-                {
-                  "match": ".*",
-                  "name": "invalid.illegal.dec.renpy"
-                }
-              ]
-            }
-          }
+          "comment": "Control flow keywords",
+          "name": "keyword.control.flow.renpy",
+          "match": "\\b(?<!\\.)(?:pass|return|pause)\\b"
         },
         {
-          "comment": "Renpy python block",
-          "contentName": "meta.embedded.block.python",
-          "begin": "^([ \\t]+)?(?:(init)(?:[ \\t]+(-)?(\\d+))?[ \\t]+)?(python)[ \\t]*(.*)?(:)",
+          "comment": "Control flow keywords with block",
+          "begin": "\\b(?<!\\.)(?:(if|elif|else)|(for|while))\\b",
+          "contentName": "meta.embedded.line.python",
           "beginCaptures": {
-            "1": { "name": "punctuation.whitespace.embedded.leading.renpy" },
-            "2": { "name": "keyword.renpy" },
-            "3": { "name": "keyword.operator.arithmetic.renpy" },
-            "4": { "name": "constant.numeric.dec.renpy" },
-            "5": { "name": "keyword.renpy" },
-            "6": {
-              "name": "meta.python.block.arguments.renpy",
-              "patterns": [
-                {
-                  "comment": "in statement",
-                  "match": "(?:\\s*(in)\\s*([a-zA-Z_]\\w*)\\b)",
-                  "captures": {
-                    "1": { "name": "keyword.renpy" },
-                    "2": { "name": "entity.name.namespace" }
-                  }
-                },
-                {
-                  "comment": "keywords",
-                  "match": "\\b(hide|early|in)\\b",
-                  "name": "keyword.renpy"
-                }
-              ]
-            },
-            "7": { "name": "punctuation.section.python.begin.renpy" }
+            "1": { "name": "keyword.control.conditional.renpy" },
+            "2": { "name": "keyword.control.flow.renpy" }
           },
-          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-          "patterns": [{ "include": "source.renpy.python" }]
+          "end": ":|$",
+          "endCaptures": {
+            "0": { "name": "punctuation.section.block.begin.renpy" }
+          },
+          "patterns": [{ "include": "#expressions" }, { "include": "source.renpy.python#expression" }]
         },
         {
-          "comment": "Match begin and end of python one line statements",
-          "contentName": "meta.embedded.line.python",
-          "begin": "^[ \\t]*(\\$|define|default)(?=[ \\t])",
-          "beginCaptures": {
-            "1": { "name": "keyword.renpy" }
-          },
-          "end": "\\R$",
-          "patterns": [
-            {
-              "comment": "Type the first name as a variable (Probably not needed, but python doesn't seem to catch it)",
-              "match": "(?<!\\.)\\b([a-zA-Z_]\\w*)(?=\\s=\\s)",
-              "name": "variable.other.renpy"
-            },
-            { "include": "source.renpy.python#expression" }
-          ]
+          "comment": "Python statement keywords",
+          "match": "\\b(?<!\\.)(define|default|early|hide|in|init|python)\\b",
+          "name": "keyword.other.python.renpy"
+        },
+        {
+          "comment": "Renpy keywords",
+          "match": "\\b(?<!\\.)(?:camera|image|label|layeredimage|menu|nvl[ \\t]+clear|play|queue|scene|screen|show|transform|translate|voice(?:[ \\t]+sustain)?|window|frame)\\b",
+          "name": "keyword.other.renpy"
+        },
+        {
+          "comment": "[TODO: Should probably only be a keyword in the expression] Renpy sub expression keywords",
+          "name": "keyword.other.renpy",
+          "match": "\\b(?<!\\.)(?:set|expression|at|with|from)\\b"
         }
       ]
     },
-    "renpy-statements": {
+    "comments": {
       "patterns": [
-        { "include": "#label" },
-        { "include": "#menu" },
-        { "include": "#image" },
-        { "include": "#audio" },
-        { "include": "#transform" },
-        { "include": "#scene" },
-        { "include": "#camera" },
-        { "include": "#show" },
-        { "include": "#with" },
-        { "include": "#style-old" },
-        { "include": "#use-old" },
-        { "include": "#screen" },
-        { "include": "#return-statements" },
-        { "include": "#jump" },
-        { "include": "#call" }
-      ]
-    },
-    "transform": {
-      "begin": "^([ \\t]+)?(transform)\\b[ \\t]*(.*)?(:)",
-      "beginCaptures": {
-        "1": { "name": "punctuation.whitespace.leading.renpy" },
-        "2": { "name": "keyword.renpy" },
-        "3": {
-          "patterns": [
-            {
-              "name": "variable.name.transform.renpy",
-              "match": "\\b([[:alpha:]_]\\w*)\\b"
-            }
-          ]
+        {
+          "name": "comment.line.number-sign.renpy",
+          "match": "(?<=^[ \\t]*)(#[ \\t]*(?:end)?region)\\b.*$",
+          "captures": {
+            "1": { "name": "punctuation.definition.tag.region" }
+          }
         },
-        "4": { "name": "punctuation.section.atl.begin.renpy" }
-      },
-      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-      "patterns": [{ "include": "#atl" }]
-    },
-    "at": {
-      "name": "meta.at.renpy",
-      "match": "\\b(at)\\b[ \\t]*(.+)?",
-      "captures": {
-        "1": { "name": "keyword.renpy" },
-        "2": {
-          "name": "meta.at.params.renpy",
-          "patterns": [{ "include": "#statements" }]
-        }
-      }
-    },
-    "as": {
-      "name": "meta.as.renpy",
-      "match": "\\b(as)\\b[ \\t]*(.+)?",
-      "captures": {
-        "1": { "name": "keyword.renpy" },
-        "2": {
-          "name": "meta.as.params.renpy",
-          "patterns": [{ "include": "#statements" }]
-        }
-      }
-    },
-    "with": {
-      "name": "meta.with.renpy",
-      "match": "\\b(with)\\b[ \\t]*(.+)?",
-      "captures": {
-        "1": { "name": "keyword.renpy" },
-        "2": {
-          "name": "meta.with.params.renpy",
-          "patterns": [{ "include": "#expressions" }]
+        {
+          "name": "comment.line.number-sign.renpy",
+          "match": "(#)(.*)$",
+          "captures": {
+            "1": { "name": "punctuation.definition.comment.renpy" },
+            "2": {
+              "patterns": [
+                {
+                  "comment": "Code Tags",
+                  "match": "(?:\\b(NOTE|XXX|HACK|FIXME|BUG|TODO)\\b)",
+                  "captures": {
+                    "1": { "name": "keyword.codetag.notation.renpy" }
+                  }
+                }
+              ]
+            }
+          }
         }
-      }
+      ]
     },
-    "behind": {
-      "name": "meta.behind.renpy",
-      "match": "\\b(behind)\\b[ \\t]*(.+)?",
+    "escaped_char": {
+      "match": "(\\\\\")|(\\\\')|(\\\\ )|(\\\\n)|(\\\\\\\\)|(\\[\\[)|({{)",
       "captures": {
-        "1": { "name": "keyword.renpy" },
-        "2": {
-          "name": "meta.behind.params.renpy",
-          "patterns": [{ "include": "#statements" }]
-        }
+        "1": { "name": "constant.character.escape.double-quote.python.renpy" },
+        "2": { "name": "constant.character.escape.quote.python.renpy" },
+        "3": { "name": "constant.character.escape.whitespace.python.renpy" },
+        "4": { "name": "constant.character.escape.newline.python.renpy" },
+        "5": { "name": "constant.character.escape.backslash.python.renpy" },
+        "6": { "name": "constant.character.escape.open.bracket.python.renpy" },
+        "7": { "name": "constant.character.escape.open.square-bracket.python.renpy" }
       }
     },
-    "onlayer": {
-      "name": "meta.onlayer.renpy",
-      "match": "\\b(onlayer)\\b[ \\t]*(.+)?",
+    "constant_placeholder": {
+      "comment": "Python value interpolation using [ ... ]",
+      "name": "constant.other.placeholder.tags.renpy",
+      "match": "(\\[)(.*?)(\\])(?![^\\[]*?\\])",
       "captures": {
-        "1": { "name": "keyword.renpy" },
+        "1": { "name": "constant.character.format.placeholder.other.renpy" },
         "2": {
-          "name": "meta.onlayer.params.renpy",
-          "patterns": [{ "include": "#statements" }]
-        }
+          "name": "meta.embedded.line.python",
+          "patterns": [{ "include": "source.renpy.python#expression" }]
+        },
+        "3": { "name": "constant.character.format.placeholder.other.renpy" }
       }
     },
-    "zorder": {
-      "name": "meta.zorder.renpy",
-      "match": "\\b(zorder)\\b[ \\t]*(.+)?",
+    "escaped_unicode_char": {
+      "match": "(\\\\U[0-9A-Fa-f]{8})|(\\\\u[0-9A-Fa-f]{4})|(\\\\N\\{[a-zA-Z ]+\\})",
       "captures": {
-        "1": { "name": "keyword.renpy" },
-        "2": {
-          "name": "meta.zorder.params.renpy",
-          "patterns": [{ "include": "#statements" }]
-        }
+        "1": { "name": "constant.character.unicode.16-bit-hex.python.renpy" },
+        "2": { "name": "constant.character.unicode.32-bit-hex.python.renpy" },
+        "3": { "name": "constant.character.unicode.name.python.renpy" }
       }
     },
-    "image": {
+    "hex_literal": {
+      "comment": "Note: This pattern has no end check. Only use as include pattern!",
       "patterns": [
         {
-          "name": "meta.image.renpy",
-          "contentName": "meta.image.atl-block.renpy",
-          "begin": "^([ \\t]+)?(image)\\b[ \\t]*([a-zA-Z_0-9 ]*)(:)",
-          "beginCaptures": {
-            "1": { "name": "punctuation.whitespace.leading.renpy" },
-            "2": { "name": "keyword.renpy" },
-            "3": { "name": "entity.name.type.image.renpy" },
-            "4": { "name": "punctuation.section.atl.begin.renpy" }
-          },
-          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-          "patterns": [{ "include": "#atl" }]
+          "comment": "rgb, rgba, rrggbb, rrggbbaa",
+          "match": "(?i)#(?:[a-f0-9]{8}|[a-f0-9]{6}|[a-f0-9]{3,4})\\b",
+          "name": "constant.color.renpy"
         },
         {
-          "name": "meta.image.renpy",
-          "begin": "^[ \\t]*(image)\\b[ \\t]*",
-          "beginCaptures": {
-            "1": { "name": "keyword.renpy" }
-          },
-          "end": "(?!\\G)(?=\\b(at)\\b|#|=)|$",
-          "patterns": [
-            { "include": "#strings" },
-            {
-              "match": "\\b(?:[a-zA-Z_0-9]+)\\b[ \\t]*",
-              "name": "entity.name.type.image.renpy"
-            }
-          ]
+          "match": "(?i)#[a-f0-9]+\\b",
+          "name": "invalid.illegal.unexpected-number-of-hex-values.renpy"
         },
-        { "include": "#at" },
-        { "include": "#with" }
-      ]
-    },
-    "show": {
-      "patterns": [
         {
-          "name": "meta.$2.renpy",
-          "contentName": "meta.$2.atl-block.renpy",
-          "begin": "^([ \\t]+)?(show)\\b[ \\t]*([a-zA-Z_0-9 ]*)(:)",
-          "beginCaptures": {
-            "1": { "name": "punctuation.whitespace.leading.renpy" },
-            "2": { "name": "keyword.renpy" },
-            "3": { "name": "entity.name.type.image.renpy" },
-            "4": { "name": "punctuation.section.atl.begin.renpy" }
-          },
-          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-          "patterns": [{ "include": "#atl" }]
-        },
-        {
-          "name": "meta.$1.renpy",
-          "begin": "^[ \\t]*(show)\\b[ \\t]*",
-          "beginCaptures": {
-            "1": { "name": "keyword.renpy" }
-          },
-          "end": "(?=\\b(at|as|behind|onlayer|expression|with|zorder)\\b|#)|$",
-          "patterns": [
-            { "include": "#strings" },
-            {
-              "match": "\\b(?:[a-zA-Z_0-9]+)\\b[ \\t]*",
-              "name": "entity.name.type.image.renpy"
-            }
-          ]
-        },
-        { "include": "#at" },
-        { "include": "#as" },
-        { "include": "#with" },
-        { "include": "#behind" },
-        { "include": "#onlayer" },
-        { "include": "#zorder" }
+          "match": "(?i)(?:#[a-f0-9]*)?(.+)",
+          "name": "constant.color.renpy",
+          "captures": {
+            "1": { "name": "invalid.illegal.character-not-allowed-here.renpy" }
+          }
+        }
       ]
     },
-    "scene": {
-      "patterns": [
-        {
-          "name": "meta.$2.renpy",
-          "contentName": "meta.$2.atl-block.renpy",
-          "begin": "^([ \\t]+)?(scene)\\b[ \\t]*([a-zA-Z_0-9 ]*)(:)",
-          "beginCaptures": {
-            "1": { "name": "punctuation.whitespace.leading.renpy" },
-            "2": { "name": "keyword.renpy" },
-            "3": { "name": "entity.name.type.image.renpy" },
-            "4": { "name": "punctuation.section.atl.begin.renpy" }
-          },
-          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-          "patterns": [{ "include": "#atl" }]
-        },
-        {
-          "name": "meta.$1.renpy",
-          "begin": "^[ \\t]*(scene)\\b[ \\t]*",
-          "beginCaptures": {
-            "1": { "name": "keyword.renpy" }
-          },
-          "end": "(?=\\b(at|as|behind|onlayer|expression|with|zorder)\\b|#)|$",
-          "patterns": [
-            { "include": "#strings" },
-            {
-              "match": "\\b(?:[a-zA-Z_0-9]+)\\b[ \\t]*",
-              "name": "entity.name.type.image.renpy"
-            }
-          ]
-        },
-        { "include": "#at" },
-        { "include": "#as" },
-        { "include": "#with" },
-        { "include": "#behind" },
-        { "include": "#onlayer" },
-        { "include": "#zorder" }
-      ]
+    "strings-interior": {
+      "patterns": [{ "include": "#new-line" }, { "include": "#escaped_char" }, { "include": "#string-tags" }, { "include": "#constant_placeholder" }]
     },
-    "camera": {
+    "string-tags": {
       "patterns": [
         {
-          "name": "meta.camera.renpy",
-          "contentName": "meta.camera.atl-block.renpy",
-          "begin": "^([ \\t]+)?(camera)\\b[ \\t]*(:)",
-          "beginCaptures": {
-            "1": { "name": "punctuation.whitespace.leading.renpy" },
-            "2": { "name": "keyword.renpy" },
-            "3": { "name": "entity.name.type.image.renpy" },
-            "4": { "name": "punctuation.section.atl.begin.renpy" }
-          },
-          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-          "patterns": [{ "include": "#atl" }]
+          "comment": "Valid tags without params (self-closing)",
+          "name": "meta.string.tag.${2:/downcase}.self-closing.renpy",
+          "match": "({)\\s*(nw|done|fast|p|w|clear)\\s*(})",
+          "captures": {
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.definition.tag.end.renpy" }
+          }
         },
         {
-          "name": "meta.camera.renpy",
-          "begin": "^[ \\t]*(camera)\\b[ \\t]*",
-          "beginCaptures": {
-            "1": { "name": "keyword.renpy" }
-          },
-          "end": "(?=\\b(at|with)\\b|#)|$",
-          "patterns": [
-            {
-              "match": "\\b(?:[a-zA-Z_0-9]+)\\b[ \\t]*",
-              "name": "entity.name.type.image.renpy"
-            }
-          ]
+          "comment": "Valid tags with numeric params (self-closing)",
+          "name": "meta.string.tag.${2:/downcase}.self-closing.renpy",
+          "match": "({)\\s*(p|w)(=)(\\+?)(\\d*(?:.\\d+)?)\\s*(})",
+          "captures": {
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
+            "4": { "name": "keyword.operator.arithmetic.plus.renpy" },
+            "5": { "name": "support.constant.property-value.renpy constant.numeric.float.renpy" },
+            "6": { "name": "punctuation.definition.tag.end.renpy" }
+          }
         },
-        { "include": "#at" },
-        { "include": "#with" }
-      ]
-    },
-    "atl": {
-      "comment": "https://www.renpy.org/doc/html/atl.html#atl-syntax-and-semantics",
-      "patterns": [{ "include": "#atl-keywords" }, { "include": "#atl-blocks" }, { "include": "#atl-simple-expression" }, { "include": "#atl-warper" }, { "include": "#atl-event" }, { "include": "#atl-on" }, { "include": "#atl-function" }]
-    },
-    "atl-simple-expression": {
-      "patterns": [
-        { "include": "#expressions" },
-        { "include": "#atl-build-in-properties" },
-        { "include": "source.renpy.python#literal" },
-        { "include": "source.renpy.python#member-access" },
-        { "include": "source.renpy.python#illegal-operator" },
-        { "include": "source.renpy.python#operator" },
-        { "include": "source.renpy.python#curly-braces" },
-        { "include": "source.renpy.python#item-access" },
-        { "include": "source.renpy.python#list" },
-        { "include": "source.renpy.python#odd-function-call" },
-        { "include": "source.renpy.python#round-braces" },
-        { "include": "source.renpy.python#function-call" },
-        { "include": "source.renpy.python#builtin-functions" },
-        { "include": "source.renpy.python#builtin-types" },
-        { "include": "source.renpy.python#builtin-exceptions" },
-        { "include": "source.renpy.python#magic-names" },
-        { "include": "source.renpy.python#special-names" },
-        { "include": "source.renpy.python#illegal-names" },
-        { "include": "source.renpy.python#special-variables" },
-        { "include": "source.renpy.python#ellipsis" },
-        { "include": "source.renpy.python#punctuation" },
-        { "include": "source.renpy.python#line-continuation" }
-      ]
-    },
-    "atl-expression": {
-      "comment": "https://www.renpy.org/doc/html/atl.html#expression-statement",
-      "patterns": [
-        { "include": "#atl-simple-expression" },
         {
-          "begin": "\\b(with)\\b[ \\t]*",
-          "beginCaptures": {
-            "1": { "name": "keyword.renpy" }
-          },
-          "end": "$",
-          "patterns": [{ "include": "#atl-simple-expression" }]
+          "comment": "Valid tags with numeric params (self-closing)",
+          "name": "meta.string.tag.${2:/downcase}.self-closing.renpy",
+          "match": "({)\\s*(v?space)(=)(\\+?)(\\d+)\\s*(})",
+          "captures": {
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
+            "4": { "name": "keyword.operator.arithmetic.plus.renpy" },
+            "5": { "name": "support.constant.property-value.renpy constant.numeric.integer.renpy" },
+            "6": { "name": "punctuation.definition.tag.end.renpy" }
+          }
         },
-        { "include": "source.renpy.python#expression" }
-      ]
-    },
-    "atl-keywords": {
-      "patterns": [
         {
-          "comment": "https://www.renpy.org/doc/html/atl.html#animation-statement",
-          "match": "^[ \\t]*(animation)\\b",
+          "comment": "Comment tag (self-closing)",
+          "name": "meta.string.tag.comment.self-closing.renpy",
+          "match": "({)\\s*(#)\\s*(.*?)\\s*(})",
           "captures": {
-            "1": { "name": "keyword.renpy" }
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "comment.line.number-sign.renpy punctuation.definition.comment.renpy" },
+            "3": { "name": "comment.line.number-sign.renpy" },
+            "4": { "name": "punctuation.definition.tag.end.renpy" }
           }
         },
         {
-          "comment": "https://www.renpy.org/doc/html/atl.html#pass-statement",
-          "match": "^[ \\t]*(pass)\\b",
+          "comment": "Valid tags with file param",
+          "name": "meta.string.tag.${2:/downcase}.self-closing.renpy",
+          "match": "({)\\s*(image)(=)([\\w.]+)\\s*(})",
           "captures": {
-            "1": { "name": "keyword.control.flow.renpy" }
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
+            "4": { "name": "support.constant.property-value.renpy string.unquoted.renpy" },
+            "5": { "name": "punctuation.definition.tag.end.renpy" }
           }
         },
         {
-          "comment": "https://www.renpy.org/doc/html/atl.html#repeat-statement and https://www.renpy.org/doc/html/atl.html#time-statement",
-          "begin": "^[ \\t]*(repeat|time|pause)\\b[ \\t]*",
+          "comment": "Valid tags without params (close required)",
+          "contentName": "renpy.meta.${2:/downcase} meta.tagged.string.renpy",
+          "begin": "({)\\s*(u|i|b|s|plain|alt|noalt|art|rb|rt)\\s*(})",
           "beginCaptures": {
-            "1": { "name": "keyword.control.flow.renpy" }
+            "0": { "name": "meta.string.tag.${2:/downcase}.start.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.definition.tag.end.renpy" }
           },
-          "end": "$",
-          "patterns": [{ "include": "#atl-simple-expression" }]
+          "end": "({/)\\s*(\\2)\\s*(})",
+          "endCaptures": {
+            "0": { "name": "meta.string.tag.${2:/downcase}.end.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.definition.tag.end.renpy" }
+          },
+          "patterns": [{ "include": "#strings-interior" }]
         },
         {
-          "comment": "https://www.renpy.org/doc/html/atl.html#expression-statement",
-          "contentName": "meta.atl.with.renpy",
-          "begin": "^[ \\t]*(with)\\b[ \\t]*",
+          "comment": "Valid tags with numeric params (close required)",
+          "contentName": "renpy.meta.${2:/downcase} meta.tagged.string.renpy",
+          "begin": "({)\\s*(alpha|cps|k)(=)(?:(\\*)|(\\-)|(\\+))?(\\d*(?:.\\d+)?)\\s*(})",
           "beginCaptures": {
-            "1": { "name": "keyword.renpy" }
+            "0": { "name": "meta.string.tag.${2:/downcase}.start.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
+            "4": { "name": "keyword.operator.arithmetic.Multiply.renpy" },
+            "5": { "name": "keyword.operator.arithmetic.Minus.renpy" },
+            "6": { "name": "keyword.operator.arithmetic.Plus.renpy" },
+            "7": { "name": "support.constant.property-value.renpy constant.numeric.renpy" },
+            "8": { "name": "punctuation.definition.tag.end.renpy" }
           },
-          "end": "$",
-          "patterns": [{ "include": "#atl-simple-expression" }]
+          "end": "({/)\\s*(\\2)\\s*(})",
+          "endCaptures": {
+            "0": { "name": "meta.string.tag.${2:/downcase}.end.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.definition.tag.end.renpy" }
+          },
+          "patterns": [{ "include": "#strings-interior" }]
         },
         {
-          "comment": "https://www.renpy.org/doc/html/atl.html#contains-statement",
-          "contentName": "meta.atl.contains.renpy",
-          "begin": "^[ \\t]*(contains)\\b[ \\t]*",
+          "comment": "Valid tags with numeric params (close required)",
+          "contentName": "renpy.meta.${2:/downcase} meta.tagged.string.renpy",
+          "begin": "({)\\s*(size)(=)([\\-+]?)(\\d+)\\s*(})",
           "beginCaptures": {
-            "1": { "name": "keyword.control.flow.renpy" }
+            "0": { "name": "meta.string.tag.${2:/downcase}.start.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
+            "4": { "name": "keyword.operator.arithmetic.renpy" },
+            "5": { "name": "support.constant.property-value.renpy constant.numeric.integer.renpy" },
+            "6": { "name": "punctuation.definition.tag.end.renpy" }
           },
-          "end": "$",
-          "patterns": [{ "include": "#atl-expression" }]
-        }
-      ]
-    },
-    "atl-blocks": {
-      "patterns": [
+          "end": "({/)\\s*(\\2)\\s*(})",
+          "endCaptures": {
+            "0": { "name": "meta.string.tag.${2:/downcase}.end.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.definition.tag.end.renpy" }
+          },
+          "patterns": [{ "include": "#strings-interior" }]
+        },
         {
-          "comment": "See https://www.renpy.org/doc/html/atl.html",
-          "contentName": "meta.atl.block.renpy",
-          "begin": "^([ \\t]+)?(block|parallel|contains)\\b[ \\t]*(:)",
+          "comment": "Valid tags with file param (close required)",
+          "name": "meta.string.tag.${2:/downcase}.self-closing.renpy",
+          "begin": "({)\\s*(font)(=)([\\w.]+)\\s*(})",
           "beginCaptures": {
-            "1": { "name": "punctuation.whitespace.leading.block.renpy" },
-            "2": { "name": "keyword.other.renpy" },
-            "3": { "name": "punctuation.section.block.begin.renpy" }
+            "0": { "name": "meta.string.tag.${2:/downcase}.start.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
+            "4": { "name": "support.constant.property-value.renpy string.unquoted.renpy" },
+            "5": { "name": "punctuation.definition.tag.end.renpy" }
           },
-          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-          "patterns": [{ "include": "#atl" }]
+          "end": "({/)\\s*(\\2)\\s*(})",
+          "endCaptures": {
+            "0": { "name": "meta.string.tag.${2:/downcase}.end.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.definition.tag.end.renpy" }
+          },
+          "patterns": [{ "include": "#strings-interior" }]
         },
         {
-          "comment": "https://www.renpy.org/doc/html/atl.html#choice-statement",
-          "contentName": "meta.atl.choice.renpy",
-          "begin": "^([ \\t]+)?(choice)\\b[ \\t]*(.+)?(:)",
+          "comment": "Color tag",
+          "contentName": "renpy.meta.${2:/downcase}.${4:/downcase} meta.tagged.string.renpy",
+          "begin": "({)\\s*(color|outlinecolor)(=)(#?[a-zA-Z0-9]+)\\s*(})",
           "beginCaptures": {
-            "1": { "name": "punctuation.whitespace.leading.block.renpy" },
-            "2": { "name": "keyword.other.renpy" },
-            "3": { "patterns": [{ "include": "#atl-simple-expression" }] },
-            "4": { "name": "punctuation.section.block.begin.renpy" }
+            "0": { "name": "meta.string.tag.${2:/downcase}.start.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
+            "4": {
+              "name": "constant.color.renpy",
+              "patterns": [{ "include": "#hex_literal" }]
+            },
+            "5": { "name": "punctuation.definition.tag.end.renpy" }
           },
-          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-          "patterns": [{ "include": "#atl" }]
-        }
-      ]
-    },
-    "atl-build-in-events": {
-      "comment": "Pre-defined events (https://www.renpy.org/doc/html/atl.html#external-events)",
-      "name": "support.function.event.renpy",
-      "match": "\\b(?<!\\.)(?:start|show|replace|hide|replaced|update|hover|idle|selected_hover|selected_idle)\\b"
-    },
-    "atl-event-name": {
-      "patterns": [
-        { "include": "source.renpy.python#builtin-possible-callables" },
-        { "include": "#atl-build-in-events" },
-        {
-          "name": "entity.name.function.renpy meta.function-call.generic.renpy",
-          "match": "\\b([[:alpha:]_]\\w*)\\b"
-        }
-      ]
-    },
-    "atl-event-def-name": {
-      "patterns": [
-        { "include": "source.renpy.python#builtin-possible-callables" },
-        { "include": "#atl-build-in-events" },
+          "end": "({/)\\s*(\\2)\\s*(})",
+          "endCaptures": {
+            "0": { "name": "meta.string.tag.${2:/downcase}.end.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.definition.tag.end.renpy" }
+          },
+          "patterns": [{ "include": "#strings-interior" }]
+        },
         {
-          "name": "entity.name.function.renpy",
-          "match": "\\b([[:alpha:]_]\\w*)\\b"
-        }
-      ]
-    },
-    "atl-event": {
-      "comment": "https://www.renpy.org/doc/html/atl.html#event-statement",
-      "name": "meta.atl.event.renpy",
-      "match": "^[ \\t]*(event)\\b[ \\t]*\\b([[:alpha:]_]\\w*)\\b",
-      "captures": {
-        "1": { "name": "keyword.other.renpy" },
-        "2": { "patterns": [{ "include": "#atl-event-name" }] }
-      }
-    },
-    "atl-on": {
-      "comment": "https://www.renpy.org/doc/html/atl.html#on-statement",
-      "contentName": "meta.atl.on.renpy",
-      "begin": "^([ \\t]+)?(on)\\b[ \\t]*(.+)?(:)",
-      "beginCaptures": {
-        "1": { "name": "punctuation.whitespace.leading.block.renpy" },
-        "2": { "name": "keyword.other.renpy" },
-        "3": {
-          "patterns": [
-            { "include": "#atl-event-name" },
-            {
-              "match": "[ \\t]*,[ \\t]*",
-              "name": "punctuation.separator.parameters.renpy"
+          "comment": "a tag",
+          "contentName": "renpy.meta.${2:/downcase} meta.tagged.string.renpy",
+          "begin": "({)\\s*(a)(=)(.*?)\\s*(})",
+          "beginCaptures": {
+            "0": { "name": "meta.string.tag.${2:/downcase}.start.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
+            "4": {
+              "name": "support.constant.property-value.renpy string.unquoted.renpy",
+              "patterns": []
             },
-            { "include": "#comments" }
-          ]
-        },
-        "4": { "name": "punctuation.section.block.begin.renpy" }
-      },
-      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-      "patterns": [{ "include": "#atl" }]
-    },
-    "atl-function": {
-      "comment": "https://www.renpy.org/doc/html/atl.html#function-statement",
-      "name": "meta.atl.function.renpy",
-      "match": "^[ \\t]*(function)\\b[ \\t]*\\b([[:alpha:]_]\\w*)\\b",
-      "captures": {
-        "1": { "name": "keyword.other.renpy" },
-        "2": {
-          "patterns": [
-            { "include": "source.renpy.python#builtin-possible-callables" },
-            {
-              "name": "entity.name.function.renpy meta.function-call.generic.renpy",
-              "match": "\\b([[:alpha:]_]\\w*)\\b"
-            }
-          ]
-        }
-      }
-    },
-    "atl-build-in-warpers": {
-      "comment": "Pre-defined warpers (https://www.renpy.org/doc/html/atl.html#warpers)",
-      "name": "support.function.renpy",
-      "match": "\\b(?<!\\.)(?:linear|ease|easein|easeout|ease_back|ease_bounce|ease_circ|ease_cubic|ease_elastic|ease_expo|ease_quad|ease_quart|ease_quint|easein_back|easein_bounce|easein_circ|easein_cubic|easein_elastic|easein_expo|easein_quad|easein_quart|easein_quint|easeout_back|easeout_bounce|easeout_circ|easeout_cubic|easeout_elastic|easeout_expo|easeout_quad|easeout_quart|easeout_quint)\\b"
-    },
-    "atl-build-in-properties": {
-      "comment": "https://www.renpy.org/doc/html/atl.html#list-of-transform-properties",
-      "patterns": [
-        {
-          "comment": "Special manipulation keywords",
-          "name": "keyword.renpy",
-          "match": "\\b(?<!\\.)(?:warp|circles|clockwise|counterclockwise)\\b"
-        },
-        {
-          "comment": "position props (int, absolute, or a float)",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:xpos|ypos|xanchor|yanchor|xcenter|ycenter|radius)\\b"
-        },
-        {
-          "comment": "position pair props",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:pos|anchor|xycenter|around|alignaround|matrixanchor)\\b"
-        },
-        {
-          "comment": "float props",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:xalign|yalign|zoom|xzoom|yzoom|alpha|additive|angle|delay|events|zpos)\\b"
-        },
-        {
-          "comment": "float pair props",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:align|knot)\\b"
-        },
-        {
-          "comment": "int props",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:xoffset|yoffset|xtile|ytile)\\b"
-        },
-        {
-          "comment": "int pair props",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:offset)\\b"
-        },
-        {
-          "comment": "boolean props",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:rotate_pad|transform_anchor|nearest|crop_relative|subpixel|zzoom)\\b"
-        },
-        {
-          "comment": "('#float' | None)",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:rotate|xpan|ypan|blur)\\b"
-        },
-        {
-          "comment": "('#position' | None)",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:xsize|ysize)\\b"
-        },
-        {
-          "comment": "('\\(int, int, int, int\\)' | '\\(float, float, float, float\\)' | None)",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:crop)\\b"
-        },
-        {
-          "comment": "('\\(int, int\\)' | None)",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:corner1|corner2)\\b"
-        },
-        {
-          "comment": "('\\(position, position\\)' | None)",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:xysize)\\b"
-        },
-        {
-          "comment": "('#string' | None)",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:fit)\\b"
-        },
-        {
-          "comment": "('\\(int, int\\)' | None)",
-          "name": "invalid.deprecated.renpy",
-          "match": "\\b(?<!\\.)(?:size|maxsize)\\b"
-        },
-        {
-          "comment": "('#Matrix' | '#MatrixColor' | None)",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:matrixcolor)\\b"
-        },
-        {
-          "comment": "('#Matrix' | '#TransformMatrix' | None)",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:matrixtransform)\\b"
+            "5": { "name": "punctuation.definition.tag.end.renpy" }
+          },
+          "end": "({/)\\s*(\\2)\\s*(})",
+          "endCaptures": {
+            "0": { "name": "meta.string.tag.${2:/downcase}.end.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.definition.tag.end.renpy" }
+          },
+          "patterns": [{ "include": "#strings-interior" }]
         },
         {
-          "comment": "('#bool' | '#float' | '\\(float, float, float\\)')",
-          "name": "support.type.property-name.transform.renpy",
-          "match": "\\b(?<!\\.)(?:perspective)\\b"
-        }
-      ]
-    },
-    "atl-warper-name": {
-      "patterns": [
-        { "include": "source.renpy.python#builtin-possible-callables" },
-        { "include": "#atl-build-in-warpers" },
-        { "include": "#atl-build-in-properties" },
-        {
-          "name": "entity.name.function.warper.renpy meta.function-call.generic.renpy",
-          "match": "\\b([[:alpha:]_]\\w*)\\b"
-        }
-      ]
-    },
-    "atl-warper": {
-      "comment": "https://www.renpy.org/doc/html/atl.html#warpers",
-      "name": "meta.atl.warper.renpy",
-      "begin": "\\b(?<!\\.)([[:alpha:]_]\\w*)\\b[ \\t]*",
-      "beginCaptures": {
-        "1": { "patterns": [{ "include": "#atl-warper-name" }] }
-      },
-      "end": "(?!\\G)",
-      "patterns": [{ "include": "#atl-simple-expression" }]
-    },
-    "style-old": {
-      "match": "^\\s*(style)\\s+([a-zA-Z_][a-zA-Z_0-9]*)",
-      "captures": {
-        "1": { "name": "keyword.python.renpy" },
-        "2": { "name": "entity.name.tag.python.renpy.style.renpy" }
-      }
-    },
-    "use-old": {
-      "match": "^\\s*(use)\\s+([a-zA-Z_][a-zA-Z_0-9]*)",
-      "captures": {
-        "1": { "name": "keyword.python.renpy" },
-        "2": { "name": "entity.name.class.python.renpy.screen.renpy" }
-      }
-    },
-    "builtin-screens": {
-      "comment": "TODO: Should combine this with builtin-labels",
-      "name": "support.function.builtin.renpy",
-      "match": "(?<!\\.)\\b(?:start|quit|after_load|splashscreen|before_main_menu|main_menu|after_warp|hide_windows)\\b"
-    },
-    "screen-def-name": {
-      "comment": "TODO: Should combine this with label-def-name",
-      "patterns": [
-        { "include": "source.renpy.python#builtin-possible-callables" },
-        { "include": "#builtin-screens" },
-        {
-          "match": "(?<=^|[ \\t])(\\b(?:[a-zA-Z_]\\w*)\\b)?(\\.)?(\\b(?:[a-zA-Z_]\\w*)\\b)",
+          "comment": "Unknown tag (Single line support only cus \\R does not work) (Since we don't know if a tag is self closing, we can't assume that an end pattern exists)",
+          "match": "({)[ \\t]*(\\w+)\\b(?:(=)(.*?))?\\s*(})((?:.|\\R)+?)\\s*({/)\\s*(\\2)\\s*(})",
           "captures": {
-            "1": { "name": "entity.name.function.renpy" },
-            "2": { "name": "punctuation.separator.period.renpy" },
-            "3": { "name": "entity.name.function.renpy" }
+            "1": { "name": "meta.string.tag.${2:/downcase}.start.renpy punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "meta.string.tag.${2:/downcase}.start.renpy renpy.meta.u entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "meta.string.tag.${2:/downcase}.start.renpy punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
+            "4": { "name": "meta.string.tag.${2:/downcase}.start.renpy constant.other.placeholder.tags.renpy" },
+            "5": { "name": "meta.string.tag.${2:/downcase}.start.renpy punctuation.definition.tag.end.renpy" },
+            "6": {
+              "name": "renpy.meta.string.tag.custom.${2:/downcase} meta.tagged.string.renpy",
+              "patterns": [{ "include": "#strings-interior" }]
+            },
+            "7": { "name": "meta.string.tag.${2:/downcase}.end.renpy punctuation.definition.tag.begin.renpy" },
+            "8": { "name": "meta.string.tag.${2:/downcase}.end.renpy renpy.meta.u entity.name.tag.${2:/downcase}.renpy" },
+            "9": { "name": "meta.string.tag.${2:/downcase}.end.renpy punctuation.definition.tag.end.renpy" }
           }
-        }
-      ]
-    },
-    "screen-simple-expression": {
-      "patterns": [
-        { "include": "#expressions" },
-        { "include": "source.renpy.python#literal" },
-        { "include": "source.renpy.python#member-access" },
-        { "include": "source.renpy.python#illegal-operator" },
-        { "include": "source.renpy.python#operator" },
-        { "include": "source.renpy.python#curly-braces" },
-        { "include": "source.renpy.python#item-access" },
-        { "include": "source.renpy.python#list" },
-        { "include": "source.renpy.python#odd-function-call" },
-        { "include": "source.renpy.python#round-braces" },
-        { "include": "source.renpy.python#function-call" },
-        { "include": "source.renpy.python#builtin-functions" },
-        { "include": "source.renpy.python#builtin-types" },
-        { "include": "source.renpy.python#builtin-exceptions" },
-        { "include": "source.renpy.python#magic-names" },
-        { "include": "source.renpy.python#special-names" },
-        { "include": "source.renpy.python#illegal-names" },
-        { "include": "source.renpy.python#special-variables" },
-        { "include": "source.renpy.python#ellipsis" },
-        { "include": "source.renpy.python#punctuation" },
-        { "include": "source.renpy.python#line-continuation" }
-      ]
-    },
-    "screen-keywords": {
-      "comment": "https://www.renpy.org/doc/html/screens.html#screen-statement",
-      "patterns": [
-        {
-          "contentName": "meta.screen.sensitive.renpy",
-          "begin": "^[ \\t]*(sensitive)\\b[ \\t]*",
-          "beginCaptures": {
-            "1": { "name": "keyword.renpy" }
-          },
-          "end": "$",
-          "patterns": [{ "include": "#screen-simple-expression" }]
         },
         {
-          "name": "keyword.renpy",
-          "match": "\\b(?<!\\.)(?:modal|sensitive|tag|zorder|variant|layer|roll_forward|text)\\b"
-        },
-        {
-          "name": "keyword.renpy",
-          "match": "\\b(?<!\\.)(?:style|style_group|style_prefix)\\b"
+          "comment": "Unknown tag start",
+          "match": "({)\\s*(\\w*)(?:(=)(.*?))?\\s*(})",
+          "captures": {
+            "0": { "name": "meta.string.tag.${2:/downcase}.start.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "renpy.meta.u entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
+            "4": {
+              "name": "support.constant.property-value.renpy constant.other.placeholder.tags.renpy",
+              "patterns": []
+            },
+            "5": { "name": "punctuation.definition.tag.end.renpy" }
+          }
         },
         {
-          "name": "keyword.renpy",
-          "match": "\\b(?<!\\.)(?:has|vbox|label|add|xfill)\\b"
+          "comment": "Unknown tag end",
+          "match": "({/)\\s*(\\w*?)\\b\\s*(})",
+          "captures": {
+            "0": { "name": "meta.string.tag.${2:/downcase}.end.renpy" },
+            "1": { "name": "punctuation.definition.tag.begin.renpy" },
+            "2": { "name": "renpy.meta.u entity.name.tag.${2:/downcase}.renpy" },
+            "3": { "name": "punctuation.definition.tag.end.renpy" }
+          }
         }
       ]
     },
-    "screen-frame": {
-      "contentName": "meta.screen.frame.renpy",
-      "begin": "^([ \\t]+)?(frame)\\b[ \\t]*(:)",
+    "strings": {
+      "name": "string.quoted.renpy",
+      "begin": "\"\"\"|\"|'''|'|```|`",
       "beginCaptures": {
-        "1": { "name": "punctuation.whitespace.leading.block.renpy" },
-        "2": { "name": "keyword.other.renpy" },
-        "3": { "name": "punctuation.section.block.begin.renpy" }
+        "0": { "name": "punctuation.definition.string.begin.renpy" }
       },
-      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-      "patterns": [{ "include": "#screen-language" }]
-    },
-    "screen-window": {
-      "contentName": "meta.screen.window.renpy",
-      "begin": "^([ \\t]+)?(window)\\b[ \\t]*(:)",
-      "beginCaptures": {
-        "1": { "name": "punctuation.whitespace.leading.block.renpy" },
-        "2": { "name": "keyword.other.renpy" },
-        "3": { "name": "punctuation.section.block.begin.renpy" }
+      "end": "(?<![^\\\\]\\\\)(((?<=\\0)\\0)|\\0)",
+      "endCaptures": {
+        "1": { "name": "punctuation.definition.string.end.renpy" },
+        "2": { "name": "meta.empty-string.renpy" }
       },
-      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-      "patterns": [{ "include": "#screen-language" }]
+      "patterns": [{ "include": "#strings-interior" }]
     },
-    "screen-text": {
-      "contentName": "meta.screen.text.renpy",
-      "begin": "^([ \\t]+)?(text)\\b[ \\t]*(:)",
-      "beginCaptures": {
-        "1": { "name": "punctuation.whitespace.leading.block.renpy" },
-        "2": { "name": "keyword.other.renpy" },
-        "3": { "name": "punctuation.section.block.begin.renpy" }
-      },
-      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
 
+    "python-statements": {
       "patterns": [
         {
-          "name": "meta.screen.text.renpy",
-          "contentName": "meta.screen.text.atl-block.renpy",
-          "begin": "^([ \\t]+)?(text)\\b[ \\t]*([a-zA-Z_0-9 ]*)(:)",
-          "beginCaptures": {
+          "match": "^([ \\t]*)(init)[ \\t]+(offset)[ \\t]*(=)[ \\t]*(-)?([^#]*?)$",
+          "captures": {
             "1": { "name": "punctuation.whitespace.leading.renpy" },
-            "2": { "name": "keyword.renpy" },
-            "3": { "name": "entity.name.type.text.renpy" },
-            "4": { "name": "punctuation.section.atl.begin.renpy" }
+            "2": { "name": "keyword.init.renpy" },
+            "3": { "name": "keyword.offset.renpy" },
+            "4": { "name": "keyword.operator.assignment.renpy" },
+            "5": { "name": "keyword.operator.arithmetic.minus.renpy" },
+            "6": {
+              "patterns": [{ "include": "#num-int" }, { "include": "#invalid-token" }]
+            }
+          }
+        },
+        {
+          "comment": "Renpy python block",
+          "contentName": "meta.embedded.block.python",
+          "begin": "^([ \\t]+)?(?:(init)(?:[ \\t]+(-)?(\\d+))?[ \\t]+)?(python)[ \\t]*(.*)?(:)",
+          "beginCaptures": {
+            "1": { "name": "punctuation.whitespace.embedded.leading.renpy" },
+            "2": { "name": "keyword.init.renpy" },
+            "3": { "name": "keyword.operator.arithmetic.minus.renpy" },
+            "4": { "name": "constant.numeric.integer.renpy" },
+            "5": { "name": "keyword.python.renpy" },
+            "6": {
+              "name": "meta.python.block.arguments.renpy",
+              "patterns": [
+                {
+                  "comment": "in statement",
+                  "match": "(?:\\s*(in)\\s*([a-zA-Z_]\\w*)\\b)",
+                  "captures": {
+                    "1": { "name": "keyword.control.flow.in.renpy" },
+                    "2": { "name": "entity.name.namespace" }
+                  }
+                },
+                {
+                  "comment": "keywords",
+                  "match": "\\b(hide)|(early)|(in)\\b",
+                  "captures": {
+                    "1": { "name": "keyword.hide.renpy" },
+                    "2": { "name": "keyword.early.renpy" },
+                    "3": { "name": "keyword.control.flow.in.renpy" }
+                  }
+                }
+              ]
+            },
+            "7": { "name": "punctuation.section.python.begin.renpy" }
           },
           "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-          "patterns": [{ "include": "#atl" }]
+          "patterns": [{ "include": "source.renpy.python" }]
         },
         {
-          "name": "meta.screen.text.renpy",
-          "begin": "^[ \\t]*(text)\\b[ \\t]*",
+          "comment": "Match begin and end of python one line statements",
+          "contentName": "meta.embedded.line.python",
+          "begin": "(?<=^[ \\t]*)(?:(\\$)|(define)|(default))(?=[ \\t])",
           "beginCaptures": {
-            "1": { "name": "keyword.renpy" }
+            "1": { "name": "keyword.dollar.sign.renpy" },
+            "2": { "name": "keyword.define.renpy" },
+            "3": { "name": "keyword.default.renpy" }
           },
-          "end": "(?!\\G)(?=\\b(at)\\b|#|=)|$",
+          "end": "$",
           "patterns": [
-            { "include": "#strings" },
             {
-              "match": "\\b(?:[a-zA-Z_0-9]+)\\b[ \\t]*",
-              "name": "entity.name.type.text.renpy"
-            }
+              "comment": "Type the first name as a variable (Probably not needed, but python doesn't seem to catch it)",
+              "match": "(?<!\\.)\\b([a-zA-Z_]\\w*)(?=\\s=\\s)",
+              "name": "variable.other.renpy"
+            },
+            { "include": "#strings" },
+            { "include": "source.renpy.python#expression" },
+            { "include": "#whitespace" }
           ]
-        },
-        { "include": "#at" }
+        }
       ]
     },
-    "screen-language": {
-      "comment": "https://www.renpy.org/doc/html/screens.html#screen-language",
-      "patterns": [{ "include": "#screen-frame" }, { "include": "#screen-window" }, { "include": "#screen-text" }, { "include": "#screen-keywords" }, { "include": "#screen-simple-expression" }]
-    },
-    "screen": {
-      "patterns": [
-        {
-          "comment": "See https://www.renpy.org/doc/html/screens.html",
-          "contentName": "meta.screen.block.renpy",
-          "begin": "^([ \\t]+)?(screen)\\b[ \\t]*(.*?)(:)",
-          "beginCaptures": {
-            "1": { "name": "punctuation.whitespace.leading.block.renpy" },
-            "2": { "name": "storage.type.function.renpy" },
-            "3": {
-              "patterns": [
-                { "include": "#screen-def-name" },
-                { "include": "source.renpy.python#parameters" },
-                {
-                  "match": ".*",
-                  "name": "invalid.illegal.name.renpy"
-                }
-              ]
-            },
-            "4": { "name": "punctuation.section.block.begin.renpy" }
-          },
-          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-          "patterns": [{ "include": "#screen-language" }]
-        }
-      ]
-    },
-    "say-statements": {
+
+    "say-statements": {
       "patterns": [
         {
           "name": "meta.say.statement.renpy",
-          "contentName": "string.quoted.renpy renpy.meta.say.$1",
-          "begin": "^[ \\t]+(?:([a-zA-Z_]\\w*)\\b|\"([a-zA-Z_]\\w*)\\b\")((?:[ \\t]+(?:@|\\w+))*)?[ \\t]*(\"\"\"|\"|'''|'|```|`)",
+          "contentName": "renpy.meta.say.$1 string.quoted.renpy",
+          "begin": "(?<=^[ \\t]+)(?:([a-zA-Z_]\\w*)\\b|\"([a-zA-Z_]\\w*)\\b\")((?:[ \\t]+(?:@|\\w+))*)?[ \\t]*(\"\"\"|\"|'''|'|```|`)",
           "beginCaptures": {
             "1": {
-              "name": "variable.other.renpy renpy.meta.character.$1",
+              "name": "renpy.meta.character.$1 variable.other.renpy",
               "patterns": [
                 {
                   "match": "extend",
@@ -871,11 +625,11 @@
                 }
               ]
             },
-            "4": { "name": "punctuation.definition.string.begin.renpy string.quoted.renpy" }
+            "4": { "name": "string.quoted.renpy punctuation.definition.string.begin.renpy" }
           },
           "end": "(?<![^\\\\]\\\\)(((?<=\\4)\\4)|\\4)[ \\t]*(\\(.*?\\)(?![^\\(]*?\\)))?",
           "endCaptures": {
-            "1": { "name": "punctuation.definition.string.end.renpy string.quoted.renpy" },
+            "1": { "name": "string.quoted.renpy punctuation.definition.string.end.renpy" },
             "2": { "name": "meta.empty-string.renpy" },
             "3": {
               "patterns": [{ "include": "source.renpy.python#function-arguments" }]
@@ -886,13 +640,13 @@
         {
           "name": "meta.say.narrator.renpy",
           "contentName": "string.quoted.narrator.renpy",
-          "begin": "^[ \\t]+(\"\"\"|\"|'''|'|```|`)",
+          "begin": "(?<=^[ \\t]+)(\"\"\"|\"|'''|'|```|`)",
           "beginCaptures": {
-            "1": { "name": "punctuation.definition.string.begin.renpy string.quoted.renpy" }
+            "1": { "name": "string.quoted.renpy punctuation.definition.string.begin.renpy" }
           },
           "end": "(?<![^\\\\]\\\\)(((?<=\\1)\\1)|\\1)[ \\t]*(\\(.*?\\)(?![^\\(]*?\\)))?",
           "endCaptures": {
-            "1": { "name": "punctuation.definition.string.end.renpy string.quoted.renpy" },
+            "1": { "name": "string.quoted.renpy punctuation.definition.string.end.renpy" },
             "2": { "name": "meta.empty-string.renpy" },
             "3": {
               "patterns": [{ "include": "source.renpy.python#function-arguments" }]
@@ -902,679 +656,725 @@
         }
       ]
     },
-    "return-statements": {
-      "begin": "^[ \\t]+(return)\\b[ \\t]*",
-      "beginCaptures": {
-        "1": { "name": "keyword.control.flow.renpy" }
-      },
-      "end": "$",
-      "patterns": [{ "include": "#expressions" }, { "include": "source.renpy.python#expression" }]
-    },
-    "call-jump-expression": {
-      "begin": "\\b(?<!\\.)(expression)\\b",
-      "beginCaptures": {
-        "1": { "name": "keyword.other.renpy" }
-      },
-      "end": "(?=\\b(?<!\\.)(?:pass|from)\\b)|$",
-      "patterns": [{ "include": "#expressions" }, { "include": "source.renpy.python#expression" }]
-    },
-    "jump": {
-      "name": "meta.jump.renpy",
-      "begin": "^[ \\t]+(jump)\\b[ \\t]*",
-      "beginCaptures": {
-        "1": { "name": "keyword.control.flow.renpy" }
-      },
-      "end": "(?!\\G)[ \\t]*(.*?)?(?=#|$)",
-      "endCaptures": {
-        "1": { "name": "invalid.illegal.renpy" }
-      },
-      "patterns": [
-        { "include": "#call-jump-expression" },
-        {
-          "comment": "Label expression",
-          "begin": "\\G",
-          "end": "(?!\\G)(?![ \\t]*\\.[ \\t]*)",
-          "patterns": [{ "include": "#label-access" }, { "include": "#label-name" }]
+
+    "pause": {
+      "match": "^([ \\t]+)(pause)\\b([ \\t]+[^#\\n]*)?$",
+      "captures": {
+        "1": { "name": "punctuation.whitespace.leading.renpy" },
+        "2": { "name": "keyword.control.flow.pause.renpy" },
+        "3": { "name": "punctuation.whitespace.leading.renpy" },
+        "4": {
+          "name": "meta.pause.arguments.renpy",
+          "patterns": [{ "include": "#whitespace" }, { "include": "#num-float" }, { "include": "#num-int" }, { "include": "#invalid-token" }]
         }
-      ]
-    },
-    "call-pass": {
-      "begin": "\\b(?<!\\.)(pass)\\b[ \\t]*(?=\\()",
-      "beginCaptures": {
-        "1": { "name": "keyword.other.renpy" }
-      },
-      "end": "(\\))",
-      "endCaptures": {
-        "1": { "name": "punctuation.definition.arguments.end.renpy" }
-      },
-      "patterns": [{ "include": "source.renpy.python#function-arguments" }]
-    },
-    "call-from": {
-      "begin": "\\b(?<!\\.)(from)\\b[ \\t]*",
-      "beginCaptures": {
-        "1": { "name": "keyword.control.flow.renpy" }
-      },
-      "end": "(?=\\W|$)",
-      "patterns": [{ "include": "#label-name" }]
+      }
     },
-    "call": {
-      "name": "meta.call.renpy",
-      "begin": "^[ \\t]+(call)\\b[ \\t]*",
+
+    "transform": {
+      "begin": "^([ \\t]+)?(transform)\\b[ \\t]*(.*)?(:)",
       "beginCaptures": {
-        "1": { "name": "keyword.control.flow.renpy" }
-      },
-      "end": "(?=#|$)",
-      "endCaptures": {
-        "1": { "name": "invalid.illegal.renpy" }
-      },
-      "patterns": [
-        { "include": "#call-jump-expression" },
-        { "include": "#call-pass" },
-        {
-          "comment": "Label expression",
-          "begin": "\\G",
-          "end": "(?!\\G)(?![ \\t]*\\.[ \\t]*)",
-          "patterns": [{ "include": "#label-call" }, { "include": "#label-access" }, { "include": "#label-name" }]
+        "1": { "name": "punctuation.whitespace.leading.renpy" },
+        "2": { "name": "keyword.transform.renpy" },
+        "3": {
+          "patterns": [
+            {
+              "name": "variable.name.transform.renpy",
+              "match": "\\b([[:alpha:]_]\\w*)\\b"
+            }
+          ]
         },
-        { "include": "#call-from" }
-      ]
-    },
-    "builtin-labels": {
-      "name": "support.function.builtin.renpy",
-      "match": "(?<!\\.)\\b(?:start|quit|after_load|splashscreen|before_main_menu|main_menu|after_warp|hide_windows)\\b"
-    },
-    "label-call": {
-      "comment": "Note: label params are only allowed at the end of the access expression",
-      "name": "meta.function-call.label.renpy",
-      "begin": "\\b(?=([a-zA-Z_]\\w*)\\s*(\\())",
-      "end": "(\\))",
-      "endCaptures": {
-        "1": { "name": "punctuation.definition.arguments.end.renpy" }
-      },
-      "patterns": [{ "include": "source.renpy.python#special-variables" }, { "include": "#label-name" }, { "include": "source.renpy.python#function-arguments" }]
-    },
-    "label-access": {
-      "comment": "Note: Labels can't be nested twice in a row!",
-      "name": "meta.member.access.label.renpy",
-      "begin": "(\\.)\\s*(?!\\.)",
-      "end": "(?<=\\S)(?=\\W)|(^|(?<=\\s))(?=[^\\\\\\w\\s])|$",
-      "beginCaptures": {
-        "1": { "name": "punctuation.separator.period.renpy" }
+        "4": { "name": "punctuation.section.atl.begin.renpy" }
       },
-      "patterns": [{ "include": "#label-call" }, { "include": "#label-name" }]
+      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+      "patterns": [{ "include": "source.renpy.atl" }]
     },
-    "label-name": {
-      "patterns": [
-        { "include": "source.renpy.python#builtin-possible-callables" },
-        { "include": "#builtin-labels" },
-        {
-          "name": "entity.name.function.renpy",
-          "match": "\\b(?:[a-zA-Z_]\\w*)\\b"
+    "at-statement": {
+      "name": "meta.at.statement.renpy",
+      "match": "\\b(at)\\b[ \\t]*(.+)?",
+      "captures": {
+        "1": { "name": "keyword.control.flow.at.renpy" },
+        "2": {
+          "name": "meta.at.parameters.renpy",
+          "patterns": [{ "include": "#statements" }]
         }
-      ]
+      }
     },
-    "label-def-name": {
-      "comment": "Note: Labels can't be nested twice in a row!",
-      "patterns": [
-        { "include": "source.renpy.python#builtin-possible-callables" },
-        { "include": "#builtin-labels" },
-        {
-          "match": "(?<=^|[ \\t])(\\b(?:[a-zA-Z_]\\w*)\\b)?(\\.)?(\\b(?:[a-zA-Z_]\\w*)\\b)",
-          "captures": {
-            "1": { "name": "entity.name.function.renpy" },
-            "2": { "name": "punctuation.separator.period.renpy" },
-            "3": { "name": "entity.name.function.renpy" }
-          }
+    "as-statement": {
+      "name": "meta.as.statement.renpy",
+      "match": "\\b(as)\\b[ \\t]*(.+)?",
+      "captures": {
+        "1": { "name": "keyword.control.flow.as.renpy" },
+        "2": {
+          "name": "meta.as.parameters.renpy",
+          "patterns": [{ "include": "#statements" }]
         }
-      ]
+      }
     },
-    "label": {
-      "name": "meta.label.renpy",
-      "match": "^[ \\t]*(label)\\b[ \\t]*(.*?)([ \\t]*hide)?(:)",
+    "with-statement": {
+      "name": "meta.with.statement.renpy",
+      "match": "\\b(with)\\b[ \\t]*(.+)?",
       "captures": {
-        "1": { "name": "storage.type.function.renpy" },
+        "1": { "name": "keyword.control.flow.with.renpy" },
         "2": {
-          "patterns": [
-            { "include": "#label-def-name" },
-            { "include": "source.renpy.python#parameters" },
-            {
-              "match": ".*",
-              "name": "invalid.illegal.name.renpy"
-            }
-          ]
-        },
-        "3": { "name": "keyword.renpy" },
-        "4": { "name": "punctuation.section.label.begin.renpy" }
+          "name": "meta.with.parameters.renpy",
+          "patterns": [{ "include": "#expressions" }]
+        }
       }
     },
-    "menu": {
-      "name": "meta.menu.renpy",
-      "contentName": "meta.block.menu.renpy",
-      "begin": "^([ \\t]+)?(menu)[ \\t]*(.+)?(:)",
-      "beginCaptures": {
-        "1": { "name": "punctuation.whitespace.menu.leading.renpy" },
-        "2": { "name": "storage.type.function.renpy" },
-        "3": {
-          "patterns": [
-            {
-              "comment": "Menu name",
-              "match": "[a-zA-Z_.]\\w*",
-              "name": "entity.name.function.renpy"
-            },
-            { "include": "source.renpy.python#function-arguments" }
-          ]
-        },
-        "4": { "name": "punctuation.section.menu.begin.renpy" }
-      },
-      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-      "patterns": [{ "include": "#comments" }, { "include": "#menu-option" }, { "include": "#say-statements" }, { "include": "#menu-set" }]
+    "behind": {
+      "name": "meta.behind.statement.renpy",
+      "match": "\\b(behind)\\b[ \\t]*(.+)?",
+      "captures": {
+        "1": { "name": "keyword.control.flow.behind.renpy" },
+        "2": {
+          "name": "meta.behind.parameters.renpy",
+          "patterns": [{ "include": "#statements" }]
+        }
+      }
     },
-    "menu-set": {
-      "match": "^[ \\t]+(set)[ \\t]+(.+)?",
+    "onlayer": {
+      "name": "meta.onlayer.statement.renpy",
+      "match": "\\b(onlayer)\\b[ \\t]*(.+)?",
       "captures": {
-        "1": { "name": "keyword.renpy" },
+        "1": { "name": "keyword.control.flow.onlayer.renpy" },
         "2": {
-          "name": "meta.embedded.line.python",
-          "patterns": [{ "include": "source.renpy.python#expression-bare" }]
+          "name": "meta.onlayer.parameters.renpy",
+          "patterns": [{ "include": "#statements" }]
         }
       }
     },
-    "menu-option": {
-      "contentName": "meta.block.menu-option.renpy",
-      "begin": "^([ \\t]+)?((?:\".*\")|(?:'.*')|(?:\"\"\".*\"\"\"))[ \\t]*(.+)?(:)",
-      "beginCaptures": {
-        "1": { "name": "punctuation.whitespace.menu-option.leading.renpy" },
+    "zorder": {
+      "name": "meta.zorder.statement.renpy",
+      "match": "\\b(zorder)\\b[ \\t]*(.+)?",
+      "captures": {
+        "1": { "name": "keyword.control.flow.zorder.renpy" },
         "2": {
-          "name": "meta.menu-option.renpy",
-          "patterns": [{ "include": "#strings" }]
+          "name": "meta.zorder.parameters.renpy",
+          "patterns": [{ "include": "#statements" }]
+        }
+      }
+    },
+    "image": {
+      "patterns": [
+        {
+          "name": "meta.image.statement.renpy",
+          "contentName": "meta.atl-block.renpy",
+          "begin": "^([ \\t]+)?(image)\\b[ \\t]*([a-zA-Z_0-9 ]*)(:)",
+          "beginCaptures": {
+            "1": { "name": "punctuation.whitespace.leading.renpy" },
+            "2": { "name": "keyword.image.renpy" },
+            "3": { "name": "entity.name.type.image.renpy" },
+            "4": { "name": "punctuation.section.atl.begin.renpy" }
+          },
+          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+          "patterns": [{ "include": "source.renpy.atl" }]
         },
-        "3": {
-          "name": "meta.embedded.line.python",
+        {
+          "name": "meta.image.statement.renpy",
+          "begin": "(?<=^[ \\t]*)(image)\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.image.renpy" }
+          },
+          "end": "(?=\\b(at)\\b|#|=)|$",
           "patterns": [
-            { "include": "source.renpy.python#function-arguments" },
-            {
-              "comment": "if condition",
-              "match": "\\b(if)[ \\t]+(.+)?",
-              "captures": {
-                "1": { "name": "keyword.control.conditional.renpy" },
-                "2": {
-                  "patterns": [{ "include": "source.renpy.python#expression-bare" }]
-                }
-              }
-            },
+            { "include": "#strings" },
             {
-              "match": "[^ \\t]+",
-              "name": "invalid.illegal.unexpected-characters-in-menu-arguments.renpy"
+              "match": "\\b(?:[a-zA-Z_0-9]+)\\b[ \\t]*",
+              "name": "entity.name.type.image.renpy"
             }
           ]
         },
-        "4": { "name": "punctuation.section.menu-option.begin.renpy" }
-      },
-      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
-      "patterns": [{ "include": "#statements" }, { "include": "#expressions" }]
-    },
-    "literal": {
-      "patterns": [
-        {
-          "comment": "Python literals",
-          "name": "constant.language.renpy",
-          "match": "\\b(?<!\\.)(True|False|None)\\b"
-        }
+        { "include": "#at-statement" },
+        { "include": "#with-statement" }
       ]
     },
-    "audio": {
-      "patterns": [{ "include": "#play" }, { "include": "#stop" }]
-    },
-    "builtin-audio-channels": {
-      "name": "support.type.audio.channel.renpy",
-      "match": "(?<!\\.)\\b(?:music|sound|voice|audio)\\b"
-    },
-    "play": {
+    "show": {
       "patterns": [
         {
-          "name": "meta.$1.renpy",
-          "begin": "^[ \\t]*(play|queue)\\b[ \\t]+\\b([a-zA-Z_0-9]*)\\b[ \\t]*",
+          "name": "meta.show.statement.renpy",
+          "contentName": "meta.atl-block.renpy",
+          "begin": "^([ \\t]+)?(show)\\b[ \\t]*([a-zA-Z_0-9 ]*)(:)",
           "beginCaptures": {
-            "1": { "name": "keyword.renpy" },
-            "2": {
-              "patterns": [
-                { "include": "#builtin-audio-channels" },
-                {
-                  "match": ".*",
-                  "name": "entity.name.type.audio.channel.renpy"
-                }
-              ]
-            }
+            "1": { "name": "punctuation.whitespace.leading.renpy" },
+            "2": { "name": "keyword.show.renpy" },
+            "3": { "name": "entity.name.type.image.renpy" },
+            "4": { "name": "punctuation.section.atl.begin.renpy" }
           },
-          "end": "(?=[ \\t]*#)|$",
-          "patterns": [{ "include": "#strings" }, { "include": "#audio-params" }, { "include": "source.renpy.python#expression" }]
-        }
-      ]
-    },
-    "stop": {
-      "patterns": [
+          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+          "patterns": [{ "include": "source.renpy.atl" }]
+        },
         {
-          "name": "meta.stop.renpy",
-          "begin": "^[ \\t]*(stop)\\b[ \\t]+\\b([a-zA-Z_0-9]*)\\b[ \\t]*",
+          "name": "meta.show.statement.renpy",
+          "begin": "(?<=^[ \\t]*)(show)\\b[ \\t]*",
           "beginCaptures": {
-            "1": { "name": "keyword.renpy" },
-            "2": {
-              "patterns": [
-                { "include": "#builtin-audio-channels" },
-                {
-                  "match": ".*",
-                  "name": "entity.name.type.audio.channel.renpy"
-                }
-              ]
-            }
+            "1": { "name": "keyword.show.renpy" }
           },
-          "end": "(?=[ \\t]*#)|$",
+          "end": "(?=\\b(at|as|behind|onlayer|expression|with|zorder)\\b|#)|$",
           "patterns": [
+            { "include": "#strings" },
             {
-              "name": "keyword.renpy",
-              "match": "\\b(?<!\\.)(?:fadeout)\\b"
-            },
-            { "include": "source.renpy.python#number" }
+              "match": "\\b(?:[a-zA-Z_0-9]+)\\b[ \\t]*",
+              "name": "entity.name.type.image.renpy"
+            }
           ]
-        }
-      ]
-    },
-    "audio-params": {
-      "patterns": [
-        {
-          "name": "keyword.renpy",
-          "match": "\\b(?<!\\.)(?:fadeout|fadein|volume|loop|noloop)\\b"
         },
-        { "include": "source.renpy.python#number" }
+        { "include": "#at-statement" },
+        { "include": "#as-statement" },
+        { "include": "#with-statement" },
+        { "include": "#behind" },
+        { "include": "#onlayer" },
+        { "include": "#zorder" }
       ]
     },
-    "keywords": {
+    "scene": {
       "patterns": [
         {
-          "comment": "Control flow keywords",
-          "name": "keyword.control.flow.renpy",
-          "match": "\\b(?<!\\.)(?:pass|return)\\b"
-        },
-        {
-          "comment": "Control flow keywords with block",
-          "begin": "\\b(?<!\\.)(?:(if|elif|else)|(for|while))\\b",
-          "contentName": "meta.embedded.line.python",
+          "name": "meta.scene.statement.renpy",
+          "contentName": "meta.atl-block.renpy",
+          "begin": "^([ \\t]+)?(scene)\\b[ \\t]*([a-zA-Z_0-9 ]*)(:)",
           "beginCaptures": {
-            "1": { "name": "keyword.control.conditional.renpy" },
-            "2": { "name": "keyword.control.flow.renpy" }
-          },
-          "end": ":|$",
-          "endCaptures": {
-            "0": { "name": "punctuation.section.block.begin.renpy" }
+            "1": { "name": "punctuation.whitespace.leading.renpy" },
+            "2": { "name": "keyword.scene.renpy" },
+            "3": { "name": "entity.name.type.image.renpy" },
+            "4": { "name": "punctuation.section.atl.begin.renpy" }
           },
-          "patterns": [{ "include": "#expressions" }, { "include": "source.renpy.python#expression" }]
-        },
-        {
-          "comment": "Python statement keywords",
-          "match": "\\b(?<!\\.)(init|python|hide|early|in|define|default)\\b",
-          "name": "keyword.renpy"
-        },
-        {
-          "comment": "Renpy keywords",
-          "match": "\\b(?<!\\.)(?:camera|image|label|layeredimage|menu|nvl[ \\t]+clear|play|queue|scene|screen|show|transform|translate|voice(?:[ \\t]+sustain)?|window|frame)\\b",
-          "name": "keyword.other.renpy"
+          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+          "patterns": [{ "include": "source.renpy.atl" }]
         },
         {
-          "match": "^[ \\t]+(pause)\\b[ \\t]*([^#]*)",
-          "captures": {
-            "1": { "name": "keyword.control.flow.renpy" },
-            "2": {
-              "patterns": [
-                { "include": "#num-float" },
-                { "include": "#num-int" },
-                {
-                  "match": ".*",
-                  "name": "invalid.illegal.dec.renpy"
-                }
-              ]
+          "name": "meta.scene.statement.renpy",
+          "begin": "(?<=^[ \\t]*)(scene)\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.scene.renpy" }
+          },
+          "end": "(?=\\b(at|as|behind|onlayer|expression|with|zorder)\\b|#)|$",
+          "patterns": [
+            { "include": "#strings" },
+            {
+              "match": "\\b(?:[a-zA-Z_0-9]+)\\b[ \\t]*",
+              "name": "entity.name.type.image.renpy"
             }
-          }
+          ]
         },
-        {
-          "comment": "[TODO: Should probably only be a keyword in the expression] Renpy sub expression keywords",
-          "name": "keyword.other.renpy",
-          "match": "\\b(?<!\\.)(?:set|expression|at|with|from)\\b"
-        }
+        { "include": "#at-statement" },
+        { "include": "#as-statement" },
+        { "include": "#with-statement" },
+        { "include": "#behind" },
+        { "include": "#onlayer" },
+        { "include": "#zorder" }
       ]
     },
-    "comments": {
+    "camera": {
       "patterns": [
         {
-          "name": "comment.line.number-sign.renpy",
-          "match": "^[ \\t]*(#[ \\t]*(?:end)?region)\\b.*$",
-          "captures": {
-            "1": { "name": "punctuation.definition.tag" }
-          }
+          "name": "meta.camera.statement.renpy",
+          "contentName": "meta.atl-block.renpy",
+          "begin": "^([ \\t]+)?(camera)\\b[ \\t]*(:)",
+          "beginCaptures": {
+            "1": { "name": "punctuation.whitespace.leading.renpy" },
+            "2": { "name": "keyword.camera.renpy" },
+            "3": { "name": "entity.name.type.image.renpy" },
+            "4": { "name": "punctuation.section.atl.begin.renpy" }
+          },
+          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+          "patterns": [{ "include": "source.renpy.atl" }]
         },
         {
-          "name": "comment.line.number-sign.renpy",
-          "match": "(#)(.*)$",
-          "captures": {
-            "1": { "name": "punctuation.definition.comment.renpy" },
-            "2": {
-              "patterns": [
-                {
-                  "comment": "Code Tags",
-                  "match": "(?:\\b(NOTE|XXX|HACK|FIXME|BUG|TODO)\\b)",
-                  "captures": {
-                    "1": { "name": "keyword.codetag.notation.renpy" }
-                  }
-                }
-              ]
+          "name": "meta.camera.statement.renpy",
+          "begin": "(?<=^[ \\t]*)(camera)\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.camera.renpy" }
+          },
+          "end": "(?=\\b(at|with)\\b|#)|$",
+          "patterns": [
+            {
+              "match": "\\b(?:[a-zA-Z_0-9]+)\\b[ \\t]*",
+              "name": "entity.name.type.image.renpy"
             }
-          }
-        }
+          ]
+        },
+        { "include": "#at-statement" },
+        { "include": "#with-statement" }
       ]
     },
-    "strings-interior": {
-      "patterns": [{ "include": "#escaped_char" }, { "include": "#string-tags" }, { "include": "#constant_placeholder" }]
-    },
-    "escaped_char": {
-      "match": "(\\\\\")|(\\\\')|(\\\\ )|(\\\\n)|(\\\\\\\\)|(\\[\\[)|({{)",
+    "style-old": {
+      "match": "^\\s*(style)\\s+([a-zA-Z_][a-zA-Z_0-9]*)",
       "captures": {
-        "1": { "name": "constant.character.escape.double-quote.python.renpy" },
-        "2": { "name": "constant.character.escape.single-quote.python.renpy" },
-        "3": { "name": "constant.character.escape.space.python.renpy" },
-        "4": { "name": "constant.character.escape.newline.python.renpy" },
-        "5": { "name": "constant.character.escape.backslash.python.renpy" },
-        "6": { "name": "constant.character.escape.placeholder.python.renpy" },
-        "7": { "name": "constant.character.escape.placeholder.python.renpy" }
+        "1": { "name": "keyword.python.renpy" },
+        "2": { "name": "entity.name.tag.python.renpy.style.renpy" }
       }
     },
-    "escaped_unicode_char": {
-      "match": "(\\\\U[0-9A-Fa-f]{8})|(\\\\u[0-9A-Fa-f]{4})|(\\\\N\\{[a-zA-Z ]+\\})",
+    "use-old": {
+      "match": "^\\s*(use)\\s+([a-zA-Z_][a-zA-Z_0-9]*)",
       "captures": {
-        "1": { "name": "constant.character.escape.unicode.16-bit-hex.python.renpy" },
-        "2": { "name": "constant.character.escape.unicode.32-bit-hex.python.renpy" },
-        "3": { "name": "constant.character.escape.unicode.name.python.renpy" }
+        "1": { "name": "keyword.python.renpy" },
+        "2": { "name": "entity.name.class.python.renpy.screen.renpy" }
       }
     },
-    "constant_placeholder": {
-      "comment": "Python value interpolation using [ ... ]",
-      "name": "meta.brackets.renpy constant.other.placeholder.tags.renpy",
-      "match": "(\\[)(.*?)(\\])(?![^\\[]*?\\])",
-      "captures": {
-        "1": { "name": "constant.character.format.placeholder.other.renpy" },
-        "2": { "name": "meta.embedded.line.python source.renpy.python#expression" },
-        "3": { "name": "constant.character.format.placeholder.other.renpy" }
-      }
+    "builtin-screens": {
+      "comment": "TODO: Should combine this with builtin-labels",
+      "name": "support.function.builtin.renpy",
+      "match": "(?<!\\.)\\b(?:start|quit|after_load|splashscreen|before_main_menu|main_menu|after_warp|hide_windows)\\b"
     },
-    "hex_literal": {
-      "comment": "Note: This pattern has no end check. Only use as include pattern!",
+    "screen-language": {
+      "comment": "https://www.renpy.org/doc/html/screens.html#screen-language",
+      "patterns": [{ "include": "#screen-frame" }, { "include": "#screen-window" }, { "include": "#screen-text" }, { "include": "#screen-keywords" }, { "include": "#screen-simple-expression" }]
+    },
+    "screen-def-name": {
+      "comment": "TODO: Should combine this with label-def-name",
       "patterns": [
+        { "include": "source.renpy.python#builtin-possible-callables" },
+        { "include": "#builtin-screens" },
         {
-          "comment": "rgb, rgba, rrggbb, rrggbbaa",
-          "match": "(?i)#(?:[a-f0-9]{8}|[a-f0-9]{6}|[a-f0-9]{3,4})\\b",
-          "name": "support.constant.color.renpy"
-        },
-        {
-          "match": "(?i)#[a-f0-9]+\\b",
-          "name": "invalid.illegal.unexpected-number-of-hex-values.renpy"
-        },
-        {
-          "match": "(?i)(?:#[a-f0-9]*)?(.+)",
-          "name": "support.constant.color.renpy",
+          "match": "(?<=^|[ \\t])(\\b(?:[a-zA-Z_]\\w*)\\b)?(\\.)?(\\b(?:[a-zA-Z_]\\w*)\\b)",
           "captures": {
-            "1": { "name": "invalid.illegal.character-not-allowed-here.renpy" }
+            "1": { "name": "entity.name.function.renpy" },
+            "2": { "name": "punctuation.separator.period.renpy" },
+            "3": { "name": "entity.name.function.renpy" }
           }
         }
       ]
     },
-    "string-tags": {
+    "screen-simple-expression": {
+      "patterns": [
+        { "include": "#expressions" },
+        { "include": "source.renpy.python#literal" },
+        { "include": "source.renpy.python#member-access" },
+        { "include": "source.renpy.python#illegal-operator" },
+        { "include": "source.renpy.python#operator" },
+        { "include": "source.renpy.python#curly-braces" },
+        { "include": "source.renpy.python#item-access" },
+        { "include": "source.renpy.python#list" },
+        { "include": "source.renpy.python#odd-function-call" },
+        { "include": "source.renpy.python#round-braces" },
+        { "include": "source.renpy.python#function-call" },
+        { "include": "source.renpy.python#builtin-functions" },
+        { "include": "source.renpy.python#builtin-types" },
+        { "include": "source.renpy.python#builtin-exceptions" },
+        { "include": "source.renpy.python#magic-names" },
+        { "include": "source.renpy.python#special-names" },
+        { "include": "source.renpy.python#illegal-names" },
+        { "include": "source.renpy.python#special-variables" },
+        { "include": "source.renpy.python#ellipsis" },
+        { "include": "source.renpy.python#punctuation" },
+        { "include": "source.renpy.python#line-continuation" }
+      ]
+    },
+    "screen-keywords": {
+      "comment": "https://www.renpy.org/doc/html/screens.html#screen-statement",
       "patterns": [
         {
-          "comment": "Valid tags without params (self-closing)",
-          "name": "meta.tag.${2:/downcase}.self-closing.renpy",
-          "match": "({)\\s*(nw|done|fast|p|w|clear)\\s*(})",
-          "captures": {
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.definition.tag.end.renpy" }
-          }
-        },
-        {
-          "comment": "Valid tags with numeric params (self-closing)",
-          "name": "meta.tag.${2:/downcase}.self-closing.renpy",
-          "match": "({)\\s*(p|w)(=)(\\+?)(\\d*(?:.\\d+)?)\\s*(})",
-          "captures": {
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
-            "4": { "name": "keyword.operator.arithmetic.renpy" },
-            "5": { "name": "support.constant.property-value constant.numeric.float.renpy" },
-            "6": { "name": "punctuation.definition.tag.end.renpy" }
-          }
+          "contentName": "meta.screen.sensitive.renpy",
+          "begin": "(?<=^[ \\t]*)(sensitive)\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.sensitive.renpy" }
+          },
+          "end": "$",
+          "patterns": [{ "include": "#screen-simple-expression" }]
         },
         {
-          "comment": "Valid tags with numeric params (self-closing)",
-          "name": "meta.tag.${2:/downcase}.self-closing.renpy",
-          "match": "({)\\s*(v?space)(=)(\\+?)(\\d+)\\s*(})",
-          "captures": {
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
-            "4": { "name": "keyword.operator.arithmetic.renpy" },
-            "5": { "name": "support.constant.property-value constant.numeric.integer.renpy" },
-            "6": { "name": "punctuation.definition.tag.end.renpy" }
-          }
+          "name": "keyword.other.renpy",
+          "match": "\\b(?<!\\.)(?:modal|sensitive|tag|zorder|variant|layer|roll_forward|text)\\b"
         },
         {
-          "comment": "Comment tag (self-closing)",
-          "name": "meta.tag.comment.self-closing.renpy",
-          "match": "({)\\s*(#)\\s*(.*?)\\s*(})",
-          "captures": {
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "comment.line.number-sign.renpy punctuation.definition.comment.renpy" },
-            "3": { "name": "comment.line.number-sign.renpy" },
-            "4": { "name": "punctuation.definition.tag.end.renpy" }
-          }
+          "name": "keyword.other.renpy",
+          "match": "\\b(?<!\\.)(?:style|style_group|style_prefix)\\b"
         },
         {
-          "comment": "Valid tags with file param",
-          "name": "meta.tag.${2:/downcase}.self-closing.renpy",
-          "match": "({)\\s*(image)(=)([\\w.]+)\\s*(})",
-          "captures": {
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
-            "4": { "name": "support.constant.property-value string.unquoted.renpy" },
-            "5": { "name": "punctuation.definition.tag.end.renpy" }
-          }
-        },
-        {
-          "comment": "Valid tags without params (close required)",
-          "contentName": "renpy.meta.${2:/downcase}",
-          "begin": "({)\\s*(u|i|b|s|plain|alt|noalt|art|rb|rt)\\s*(})",
-          "beginCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.start.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.definition.tag.end.renpy" }
-          },
-          "end": "({/)\\s*(\\2)\\s*(})",
-          "endCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.end.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.definition.tag.end.renpy" }
-          },
-          "patterns": [{ "include": "#strings-interior" }]
-        },
-        {
-          "comment": "Valid tags with numeric params (close required)",
-          "contentName": "renpy.meta.${2:/downcase}",
-          "begin": "({)\\s*(alpha|cps|k)(=)([*\\-+]?)(\\d*(?:.\\d+)?)\\s*(})",
-          "beginCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.start.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
-            "4": { "name": "keyword.operator.arithmetic.renpy" },
-            "5": { "name": "support.constant.property-value constant.numeric.renpy" },
-            "6": { "name": "punctuation.definition.tag.end.renpy" }
-          },
-          "end": "({/)\\s*(\\2)\\s*(})",
-          "endCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.end.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.definition.tag.end.renpy" }
-          },
-          "patterns": [{ "include": "#strings-interior" }]
-        },
-        {
-          "comment": "Valid tags with numeric params (close required)",
-          "contentName": "renpy.meta.${2:/downcase}",
-          "begin": "({)\\s*(size)(=)([\\-+]?)(\\d+)\\s*(})",
-          "beginCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.start.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
-            "4": { "name": "keyword.operator.arithmetic.renpy" },
-            "5": { "name": "support.constant.property-value constant.numeric.integer.renpy" },
-            "6": { "name": "punctuation.definition.tag.end.renpy" }
-          },
-          "end": "({/)\\s*(\\2)\\s*(})",
-          "endCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.end.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.definition.tag.end.renpy" }
-          },
-          "patterns": [{ "include": "#strings-interior" }]
-        },
+          "name": "keyword.other.renpy",
+          "match": "\\b(?<!\\.)(?:has|vbox|label|add|xfill)\\b"
+        }
+      ]
+    },
+    "screen-frame": {
+      "contentName": "meta.screen.frame.renpy",
+      "begin": "^([ \\t]+)?(frame)\\b[ \\t]*(:)",
+      "beginCaptures": {
+        "1": { "name": "punctuation.whitespace.leading.block.renpy" },
+        "2": { "name": "keyword.frame.renpy" },
+        "3": { "name": "punctuation.section.block.begin.renpy" }
+      },
+      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+      "patterns": [{ "include": "#screen-language" }]
+    },
+    "screen-window": {
+      "contentName": "meta.screen.window.renpy",
+      "begin": "^([ \\t]+)?(window)\\b[ \\t]*(:)",
+      "beginCaptures": {
+        "1": { "name": "punctuation.whitespace.leading.block.renpy" },
+        "2": { "name": "keyword.window.renpy" },
+        "3": { "name": "punctuation.section.block.begin.renpy" }
+      },
+      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+      "patterns": [{ "include": "#screen-language" }]
+    },
+    "screen-text": {
+      "contentName": "meta.screen.text.renpy",
+      "begin": "^([ \\t]+)?(text)\\b[ \\t]*(:)",
+      "beginCaptures": {
+        "1": { "name": "punctuation.whitespace.leading.block.renpy" },
+        "2": { "name": "keyword.text.renpy" },
+        "3": { "name": "punctuation.section.block.begin.renpy" }
+      },
+      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+
+      "patterns": [
         {
-          "comment": "Valid tags with file param (close required)",
-          "name": "meta.tag.${2:/downcase}.self-closing.renpy",
-          "begin": "({)\\s*(font)(=)([\\w.]+)\\s*(})",
+          "name": "meta.screen.text.renpy",
+          "contentName": "meta.atl-block.renpy",
+          "begin": "^([ \\t]+)?(text)\\b[ \\t]*([a-zA-Z_0-9 ]*)(:)",
           "beginCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.start.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
-            "4": { "name": "support.constant.property-value string.unquoted.renpy" },
-            "5": { "name": "punctuation.definition.tag.end.renpy" }
-          },
-          "end": "({/)\\s*(\\2)\\s*(})",
-          "endCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.end.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.definition.tag.end.renpy" }
+            "1": { "name": "punctuation.whitespace.leading.renpy" },
+            "2": { "name": "keyword.text.renpy" },
+            "3": { "name": "entity.name.type.text.renpy" },
+            "4": { "name": "punctuation.section.atl.begin.renpy" }
           },
-          "patterns": [{ "include": "#strings-interior" }]
+          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+          "patterns": [{ "include": "source.renpy.atl" }]
         },
         {
-          "comment": "Color tag",
-          "contentName": "renpy.meta.${2:/downcase}.${4:/downcase}",
-          "begin": "({)\\s*(color|outlinecolor)(=)(#?[a-zA-Z0-9]+)\\s*(})",
+          "name": "meta.screen.text.renpy",
+          "begin": "(?<=^[ \\t]*)(text)\\b[ \\t]*",
           "beginCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.start.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
-            "4": {
-              "name": "support.constant.property-value",
-              "patterns": [{ "include": "#hex_literal" }]
-            },
-            "5": { "name": "punctuation.definition.tag.end.renpy" }
-          },
-          "end": "({/)\\s*(\\2)\\s*(})",
-          "endCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.end.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.definition.tag.end.renpy" }
+            "1": { "name": "keyword.text.renpy" }
           },
-          "patterns": [{ "include": "#strings-interior" }]
+          "end": "(?=\\b(at)\\b|#|=)|$",
+          "patterns": [
+            { "include": "#strings" },
+            {
+              "match": "\\b(?:[a-zA-Z_0-9]+)\\b[ \\t]*",
+              "name": "entity.name.type.text.renpy"
+            }
+          ]
         },
+        { "include": "#at-statement" }
+      ]
+    },
+    "screen": {
+      "patterns": [
         {
-          "comment": "a tag",
-          "contentName": "renpy.meta.${2:/downcase}",
-          "begin": "({)\\s*(a)(=)(.*?)\\s*(})",
+          "comment": "See https://www.renpy.org/doc/html/screens.html",
+          "contentName": "meta.screen.block.renpy",
+          "begin": "^([ \\t]+)?(screen)\\b[ \\t]*(.*?)(:)",
           "beginCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.start.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
-            "4": {
-              "name": "support.constant.property-value string.unquoted.renpy",
-              "patterns": []
+            "1": { "name": "punctuation.whitespace.leading.block.renpy" },
+            "2": { "name": "storage.type.function.renpy" },
+            "3": {
+              "patterns": [{ "include": "#screen-def-name" }, { "include": "source.renpy.python#parameters" }, { "include": "#invalid-token" }]
             },
-            "5": { "name": "punctuation.definition.tag.end.renpy" }
-          },
-          "end": "({/)\\s*(\\2)\\s*(})",
-          "endCaptures": {
-            "0": { "name": "meta.tag.${2:/downcase}.end.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.definition.tag.end.renpy" }
+            "4": { "name": "punctuation.section.block.begin.renpy" }
           },
-          "patterns": [{ "include": "#strings-interior" }]
-        },
+          "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+          "patterns": [{ "include": "#screen-language" }]
+        }
+      ]
+    },
+    "builtin-labels": {
+      "name": "support.function.builtin.renpy",
+      "match": "(?<!\\.)\\b(?:start|quit|after_load|splashscreen|before_main_menu|main_menu|after_warp|hide_windows)\\b"
+    },
+    "label-name": {
+      "patterns": [
+        { "include": "source.renpy.python#builtin-possible-callables" },
+        { "include": "#builtin-labels" },
         {
-          "comment": "Unknown tag (Single line support only cus \\R does not work) (Since we don't know if a tag is self closing, we can't assume that an end pattern exists)",
-          "match": "({)[ \\t]*(\\w+)\\b(?:(=)(.*?))?\\s*(})((?:.|\\R)+?)\\s*({/)\\s*(\\2)\\s*(})",
-          "captures": {
-            "1": { "name": "meta.tag.${2:/downcase}.start.renpy punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "renpy.meta.u meta.tag.${2:/downcase}.start.renpy entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "meta.tag.${2:/downcase}.start.renpy punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
-            "4": { "name": "meta.tag.${2:/downcase}.start.renpy constant.other.placeholder.tags.renpy" },
-            "5": { "name": "meta.tag.${2:/downcase}.start.renpy punctuation.definition.tag.end.renpy" },
-            "6": {
-              "name": "renpy.meta.tag.custom.${2:/downcase}",
-              "patterns": [{ "include": "#strings-interior" }]
-            },
-            "7": { "name": "meta.tag.${2:/downcase}.end.renpy punctuation.definition.tag.begin.renpy" },
-            "8": { "name": "renpy.meta.u meta.tag.${2:/downcase}.end.renpy entity.name.tag.${2:/downcase}.renpy" },
-            "9": { "name": "meta.tag.${2:/downcase}.end.renpy punctuation.definition.tag.end.renpy" }
-          }
-        },
+          "name": "entity.name.function.renpy",
+          "match": "\\b(?:[a-zA-Z_]\\w*)\\b"
+        }
+      ]
+    },
+    "label-call": {
+      "comment": "Note: label params are only allowed at the end of the access expression",
+      "name": "meta.function-call.label.renpy",
+      "begin": "\\b(?=([a-zA-Z_]\\w*)\\s*(\\())",
+      "end": "(\\))",
+      "endCaptures": {
+        "1": { "name": "punctuation.definition.arguments.end.renpy" }
+      },
+      "patterns": [{ "include": "source.renpy.python#special-variables" }, { "include": "#label-name" }, { "include": "source.renpy.python#function-arguments" }]
+    },
+    "label-access": {
+      "comment": "Note: Labels can't be nested twice in a row!",
+      "name": "meta.member.access.label.renpy",
+      "begin": "(\\.)\\s*(?!\\.)",
+      "end": "(?<=\\S)(?=\\W)|(^|(?<=\\s))(?=[^\\\\\\w\\s])|$",
+      "beginCaptures": {
+        "1": { "name": "punctuation.separator.period.renpy" }
+      },
+      "patterns": [{ "include": "#label-call" }, { "include": "#label-name" }]
+    },
+    "label-def-name": {
+      "comment": "Note: Labels can't be nested twice in a row!",
+      "patterns": [
+        { "include": "source.renpy.python#builtin-possible-callables" },
+        { "include": "#builtin-labels" },
         {
-          "comment": "Unknown tag start",
-          "match": "({)\\s*(\\w*)(?:(=)(.*?))?\\s*(})",
+          "match": "(?<=^|[ \\t])(\\b(?:[a-zA-Z_]\\w*)\\b)?(\\.)?(\\b(?:[a-zA-Z_]\\w*)\\b)",
           "captures": {
-            "0": { "name": "meta.tag.${2:/downcase}.start.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "renpy.meta.u entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.separator.key-value.renpy keyword.operator.assignment.renpy" },
-            "4": {
-              "name": "support.constant.property-value constant.other.placeholder.tags.renpy",
-              "patterns": []
-            },
-            "5": { "name": "punctuation.definition.tag.end.renpy" }
+            "1": { "name": "entity.name.function.renpy" },
+            "2": { "name": "punctuation.separator.period.renpy" },
+            "3": { "name": "entity.name.function.renpy" }
           }
+        }
+      ]
+    },
+    "label": {
+      "name": "meta.label.statement.renpy",
+      "match": "(?<=^[ \\t]*)(label)\\b[ \\t]*(.*?)(?:[ \\t]*(hide))?(:)",
+      "captures": {
+        "1": { "name": "storage.type.function.label.renpy" },
+        "2": {
+          "patterns": [{ "include": "#label-def-name" }, { "include": "source.renpy.python#parameters" }, { "include": "#invalid-token" }]
         },
+        "3": { "name": "keyword.hide.renpy" },
+        "4": { "name": "punctuation.section.label.begin.renpy" }
+      }
+    },
+    "return-statements": {
+      "begin": "(?<=^[ \\t]+)(return)\\b[ \\t]*",
+      "beginCaptures": {
+        "1": { "name": "keyword.control.flow.return.renpy" }
+      },
+      "end": "$",
+      "patterns": [{ "include": "#expressions" }, { "include": "source.renpy.python#expression" }]
+    },
+    "call-jump-expression": {
+      "begin": "\\b(?<!\\.)(expression)\\b",
+      "beginCaptures": {
+        "1": { "name": "keyword.expression.renpy" }
+      },
+      "end": "(?=\\b(?<!\\.)(?:pass|from)\\b)|$",
+      "patterns": [{ "include": "#expressions" }, { "include": "source.renpy.python#expression" }]
+    },
+    "jump": {
+      "name": "meta.jump.statement.renpy",
+      "begin": "(?<=^[ \\t]+)(jump)\\b[ \\t]*",
+      "beginCaptures": {
+        "1": { "name": "keyword.control.flow.jump.renpy" }
+      },
+      "end": "(?=#)|$",
+      "endCaptures": {
+        "1": { "name": "invalid.illegal.renpy" }
+      },
+      "patterns": [
+        { "include": "#call-jump-expression" },
         {
-          "comment": "Unknown tag end",
-          "match": "({/)\\s*(\\w*?)\\b\\s*(})",
-          "captures": {
-            "0": { "name": "meta.tag.${2:/downcase}.end.renpy" },
-            "1": { "name": "punctuation.definition.tag.begin.renpy" },
-            "2": { "name": "renpy.meta.u entity.name.tag.${2:/downcase}.renpy" },
-            "3": { "name": "punctuation.definition.tag.end.renpy" }
-          }
+          "comment": "Label expression",
+          "begin": "(?=[a-zA-Z_.])",
+          "end": "(?![a-zA-Z_.])(?![ \\t]*\\.[ \\t]*)",
+          "patterns": [{ "include": "#label-access" }, { "include": "#label-name" }]
         }
       ]
     },
-    "strings": {
-      "name": "string.quoted.renpy",
-      "begin": "\"\"\"|\"|'''|'|```|`",
+    "call-pass": {
+      "begin": "\\b(?<!\\.)(pass)\\b[ \\t]*(?=\\()",
       "beginCaptures": {
-        "0": { "name": "punctuation.definition.string.begin.renpy" }
+        "1": { "name": "keyword.pass.renpy" }
       },
-      "end": "(?<![^\\\\]\\\\)(((?<=\\0)\\0)|\\0)",
+      "end": "(\\))",
       "endCaptures": {
-        "1": { "name": "punctuation.definition.string.end.renpy" },
-        "2": { "name": "meta.empty-string.renpy" }
+        "1": { "name": "punctuation.definition.arguments.end.renpy" }
       },
-      "patterns": [{ "include": "#strings-interior" }]
+      "patterns": [{ "include": "source.renpy.python#function-arguments" }]
+    },
+    "call-from": {
+      "begin": "\\b(?<!\\.)(from)\\b[ \\t]*",
+      "beginCaptures": {
+        "1": { "name": "keyword.control.flow.from.renpy" }
+      },
+      "end": "(?=\\W|$)",
+      "patterns": [{ "include": "#label-name" }]
+    },
+    "call": {
+      "name": "meta.call.statement.renpy",
+      "begin": "(?<=^[ \\t]+)(call)\\b[ \\t]*",
+      "beginCaptures": {
+        "1": { "name": "keyword.control.flow.call.renpy" }
+      },
+      "end": "(?=#)|$",
+      "endCaptures": {
+        "1": { "name": "invalid.illegal.renpy" }
+      },
+      "patterns": [
+        { "include": "#call-jump-expression" },
+        { "include": "#call-pass" },
+        {
+          "comment": "Label expression",
+          "begin": "(?=[a-zA-Z_.])",
+          "end": "(?![a-zA-Z_.])(?![ \\t]*\\.[ \\t]*)",
+          "patterns": [{ "include": "#label-call" }, { "include": "#label-access" }, { "include": "#label-name" }]
+        },
+        { "include": "#call-from" }
+      ]
+    },
+    "menu-option": {
+      "contentName": "meta.menu-option.block.renpy",
+      "begin": "^([ \\t]+)?((?:\".*\")|(?:'.*')|(?:\"\"\".*\"\"\"))[ \\t]*(.+)?(:)",
+      "beginCaptures": {
+        "1": { "name": "punctuation.whitespace.menu-option.leading.renpy" },
+        "2": {
+          "name": "meta.menu-option.renpy",
+          "patterns": [{ "include": "#strings" }]
+        },
+        "3": {
+          "name": "meta.embedded.line.python",
+          "patterns": [
+            { "include": "source.renpy.python#function-arguments" },
+            {
+              "comment": "if condition",
+              "match": "\\b(if)[ \\t]+(.+)?",
+              "captures": {
+                "1": { "name": "keyword.control.conditional.renpy" },
+                "2": {
+                  "patterns": [{ "include": "source.renpy.python#expression-bare" }]
+                }
+              }
+            },
+            {
+              "match": "[^ \\t]+",
+              "name": "invalid.illegal.unexpected-characters-in-menu-arguments.renpy"
+            }
+          ]
+        },
+        "4": { "name": "punctuation.section.menu-option.begin.renpy" }
+      },
+      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+      "patterns": [{ "include": "#base-patterns" }]
+    },
+    "menu-set": {
+      "match": "(?<=^[ \\t]+)(set)[ \\t]+(.+)?",
+      "captures": {
+        "1": { "name": "keyword.set.renpy" },
+        "2": {
+          "name": "meta.embedded.line.python",
+          "patterns": [{ "include": "source.renpy.python#expression-bare" }]
+        }
+      }
+    },
+    "menu": {
+      "name": "meta.menu.statement.renpy",
+      "contentName": "meta.menu.block.renpy",
+      "begin": "^([ \\t]+)?(menu)[ \\t]*(.+)?(:)",
+      "beginCaptures": {
+        "1": { "name": "punctuation.whitespace.menu.leading.renpy" },
+        "2": { "name": "storage.type.function.renpy" },
+        "3": {
+          "patterns": [
+            {
+              "comment": "Menu name",
+              "match": "[a-zA-Z_.]\\w*",
+              "name": "entity.name.function.renpy"
+            },
+            { "include": "source.renpy.python#function-arguments" }
+          ]
+        },
+        "4": { "name": "punctuation.section.menu.begin.renpy" }
+      },
+      "end": "^(?=(?!\\1)[ \\t]*[^\\s#]|\\1[^\\s#])",
+      "patterns": [{ "include": "#comments" }, { "include": "#menu-option" }, { "include": "#say-statements" }, { "include": "#menu-set" }, { "include": "#fallback-characters" }]
+    },
+    "builtin-audio-channels": {
+      "name": "support.type.audio.channel.renpy",
+      "match": "(?<!\\.)\\b(?:music|sound|voice|audio)\\b"
+    },
+    "audio-channel": {
+      "patterns": [
+        { "include": "#builtin-audio-channels" },
+        {
+          "match": ".+",
+          "name": "entity.name.type.audio.channel.renpy"
+        }
+      ]
+    },
+    "audio-params": {
+      "patterns": [
+        {
+          "name": "keyword.other.audio.renpy",
+          "match": "\\b(?<!\\.)(?:fadeout|fadein|volume|loop|noloop)\\b"
+        },
+        { "include": "source.renpy.python#number" }
+      ]
+    },
+    "play": {
+      "patterns": [
+        {
+          "name": "meta.play.audio.statement.renpy",
+          "begin": "(?<=^[ \\t]*)(play)\\b[ \\t]+\\b([a-zA-Z_0-9]*)\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.play.renpy" },
+            "2": {
+              "patterns": [{ "include": "#audio-channel" }]
+            }
+          },
+          "end": "(?=[ \\t]*#)|$",
+          "patterns": [{ "include": "#strings" }, { "include": "#audio-params" }, { "include": "source.renpy.python#expression" }]
+        }
+      ]
+    },
+    "queue": {
+      "patterns": [
+        {
+          "name": "meta.queue.audio.statement.renpy",
+          "begin": "(?<=^[ \\t]*)(queue)\\b[ \\t]+\\b([a-zA-Z_0-9]*)\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.queue.renpy" },
+            "2": {
+              "patterns": [{ "include": "#audio-channel" }]
+            }
+          },
+          "end": "(?=[ \\t]*#)|$",
+          "patterns": [{ "include": "#strings" }, { "include": "#audio-params" }, { "include": "source.renpy.python#expression" }]
+        }
+      ]
+    },
+    "stop": {
+      "patterns": [
+        {
+          "name": "meta.stop.audio.statement.renpy",
+          "begin": "(?<=^[ \\t]*)(stop)\\b[ \\t]+\\b([a-zA-Z_0-9]*)\\b[ \\t]*",
+          "beginCaptures": {
+            "1": { "name": "keyword.stop.renpy" },
+            "2": {
+              "patterns": [{ "include": "#audio-channel" }]
+            }
+          },
+          "end": "(?=[ \\t]*#)|$",
+          "patterns": [
+            {
+              "name": "keyword.fadeout.renpy",
+              "match": "\\b(?<!\\.)(?:fadeout)\\b"
+            },
+            { "include": "source.renpy.python#number" }
+          ]
+        }
+      ]
+    },
+    "audio": {
+      "patterns": [{ "include": "#play" }, { "include": "#queue" }, { "include": "#stop" }]
+    },
+
+    "renpy-statements": {
+      "patterns": [
+        { "include": "#label" },
+        { "include": "#menu" },
+        { "include": "#image" },
+        { "include": "#audio" },
+        { "include": "#pause" },
+        { "include": "#transform" },
+        { "include": "#scene" },
+        { "include": "#camera" },
+        { "include": "#show" },
+        { "include": "#with-statement" },
+        { "include": "#style-old" },
+        { "include": "#use-old" },
+        { "include": "#screen" },
+        { "include": "#return-statements" },
+        { "include": "#jump" },
+        { "include": "#call" }
+      ]
+    },
+    "base-patterns": {
+      "patterns": [{ "include": "#statements" }, { "include": "#expressions" }]
     }
   }
 }